Api-Roll 54: 2017-09-11

generated/googleapis/test/youtube/v3_test.dart

 library googleapis.youtube.v3.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/youtube/v3.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);
 }
 
-buildUnnamed563() {
+buildUnnamed562() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed563(core.List<core.String> o) {
+checkUnnamed562(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 buildCounterAccessPolicy = 0;
 buildAccessPolicy() {
   var o = new api.AccessPolicy();
   buildCounterAccessPolicy++;
   if (buildCounterAccessPolicy < 3) {
     o.allowed = true;
-    o.exception = buildUnnamed563();
+    o.exception = buildUnnamed562();
   }
   buildCounterAccessPolicy--;
   return o;
 }
 
 checkAccessPolicy(api.AccessPolicy o) {
   buildCounterAccessPolicy++;
   if (buildCounterAccessPolicy < 3) {
     unittest.expect(o.allowed, unittest.isTrue);
-    checkUnnamed563(o.exception);
+    checkUnnamed562(o.exception);
   }
   buildCounterAccessPolicy--;
 }
 
 core.int buildCounterActivity = 0;
 buildActivity() {
   var o = new api.Activity();
   buildCounterActivity++;
   if (buildCounterActivity < 3) {
     o.contentDetails = buildActivityContentDetails();
@@ skipping 80 matching lines @@
 buildActivityContentDetailsChannelItem() {
   var o = new api.ActivityContentDetailsChannelItem();
   buildCounterActivityContentDetailsChannelItem++;
   if (buildCounterActivityContentDetailsChannelItem < 3) {
     o.resourceId = buildResourceId();
   }
   buildCounterActivityContentDetailsChannelItem--;
   return o;
 }
 
-checkActivityContentDetailsChannelItem(api.ActivityContentDetailsChannelItem o) {
+checkActivityContentDetailsChannelItem(
+    api.ActivityContentDetailsChannelItem o) {
   buildCounterActivityContentDetailsChannelItem++;
   if (buildCounterActivityContentDetailsChannelItem < 3) {
     checkResourceId(o.resourceId);
   }
   buildCounterActivityContentDetailsChannelItem--;
 }
 
 core.int buildCounterActivityContentDetailsComment = 0;
 buildActivityContentDetailsComment() {
   var o = new api.ActivityContentDetailsComment();
@@ skipping 57 matching lines @@
   buildCounterActivityContentDetailsPlaylistItem++;
   if (buildCounterActivityContentDetailsPlaylistItem < 3) {
     o.playlistId = "foo";
     o.playlistItemId = "foo";
     o.resourceId = buildResourceId();
   }
   buildCounterActivityContentDetailsPlaylistItem--;
   return o;
 }
 
-checkActivityContentDetailsPlaylistItem(api.ActivityContentDetailsPlaylistItem o) {
+checkActivityContentDetailsPlaylistItem(
+    api.ActivityContentDetailsPlaylistItem o) {
   buildCounterActivityContentDetailsPlaylistItem++;
   if (buildCounterActivityContentDetailsPlaylistItem < 3) {
     unittest.expect(o.playlistId, unittest.equals('foo'));
     unittest.expect(o.playlistItemId, unittest.equals('foo'));
     checkResourceId(o.resourceId);
   }
   buildCounterActivityContentDetailsPlaylistItem--;
 }
 
+buildUnnamed563() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed563(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'));
+}
+
 buildUnnamed564() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed564(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'));
-}
-
-buildUnnamed565() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed565(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 buildCounterActivityContentDetailsPromotedItem = 0;
 buildActivityContentDetailsPromotedItem() {
   var o = new api.ActivityContentDetailsPromotedItem();
   buildCounterActivityContentDetailsPromotedItem++;
   if (buildCounterActivityContentDetailsPromotedItem < 3) {
     o.adTag = "foo";
     o.clickTrackingUrl = "foo";
     o.creativeViewUrl = "foo";
     o.ctaType = "foo";
     o.customCtaButtonText = "foo";
     o.descriptionText = "foo";
     o.destinationUrl = "foo";
-    o.forecastingUrl = buildUnnamed564();
-    o.impressionUrl = buildUnnamed565();
+    o.forecastingUrl = buildUnnamed563();
+    o.impressionUrl = buildUnnamed564();
     o.videoId = "foo";
   }
   buildCounterActivityContentDetailsPromotedItem--;
   return o;
 }
 
-checkActivityContentDetailsPromotedItem(api.ActivityContentDetailsPromotedItem o) {
+checkActivityContentDetailsPromotedItem(
+    api.ActivityContentDetailsPromotedItem o) {
   buildCounterActivityContentDetailsPromotedItem++;
   if (buildCounterActivityContentDetailsPromotedItem < 3) {
     unittest.expect(o.adTag, unittest.equals('foo'));
     unittest.expect(o.clickTrackingUrl, unittest.equals('foo'));
     unittest.expect(o.creativeViewUrl, unittest.equals('foo'));
     unittest.expect(o.ctaType, unittest.equals('foo'));
     unittest.expect(o.customCtaButtonText, unittest.equals('foo'));
     unittest.expect(o.descriptionText, unittest.equals('foo'));
     unittest.expect(o.destinationUrl, unittest.equals('foo'));
-    checkUnnamed564(o.forecastingUrl);
-    checkUnnamed565(o.impressionUrl);
+    checkUnnamed563(o.forecastingUrl);
+    checkUnnamed564(o.impressionUrl);
     unittest.expect(o.videoId, unittest.equals('foo'));
   }
   buildCounterActivityContentDetailsPromotedItem--;
 }
 
 core.int buildCounterActivityContentDetailsRecommendation = 0;
 buildActivityContentDetailsRecommendation() {
   var o = new api.ActivityContentDetailsRecommendation();
   buildCounterActivityContentDetailsRecommendation++;
   if (buildCounterActivityContentDetailsRecommendation < 3) {
     o.reason = "foo";
     o.resourceId = buildResourceId();
     o.seedResourceId = buildResourceId();
   }
   buildCounterActivityContentDetailsRecommendation--;
   return o;
 }
 
-checkActivityContentDetailsRecommendation(api.ActivityContentDetailsRecommendation o) {
+checkActivityContentDetailsRecommendation(
+    api.ActivityContentDetailsRecommendation o) {
   buildCounterActivityContentDetailsRecommendation++;
   if (buildCounterActivityContentDetailsRecommendation < 3) {
     unittest.expect(o.reason, unittest.equals('foo'));
     checkResourceId(o.resourceId);
     checkResourceId(o.seedResourceId);
   }
   buildCounterActivityContentDetailsRecommendation--;
 }
 
 core.int buildCounterActivityContentDetailsSocial = 0;
@@ skipping 27 matching lines @@
 buildActivityContentDetailsSubscription() {
   var o = new api.ActivityContentDetailsSubscription();
   buildCounterActivityContentDetailsSubscription++;
   if (buildCounterActivityContentDetailsSubscription < 3) {
     o.resourceId = buildResourceId();
   }
   buildCounterActivityContentDetailsSubscription--;
   return o;
 }
 
-checkActivityContentDetailsSubscription(api.ActivityContentDetailsSubscription o) {
+checkActivityContentDetailsSubscription(
+    api.ActivityContentDetailsSubscription o) {
   buildCounterActivityContentDetailsSubscription++;
   if (buildCounterActivityContentDetailsSubscription < 3) {
     checkResourceId(o.resourceId);
   }
   buildCounterActivityContentDetailsSubscription--;
 }
 
 core.int buildCounterActivityContentDetailsUpload = 0;
 buildActivityContentDetailsUpload() {
   var o = new api.ActivityContentDetailsUpload();
   buildCounterActivityContentDetailsUpload++;
   if (buildCounterActivityContentDetailsUpload < 3) {
     o.videoId = "foo";
   }
   buildCounterActivityContentDetailsUpload--;
   return o;
 }
 
 checkActivityContentDetailsUpload(api.ActivityContentDetailsUpload o) {
   buildCounterActivityContentDetailsUpload++;
   if (buildCounterActivityContentDetailsUpload < 3) {
     unittest.expect(o.videoId, unittest.equals('foo'));
   }
   buildCounterActivityContentDetailsUpload--;
 }
 
-buildUnnamed566() {
+buildUnnamed565() {
   var o = new core.List<api.Activity>();
   o.add(buildActivity());
   o.add(buildActivity());
   return o;
 }
 
-checkUnnamed566(core.List<api.Activity> o) {
+checkUnnamed565(core.List<api.Activity> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkActivity(o[0]);
   checkActivity(o[1]);
 }
 
 core.int buildCounterActivityListResponse = 0;
 buildActivityListResponse() {
   var o = new api.ActivityListResponse();
   buildCounterActivityListResponse++;
   if (buildCounterActivityListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed566();
+    o.items = buildUnnamed565();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterActivityListResponse--;
   return o;
 }
 
 checkActivityListResponse(api.ActivityListResponse o) {
   buildCounterActivityListResponse++;
   if (buildCounterActivityListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed566(o.items);
+    checkUnnamed565(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterActivityListResponse--;
 }
 
@@ skipping 15 matching lines @@
   return o;
 }
 
 checkActivitySnippet(api.ActivitySnippet o) {
   buildCounterActivitySnippet++;
   if (buildCounterActivitySnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.groupId, unittest.equals('foo'));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterActivitySnippet--;
 }
 
 core.int buildCounterCaption = 0;
 buildCaption() {
   var o = new api.Caption();
@@ skipping 12 matching lines @@
   buildCounterCaption++;
   if (buildCounterCaption < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkCaptionSnippet(o.snippet);
   }
   buildCounterCaption--;
 }
 
-buildUnnamed567() {
+buildUnnamed566() {
   var o = new core.List<api.Caption>();
   o.add(buildCaption());
   o.add(buildCaption());
   return o;
 }
 
-checkUnnamed567(core.List<api.Caption> o) {
+checkUnnamed566(core.List<api.Caption> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCaption(o[0]);
   checkCaption(o[1]);
 }
 
 core.int buildCounterCaptionListResponse = 0;
 buildCaptionListResponse() {
   var o = new api.CaptionListResponse();
   buildCounterCaptionListResponse++;
   if (buildCounterCaptionListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed567();
+    o.items = buildUnnamed566();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterCaptionListResponse--;
   return o;
 }
 
 checkCaptionListResponse(api.CaptionListResponse o) {
   buildCounterCaptionListResponse++;
   if (buildCounterCaptionListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed567(o.items);
+    checkUnnamed566(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterCaptionListResponse--;
 }
 
 core.int buildCounterCaptionSnippet = 0;
 buildCaptionSnippet() {
   var o = new api.CaptionSnippet();
   buildCounterCaptionSnippet++;
@@ skipping 20 matching lines @@
   buildCounterCaptionSnippet++;
   if (buildCounterCaptionSnippet < 3) {
     unittest.expect(o.audioTrackType, unittest.equals('foo'));
     unittest.expect(o.failureReason, unittest.equals('foo'));
     unittest.expect(o.isAutoSynced, unittest.isTrue);
     unittest.expect(o.isCC, unittest.isTrue);
     unittest.expect(o.isDraft, unittest.isTrue);
     unittest.expect(o.isEasyReader, unittest.isTrue);
     unittest.expect(o.isLarge, unittest.isTrue);
     unittest.expect(o.language, unittest.equals('foo'));
-    unittest.expect(o.lastUpdated, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.lastUpdated,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     unittest.expect(o.trackKind, unittest.equals('foo'));
     unittest.expect(o.videoId, unittest.equals('foo'));
   }
   buildCounterCaptionSnippet--;
 }
 
 core.int buildCounterCdnSettings = 0;
 buildCdnSettings() {
@@ skipping 15 matching lines @@
   if (buildCounterCdnSettings < 3) {
     unittest.expect(o.format, unittest.equals('foo'));
     unittest.expect(o.frameRate, unittest.equals('foo'));
     checkIngestionInfo(o.ingestionInfo);
     unittest.expect(o.ingestionType, unittest.equals('foo'));
     unittest.expect(o.resolution, unittest.equals('foo'));
   }
   buildCounterCdnSettings--;
 }
 
-buildUnnamed568() {
+buildUnnamed567() {
   var o = new core.Map<core.String, api.ChannelLocalization>();
   o["x"] = buildChannelLocalization();
   o["y"] = buildChannelLocalization();
   return o;
 }
 
-checkUnnamed568(core.Map<core.String, api.ChannelLocalization> o) {
+checkUnnamed567(core.Map<core.String, api.ChannelLocalization> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChannelLocalization(o["x"]);
   checkChannelLocalization(o["y"]);
 }
 
 core.int buildCounterChannel = 0;
 buildChannel() {
   var o = new api.Channel();
   buildCounterChannel++;
   if (buildCounterChannel < 3) {
     o.auditDetails = buildChannelAuditDetails();
     o.brandingSettings = buildChannelBrandingSettings();
     o.contentDetails = buildChannelContentDetails();
     o.contentOwnerDetails = buildChannelContentOwnerDetails();
     o.conversionPings = buildChannelConversionPings();
     o.etag = "foo";
     o.id = "foo";
     o.invideoPromotion = buildInvideoPromotion();
     o.kind = "foo";
-    o.localizations = buildUnnamed568();
+    o.localizations = buildUnnamed567();
     o.snippet = buildChannelSnippet();
     o.statistics = buildChannelStatistics();
     o.status = buildChannelStatus();
     o.topicDetails = buildChannelTopicDetails();
   }
   buildCounterChannel--;
   return o;
 }
 
 checkChannel(api.Channel o) {
   buildCounterChannel++;
   if (buildCounterChannel < 3) {
     checkChannelAuditDetails(o.auditDetails);
     checkChannelBrandingSettings(o.brandingSettings);
     checkChannelContentDetails(o.contentDetails);
     checkChannelContentOwnerDetails(o.contentOwnerDetails);
     checkChannelConversionPings(o.conversionPings);
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     checkInvideoPromotion(o.invideoPromotion);
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed568(o.localizations);
+    checkUnnamed567(o.localizations);
     checkChannelSnippet(o.snippet);
     checkChannelStatistics(o.statistics);
     checkChannelStatus(o.status);
     checkChannelTopicDetails(o.topicDetails);
   }
   buildCounterChannel--;
 }
 
 core.int buildCounterChannelAuditDetails = 0;
 buildChannelAuditDetails() {
@@ skipping 36 matching lines @@
 checkChannelBannerResource(api.ChannelBannerResource o) {
   buildCounterChannelBannerResource++;
   if (buildCounterChannelBannerResource < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.url, unittest.equals('foo'));
   }
   buildCounterChannelBannerResource--;
 }
 
-buildUnnamed569() {
+buildUnnamed568() {
   var o = new core.List<api.PropertyValue>();
   o.add(buildPropertyValue());
   o.add(buildPropertyValue());
   return o;
 }
 
-checkUnnamed569(core.List<api.PropertyValue> o) {
+checkUnnamed568(core.List<api.PropertyValue> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPropertyValue(o[0]);
   checkPropertyValue(o[1]);
 }
 
 core.int buildCounterChannelBrandingSettings = 0;
 buildChannelBrandingSettings() {
   var o = new api.ChannelBrandingSettings();
   buildCounterChannelBrandingSettings++;
   if (buildCounterChannelBrandingSettings < 3) {
     o.channel = buildChannelSettings();
-    o.hints = buildUnnamed569();
+    o.hints = buildUnnamed568();
     o.image = buildImageSettings();
     o.watch = buildWatchSettings();
   }
   buildCounterChannelBrandingSettings--;
   return o;
 }
 
 checkChannelBrandingSettings(api.ChannelBrandingSettings o) {
   buildCounterChannelBrandingSettings++;
   if (buildCounterChannelBrandingSettings < 3) {
     checkChannelSettings(o.channel);
-    checkUnnamed569(o.hints);
+    checkUnnamed568(o.hints);
     checkImageSettings(o.image);
     checkWatchSettings(o.watch);
   }
   buildCounterChannelBrandingSettings--;
 }
 
 core.int buildCounterChannelContentDetailsRelatedPlaylists = 0;
 buildChannelContentDetailsRelatedPlaylists() {
   var o = new api.ChannelContentDetailsRelatedPlaylists();
   buildCounterChannelContentDetailsRelatedPlaylists++;
   if (buildCounterChannelContentDetailsRelatedPlaylists < 3) {
     o.favorites = "foo";
     o.likes = "foo";
     o.uploads = "foo";
     o.watchHistory = "foo";
     o.watchLater = "foo";
   }
   buildCounterChannelContentDetailsRelatedPlaylists--;
   return o;
 }
 
-checkChannelContentDetailsRelatedPlaylists(api.ChannelContentDetailsRelatedPlaylists o) {
+checkChannelContentDetailsRelatedPlaylists(
+    api.ChannelContentDetailsRelatedPlaylists o) {
   buildCounterChannelContentDetailsRelatedPlaylists++;
   if (buildCounterChannelContentDetailsRelatedPlaylists < 3) {
     unittest.expect(o.favorites, unittest.equals('foo'));
     unittest.expect(o.likes, unittest.equals('foo'));
     unittest.expect(o.uploads, unittest.equals('foo'));
     unittest.expect(o.watchHistory, unittest.equals('foo'));
     unittest.expect(o.watchLater, unittest.equals('foo'));
   }
   buildCounterChannelContentDetailsRelatedPlaylists--;
 }
@@ skipping 26 matching lines @@
     o.timeLinked = core.DateTime.parse("2002-02-27T14:01:02");
   }
   buildCounterChannelContentOwnerDetails--;
   return o;
 }
 
 checkChannelContentOwnerDetails(api.ChannelContentOwnerDetails o) {
   buildCounterChannelContentOwnerDetails++;
   if (buildCounterChannelContentOwnerDetails < 3) {
     unittest.expect(o.contentOwner, unittest.equals('foo'));
-    unittest.expect(o.timeLinked, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.timeLinked,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterChannelContentOwnerDetails--;
 }
 
 core.int buildCounterChannelConversionPing = 0;
 buildChannelConversionPing() {
   var o = new api.ChannelConversionPing();
   buildCounterChannelConversionPing++;
   if (buildCounterChannelConversionPing < 3) {
     o.context = "foo";
     o.conversionUrl = "foo";
   }
   buildCounterChannelConversionPing--;
   return o;
 }
 
 checkChannelConversionPing(api.ChannelConversionPing o) {
   buildCounterChannelConversionPing++;
   if (buildCounterChannelConversionPing < 3) {
     unittest.expect(o.context, unittest.equals('foo'));
     unittest.expect(o.conversionUrl, unittest.equals('foo'));
   }
   buildCounterChannelConversionPing--;
 }
 
-buildUnnamed570() {
+buildUnnamed569() {
   var o = new core.List<api.ChannelConversionPing>();
   o.add(buildChannelConversionPing());
   o.add(buildChannelConversionPing());
   return o;
 }
 
-checkUnnamed570(core.List<api.ChannelConversionPing> o) {
+checkUnnamed569(core.List<api.ChannelConversionPing> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChannelConversionPing(o[0]);
   checkChannelConversionPing(o[1]);
 }
 
 core.int buildCounterChannelConversionPings = 0;
 buildChannelConversionPings() {
   var o = new api.ChannelConversionPings();
   buildCounterChannelConversionPings++;
   if (buildCounterChannelConversionPings < 3) {
-    o.pings = buildUnnamed570();
+    o.pings = buildUnnamed569();
   }
   buildCounterChannelConversionPings--;
   return o;
 }
 
 checkChannelConversionPings(api.ChannelConversionPings o) {
   buildCounterChannelConversionPings++;
   if (buildCounterChannelConversionPings < 3) {
-    checkUnnamed570(o.pings);
+    checkUnnamed569(o.pings);
   }
   buildCounterChannelConversionPings--;
 }
 
-buildUnnamed571() {
+buildUnnamed570() {
   var o = new core.List<api.Channel>();
   o.add(buildChannel());
   o.add(buildChannel());
   return o;
 }
 
-checkUnnamed571(core.List<api.Channel> o) {
+checkUnnamed570(core.List<api.Channel> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChannel(o[0]);
   checkChannel(o[1]);
 }
 
 core.int buildCounterChannelListResponse = 0;
 buildChannelListResponse() {
   var o = new api.ChannelListResponse();
   buildCounterChannelListResponse++;
   if (buildCounterChannelListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed571();
+    o.items = buildUnnamed570();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterChannelListResponse--;
   return o;
 }
 
 checkChannelListResponse(api.ChannelListResponse o) {
   buildCounterChannelListResponse++;
   if (buildCounterChannelListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed571(o.items);
+    checkUnnamed570(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterChannelListResponse--;
 }
 
@@ skipping 36 matching lines @@
   buildCounterChannelProfileDetails++;
   if (buildCounterChannelProfileDetails < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelUrl, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.profileImageUrl, unittest.equals('foo'));
   }
   buildCounterChannelProfileDetails--;
 }
 
-buildUnnamed572() {
+buildUnnamed571() {
   var o = new core.Map<core.String, api.ChannelSectionLocalization>();
   o["x"] = buildChannelSectionLocalization();
   o["y"] = buildChannelSectionLocalization();
   return o;
 }
 
-checkUnnamed572(core.Map<core.String, api.ChannelSectionLocalization> o) {
+checkUnnamed571(core.Map<core.String, api.ChannelSectionLocalization> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChannelSectionLocalization(o["x"]);
   checkChannelSectionLocalization(o["y"]);
 }
 
 core.int buildCounterChannelSection = 0;
 buildChannelSection() {
   var o = new api.ChannelSection();
   buildCounterChannelSection++;
   if (buildCounterChannelSection < 3) {
     o.contentDetails = buildChannelSectionContentDetails();
     o.etag = "foo";
     o.id = "foo";
     o.kind = "foo";
-    o.localizations = buildUnnamed572();
+    o.localizations = buildUnnamed571();
     o.snippet = buildChannelSectionSnippet();
     o.targeting = buildChannelSectionTargeting();
   }
   buildCounterChannelSection--;
   return o;
 }
 
 checkChannelSection(api.ChannelSection o) {
   buildCounterChannelSection++;
   if (buildCounterChannelSection < 3) {
     checkChannelSectionContentDetails(o.contentDetails);
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed572(o.localizations);
+    checkUnnamed571(o.localizations);
     checkChannelSectionSnippet(o.snippet);
     checkChannelSectionTargeting(o.targeting);
   }
   buildCounterChannelSection--;
 }
 
+buildUnnamed572() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed572(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'));
+}
+
 buildUnnamed573() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed573(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'));
-}
-
-buildUnnamed574() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed574(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 buildCounterChannelSectionContentDetails = 0;
 buildChannelSectionContentDetails() {
   var o = new api.ChannelSectionContentDetails();
   buildCounterChannelSectionContentDetails++;
   if (buildCounterChannelSectionContentDetails < 3) {
-    o.channels = buildUnnamed573();
-    o.playlists = buildUnnamed574();
+    o.channels = buildUnnamed572();
+    o.playlists = buildUnnamed573();
   }
   buildCounterChannelSectionContentDetails--;
   return o;
 }
 
 checkChannelSectionContentDetails(api.ChannelSectionContentDetails o) {
   buildCounterChannelSectionContentDetails++;
   if (buildCounterChannelSectionContentDetails < 3) {
-    checkUnnamed573(o.channels);
-    checkUnnamed574(o.playlists);
+    checkUnnamed572(o.channels);
+    checkUnnamed573(o.playlists);
   }
   buildCounterChannelSectionContentDetails--;
 }
 
-buildUnnamed575() {
+buildUnnamed574() {
   var o = new core.List<api.ChannelSection>();
   o.add(buildChannelSection());
   o.add(buildChannelSection());
   return o;
 }
 
-checkUnnamed575(core.List<api.ChannelSection> o) {
+checkUnnamed574(core.List<api.ChannelSection> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChannelSection(o[0]);
   checkChannelSection(o[1]);
 }
 
 core.int buildCounterChannelSectionListResponse = 0;
 buildChannelSectionListResponse() {
   var o = new api.ChannelSectionListResponse();
   buildCounterChannelSectionListResponse++;
   if (buildCounterChannelSectionListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed575();
+    o.items = buildUnnamed574();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterChannelSectionListResponse--;
   return o;
 }
 
 checkChannelSectionListResponse(api.ChannelSectionListResponse o) {
   buildCounterChannelSectionListResponse++;
   if (buildCounterChannelSectionListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed575(o.items);
+    checkUnnamed574(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterChannelSectionListResponse--;
 }
 
 core.int buildCounterChannelSectionLocalization = 0;
 buildChannelSectionLocalization() {
   var o = new api.ChannelSectionLocalization();
   buildCounterChannelSectionLocalization++;
@@ skipping 36 matching lines @@
     unittest.expect(o.defaultLanguage, unittest.equals('foo'));
     checkChannelSectionLocalization(o.localized);
     unittest.expect(o.position, unittest.equals(42));
     unittest.expect(o.style, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterChannelSectionSnippet--;
 }
 
+buildUnnamed575() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed575(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'));
+}
+
 buildUnnamed576() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed576(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'));
 }
 
 buildUnnamed577() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed577(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'));
-}
-
-buildUnnamed578() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed578(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 buildCounterChannelSectionTargeting = 0;
 buildChannelSectionTargeting() {
   var o = new api.ChannelSectionTargeting();
   buildCounterChannelSectionTargeting++;
   if (buildCounterChannelSectionTargeting < 3) {
-    o.countries = buildUnnamed576();
-    o.languages = buildUnnamed577();
-    o.regions = buildUnnamed578();
+    o.countries = buildUnnamed575();
+    o.languages = buildUnnamed576();
+    o.regions = buildUnnamed577();
   }
   buildCounterChannelSectionTargeting--;
   return o;
 }
 
 checkChannelSectionTargeting(api.ChannelSectionTargeting o) {
   buildCounterChannelSectionTargeting++;
   if (buildCounterChannelSectionTargeting < 3) {
-    checkUnnamed576(o.countries);
-    checkUnnamed577(o.languages);
-    checkUnnamed578(o.regions);
+    checkUnnamed575(o.countries);
+    checkUnnamed576(o.languages);
+    checkUnnamed577(o.regions);
   }
   buildCounterChannelSectionTargeting--;
 }
 
-buildUnnamed579() {
+buildUnnamed578() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed579(core.List<core.String> o) {
+checkUnnamed578(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 buildCounterChannelSettings = 0;
 buildChannelSettings() {
   var o = new api.ChannelSettings();
   buildCounterChannelSettings++;
   if (buildCounterChannelSettings < 3) {
     o.country = "foo";
     o.defaultLanguage = "foo";
     o.defaultTab = "foo";
     o.description = "foo";
     o.featuredChannelsTitle = "foo";
-    o.featuredChannelsUrls = buildUnnamed579();
+    o.featuredChannelsUrls = buildUnnamed578();
     o.keywords = "foo";
     o.moderateComments = true;
     o.profileColor = "foo";
     o.showBrowseView = true;
     o.showRelatedChannels = true;
     o.title = "foo";
     o.trackingAnalyticsAccountId = "foo";
     o.unsubscribedTrailer = "foo";
   }
   buildCounterChannelSettings--;
   return o;
 }
 
 checkChannelSettings(api.ChannelSettings o) {
   buildCounterChannelSettings++;
   if (buildCounterChannelSettings < 3) {
     unittest.expect(o.country, unittest.equals('foo'));
     unittest.expect(o.defaultLanguage, unittest.equals('foo'));
     unittest.expect(o.defaultTab, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.featuredChannelsTitle, unittest.equals('foo'));
-    checkUnnamed579(o.featuredChannelsUrls);
+    checkUnnamed578(o.featuredChannelsUrls);
     unittest.expect(o.keywords, unittest.equals('foo'));
     unittest.expect(o.moderateComments, unittest.isTrue);
     unittest.expect(o.profileColor, unittest.equals('foo'));
     unittest.expect(o.showBrowseView, unittest.isTrue);
     unittest.expect(o.showRelatedChannels, unittest.isTrue);
     unittest.expect(o.title, unittest.equals('foo'));
     unittest.expect(o.trackingAnalyticsAccountId, unittest.equals('foo'));
     unittest.expect(o.unsubscribedTrailer, unittest.equals('foo'));
   }
   buildCounterChannelSettings--;
@@ skipping 18 matching lines @@
 }
 
 checkChannelSnippet(api.ChannelSnippet o) {
   buildCounterChannelSnippet++;
   if (buildCounterChannelSnippet < 3) {
     unittest.expect(o.country, unittest.equals('foo'));
     unittest.expect(o.customUrl, unittest.equals('foo'));
     unittest.expect(o.defaultLanguage, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkChannelLocalization(o.localized);
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterChannelSnippet--;
 }
 
 core.int buildCounterChannelStatistics = 0;
 buildChannelStatistics() {
   var o = new api.ChannelStatistics();
   buildCounterChannelStatistics++;
@@ skipping 36 matching lines @@
 checkChannelStatus(api.ChannelStatus o) {
   buildCounterChannelStatus++;
   if (buildCounterChannelStatus < 3) {
     unittest.expect(o.isLinked, unittest.isTrue);
     unittest.expect(o.longUploadsStatus, unittest.equals('foo'));
     unittest.expect(o.privacyStatus, unittest.equals('foo'));
   }
   buildCounterChannelStatus--;
 }
 
+buildUnnamed579() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed579(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'));
+}
+
 buildUnnamed580() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed580(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'));
-}
-
-buildUnnamed581() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed581(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 buildCounterChannelTopicDetails = 0;
 buildChannelTopicDetails() {
   var o = new api.ChannelTopicDetails();
   buildCounterChannelTopicDetails++;
   if (buildCounterChannelTopicDetails < 3) {
-    o.topicCategories = buildUnnamed580();
-    o.topicIds = buildUnnamed581();
+    o.topicCategories = buildUnnamed579();
+    o.topicIds = buildUnnamed580();
   }
   buildCounterChannelTopicDetails--;
   return o;
 }
 
 checkChannelTopicDetails(api.ChannelTopicDetails o) {
   buildCounterChannelTopicDetails++;
   if (buildCounterChannelTopicDetails < 3) {
-    checkUnnamed580(o.topicCategories);
-    checkUnnamed581(o.topicIds);
+    checkUnnamed579(o.topicCategories);
+    checkUnnamed580(o.topicIds);
   }
   buildCounterChannelTopicDetails--;
 }
 
 core.int buildCounterComment = 0;
 buildComment() {
   var o = new api.Comment();
   buildCounterComment++;
   if (buildCounterComment < 3) {
     o.etag = "foo";
     o.id = "foo";
     o.kind = "foo";
     o.snippet = buildCommentSnippet();
   }
   buildCounterComment--;
   return o;
 }
 
 checkComment(api.Comment o) {
   buildCounterComment++;
   if (buildCounterComment < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkCommentSnippet(o.snippet);
   }
   buildCounterComment--;
 }
 
-buildUnnamed582() {
+buildUnnamed581() {
   var o = new core.List<api.Comment>();
   o.add(buildComment());
   o.add(buildComment());
   return o;
 }
 
-checkUnnamed582(core.List<api.Comment> o) {
+checkUnnamed581(core.List<api.Comment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkComment(o[0]);
   checkComment(o[1]);
 }
 
 core.int buildCounterCommentListResponse = 0;
 buildCommentListResponse() {
   var o = new api.CommentListResponse();
   buildCounterCommentListResponse++;
   if (buildCounterCommentListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed582();
+    o.items = buildUnnamed581();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterCommentListResponse--;
   return o;
 }
 
 checkCommentListResponse(api.CommentListResponse o) {
   buildCounterCommentListResponse++;
   if (buildCounterCommentListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed582(o.items);
+    checkUnnamed581(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterCommentListResponse--;
 }
 
 core.int buildCounterCommentSnippet = 0;
 buildCommentSnippet() {
   var o = new api.CommentSnippet();
   buildCounterCommentSnippet++;
   if (buildCounterCommentSnippet < 3) {
-    o.authorChannelId = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+    o.authorChannelId = {
+      'list': [1, 2, 3],
+      'bool': true,
+      'string': 'foo'
+    };
     o.authorChannelUrl = "foo";
     o.authorDisplayName = "foo";
     o.authorProfileImageUrl = "foo";
     o.canRate = true;
     o.channelId = "foo";
     o.likeCount = 42;
     o.moderationStatus = "foo";
     o.parentId = "foo";
     o.publishedAt = core.DateTime.parse("2002-02-27T14:01:02");
     o.textDisplay = "foo";
     o.textOriginal = "foo";
     o.updatedAt = core.DateTime.parse("2002-02-27T14:01:02");
     o.videoId = "foo";
     o.viewerRating = "foo";
   }
   buildCounterCommentSnippet--;
   return o;
 }
 
 checkCommentSnippet(api.CommentSnippet o) {
   buildCounterCommentSnippet++;
   if (buildCounterCommentSnippet < 3) {
-    var casted1 = (o.authorChannelId) 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 casted1 = (o.authorChannelId) 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'));
     unittest.expect(o.authorChannelUrl, unittest.equals('foo'));
     unittest.expect(o.authorDisplayName, unittest.equals('foo'));
     unittest.expect(o.authorProfileImageUrl, unittest.equals('foo'));
     unittest.expect(o.canRate, unittest.isTrue);
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.likeCount, unittest.equals(42));
     unittest.expect(o.moderationStatus, unittest.equals('foo'));
     unittest.expect(o.parentId, unittest.equals('foo'));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.textDisplay, unittest.equals('foo'));
     unittest.expect(o.textOriginal, unittest.equals('foo'));
-    unittest.expect(o.updatedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.updatedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.videoId, unittest.equals('foo'));
     unittest.expect(o.viewerRating, unittest.equals('foo'));
   }
   buildCounterCommentSnippet--;
 }
 
 core.int buildCounterCommentThread = 0;
 buildCommentThread() {
   var o = new api.CommentThread();
   buildCounterCommentThread++;
@@ skipping 13 matching lines @@
   if (buildCounterCommentThread < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkCommentThreadReplies(o.replies);
     checkCommentThreadSnippet(o.snippet);
   }
   buildCounterCommentThread--;
 }
 
-buildUnnamed583() {
+buildUnnamed582() {
   var o = new core.List<api.CommentThread>();
   o.add(buildCommentThread());
   o.add(buildCommentThread());
   return o;
 }
 
-checkUnnamed583(core.List<api.CommentThread> o) {
+checkUnnamed582(core.List<api.CommentThread> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCommentThread(o[0]);
   checkCommentThread(o[1]);
 }
 
 core.int buildCounterCommentThreadListResponse = 0;
 buildCommentThreadListResponse() {
   var o = new api.CommentThreadListResponse();
   buildCounterCommentThreadListResponse++;
   if (buildCounterCommentThreadListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed583();
+    o.items = buildUnnamed582();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterCommentThreadListResponse--;
   return o;
 }
 
 checkCommentThreadListResponse(api.CommentThreadListResponse o) {
   buildCounterCommentThreadListResponse++;
   if (buildCounterCommentThreadListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed583(o.items);
+    checkUnnamed582(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterCommentThreadListResponse--;
 }
 
-buildUnnamed584() {
+buildUnnamed583() {
   var o = new core.List<api.Comment>();
   o.add(buildComment());
   o.add(buildComment());
   return o;
 }
 
-checkUnnamed584(core.List<api.Comment> o) {
+checkUnnamed583(core.List<api.Comment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkComment(o[0]);
   checkComment(o[1]);
 }
 
 core.int buildCounterCommentThreadReplies = 0;
 buildCommentThreadReplies() {
   var o = new api.CommentThreadReplies();
   buildCounterCommentThreadReplies++;
   if (buildCounterCommentThreadReplies < 3) {
-    o.comments = buildUnnamed584();
+    o.comments = buildUnnamed583();
   }
   buildCounterCommentThreadReplies--;
   return o;
 }
 
 checkCommentThreadReplies(api.CommentThreadReplies o) {
   buildCounterCommentThreadReplies++;
   if (buildCounterCommentThreadReplies < 3) {
-    checkUnnamed584(o.comments);
+    checkUnnamed583(o.comments);
   }
   buildCounterCommentThreadReplies--;
 }
 
 core.int buildCounterCommentThreadSnippet = 0;
 buildCommentThreadSnippet() {
   var o = new api.CommentThreadSnippet();
   buildCounterCommentThreadSnippet++;
   if (buildCounterCommentThreadSnippet < 3) {
     o.canReply = true;
@@ skipping 13 matching lines @@
     unittest.expect(o.canReply, unittest.isTrue);
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.isPublic, unittest.isTrue);
     checkComment(o.topLevelComment);
     unittest.expect(o.totalReplyCount, unittest.equals(42));
     unittest.expect(o.videoId, unittest.equals('foo'));
   }
   buildCounterCommentThreadSnippet--;
 }
 
+buildUnnamed584() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed584(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'));
+}
+
 buildUnnamed585() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed585(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'));
-}
-
-buildUnnamed586() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed586(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 buildCounterContentRating = 0;
 buildContentRating() {
   var o = new api.ContentRating();
   buildCounterContentRating++;
   if (buildCounterContentRating < 3) {
     o.acbRating = "foo";
     o.agcomRating = "foo";
     o.anatelRating = "foo";
     o.bbfcRating = "foo";
     o.bfvcRating = "foo";
     o.bmukkRating = "foo";
     o.catvRating = "foo";
     o.catvfrRating = "foo";
     o.cbfcRating = "foo";
     o.cccRating = "foo";
     o.cceRating = "foo";
     o.chfilmRating = "foo";
     o.chvrsRating = "foo";
     o.cicfRating = "foo";
     o.cnaRating = "foo";
     o.cncRating = "foo";
     o.csaRating = "foo";
     o.cscfRating = "foo";
     o.czfilmRating = "foo";
     o.djctqRating = "foo";
-    o.djctqRatingReasons = buildUnnamed585();
+    o.djctqRatingReasons = buildUnnamed584();
     o.ecbmctRating = "foo";
     o.eefilmRating = "foo";
     o.egfilmRating = "foo";
     o.eirinRating = "foo";
     o.fcbmRating = "foo";
     o.fcoRating = "foo";
     o.fmocRating = "foo";
     o.fpbRating = "foo";
-    o.fpbRatingReasons = buildUnnamed586();
+    o.fpbRatingReasons = buildUnnamed585();
     o.fskRating = "foo";
     o.grfilmRating = "foo";
     o.icaaRating = "foo";
     o.ifcoRating = "foo";
     o.ilfilmRating = "foo";
     o.incaaRating = "foo";
     o.kfcbRating = "foo";
     o.kijkwijzerRating = "foo";
     o.kmrbRating = "foo";
     o.lsfRating = "foo";
@@ skipping 46 matching lines @@
     unittest.expect(o.cceRating, unittest.equals('foo'));
     unittest.expect(o.chfilmRating, unittest.equals('foo'));
     unittest.expect(o.chvrsRating, unittest.equals('foo'));
     unittest.expect(o.cicfRating, unittest.equals('foo'));
     unittest.expect(o.cnaRating, unittest.equals('foo'));
     unittest.expect(o.cncRating, unittest.equals('foo'));
     unittest.expect(o.csaRating, unittest.equals('foo'));
     unittest.expect(o.cscfRating, unittest.equals('foo'));
     unittest.expect(o.czfilmRating, unittest.equals('foo'));
     unittest.expect(o.djctqRating, unittest.equals('foo'));
-    checkUnnamed585(o.djctqRatingReasons);
+    checkUnnamed584(o.djctqRatingReasons);
     unittest.expect(o.ecbmctRating, unittest.equals('foo'));
     unittest.expect(o.eefilmRating, unittest.equals('foo'));
     unittest.expect(o.egfilmRating, unittest.equals('foo'));
     unittest.expect(o.eirinRating, unittest.equals('foo'));
     unittest.expect(o.fcbmRating, unittest.equals('foo'));
     unittest.expect(o.fcoRating, unittest.equals('foo'));
     unittest.expect(o.fmocRating, unittest.equals('foo'));
     unittest.expect(o.fpbRating, unittest.equals('foo'));
-    checkUnnamed586(o.fpbRatingReasons);
+    checkUnnamed585(o.fpbRatingReasons);
     unittest.expect(o.fskRating, unittest.equals('foo'));
     unittest.expect(o.grfilmRating, unittest.equals('foo'));
     unittest.expect(o.icaaRating, unittest.equals('foo'));
     unittest.expect(o.ifcoRating, unittest.equals('foo'));
     unittest.expect(o.ilfilmRating, unittest.equals('foo'));
     unittest.expect(o.incaaRating, unittest.equals('foo'));
     unittest.expect(o.kfcbRating, unittest.equals('foo'));
     unittest.expect(o.kijkwijzerRating, unittest.equals('foo'));
     unittest.expect(o.kmrbRating, unittest.equals('foo'));
     unittest.expect(o.lsfRating, unittest.equals('foo'));
@@ skipping 47 matching lines @@
   buildCounterFanFundingEvent++;
   if (buildCounterFanFundingEvent < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkFanFundingEventSnippet(o.snippet);
   }
   buildCounterFanFundingEvent--;
 }
 
-buildUnnamed587() {
+buildUnnamed586() {
   var o = new core.List<api.FanFundingEvent>();
   o.add(buildFanFundingEvent());
   o.add(buildFanFundingEvent());
   return o;
 }
 
-checkUnnamed587(core.List<api.FanFundingEvent> o) {
+checkUnnamed586(core.List<api.FanFundingEvent> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkFanFundingEvent(o[0]);
   checkFanFundingEvent(o[1]);
 }
 
 core.int buildCounterFanFundingEventListResponse = 0;
 buildFanFundingEventListResponse() {
   var o = new api.FanFundingEventListResponse();
   buildCounterFanFundingEventListResponse++;
   if (buildCounterFanFundingEventListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed587();
+    o.items = buildUnnamed586();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterFanFundingEventListResponse--;
   return o;
 }
 
 checkFanFundingEventListResponse(api.FanFundingEventListResponse o) {
   buildCounterFanFundingEventListResponse++;
   if (buildCounterFanFundingEventListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed587(o.items);
+    checkUnnamed586(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterFanFundingEventListResponse--;
 }
 
 core.int buildCounterFanFundingEventSnippet = 0;
@@ skipping 12 matching lines @@
   buildCounterFanFundingEventSnippet--;
   return o;
 }
 
 checkFanFundingEventSnippet(api.FanFundingEventSnippet o) {
   buildCounterFanFundingEventSnippet++;
   if (buildCounterFanFundingEventSnippet < 3) {
     unittest.expect(o.amountMicros, unittest.equals('foo'));
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.commentText, unittest.equals('foo'));
-    unittest.expect(o.createdAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.createdAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.currency, unittest.equals('foo'));
     unittest.expect(o.displayString, unittest.equals('foo'));
     checkChannelProfileDetails(o.supporterDetails);
   }
   buildCounterFanFundingEventSnippet--;
 }
 
 core.int buildCounterGeoPoint = 0;
 buildGeoPoint() {
   var o = new api.GeoPoint();
@@ skipping 35 matching lines @@
   buildCounterGuideCategory++;
   if (buildCounterGuideCategory < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkGuideCategorySnippet(o.snippet);
   }
   buildCounterGuideCategory--;
 }
 
-buildUnnamed588() {
+buildUnnamed587() {
   var o = new core.List<api.GuideCategory>();
   o.add(buildGuideCategory());
   o.add(buildGuideCategory());
   return o;
 }
 
-checkUnnamed588(core.List<api.GuideCategory> o) {
+checkUnnamed587(core.List<api.GuideCategory> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkGuideCategory(o[0]);
   checkGuideCategory(o[1]);
 }
 
 core.int buildCounterGuideCategoryListResponse = 0;
 buildGuideCategoryListResponse() {
   var o = new api.GuideCategoryListResponse();
   buildCounterGuideCategoryListResponse++;
   if (buildCounterGuideCategoryListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed588();
+    o.items = buildUnnamed587();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterGuideCategoryListResponse--;
   return o;
 }
 
 checkGuideCategoryListResponse(api.GuideCategoryListResponse o) {
   buildCounterGuideCategoryListResponse++;
   if (buildCounterGuideCategoryListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed588(o.items);
+    checkUnnamed587(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterGuideCategoryListResponse--;
 }
 
@@ skipping 36 matching lines @@
   buildCounterI18nLanguage++;
   if (buildCounterI18nLanguage < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkI18nLanguageSnippet(o.snippet);
   }
   buildCounterI18nLanguage--;
 }
 
-buildUnnamed589() {
+buildUnnamed588() {
   var o = new core.List<api.I18nLanguage>();
   o.add(buildI18nLanguage());
   o.add(buildI18nLanguage());
   return o;
 }
 
-checkUnnamed589(core.List<api.I18nLanguage> o) {
+checkUnnamed588(core.List<api.I18nLanguage> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkI18nLanguage(o[0]);
   checkI18nLanguage(o[1]);
 }
 
 core.int buildCounterI18nLanguageListResponse = 0;
 buildI18nLanguageListResponse() {
   var o = new api.I18nLanguageListResponse();
   buildCounterI18nLanguageListResponse++;
   if (buildCounterI18nLanguageListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed589();
+    o.items = buildUnnamed588();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterI18nLanguageListResponse--;
   return o;
 }
 
 checkI18nLanguageListResponse(api.I18nLanguageListResponse o) {
   buildCounterI18nLanguageListResponse++;
   if (buildCounterI18nLanguageListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed589(o.items);
+    checkUnnamed588(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterI18nLanguageListResponse--;
 }
 
 core.int buildCounterI18nLanguageSnippet = 0;
 buildI18nLanguageSnippet() {
   var o = new api.I18nLanguageSnippet();
   buildCounterI18nLanguageSnippet++;
@@ skipping 32 matching lines @@
   buildCounterI18nRegion++;
   if (buildCounterI18nRegion < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkI18nRegionSnippet(o.snippet);
   }
   buildCounterI18nRegion--;
 }
 
-buildUnnamed590() {
+buildUnnamed589() {
   var o = new core.List<api.I18nRegion>();
   o.add(buildI18nRegion());
   o.add(buildI18nRegion());
   return o;
 }
 
-checkUnnamed590(core.List<api.I18nRegion> o) {
+checkUnnamed589(core.List<api.I18nRegion> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkI18nRegion(o[0]);
   checkI18nRegion(o[1]);
 }
 
 core.int buildCounterI18nRegionListResponse = 0;
 buildI18nRegionListResponse() {
   var o = new api.I18nRegionListResponse();
   buildCounterI18nRegionListResponse++;
   if (buildCounterI18nRegionListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed590();
+    o.items = buildUnnamed589();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterI18nRegionListResponse--;
   return o;
 }
 
 checkI18nRegionListResponse(api.I18nRegionListResponse o) {
   buildCounterI18nRegionListResponse++;
   if (buildCounterI18nRegionListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed590(o.items);
+    checkUnnamed589(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterI18nRegionListResponse--;
 }
 
 core.int buildCounterI18nRegionSnippet = 0;
 buildI18nRegionSnippet() {
   var o = new api.I18nRegionSnippet();
   buildCounterI18nRegionSnippet++;
@@ skipping 139 matching lines @@
 
 checkInvideoPosition(api.InvideoPosition o) {
   buildCounterInvideoPosition++;
   if (buildCounterInvideoPosition < 3) {
     unittest.expect(o.cornerPosition, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterInvideoPosition--;
 }
 
-buildUnnamed591() {
+buildUnnamed590() {
   var o = new core.List<api.PromotedItem>();
   o.add(buildPromotedItem());
   o.add(buildPromotedItem());
   return o;
 }
 
-checkUnnamed591(core.List<api.PromotedItem> o) {
+checkUnnamed590(core.List<api.PromotedItem> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPromotedItem(o[0]);
   checkPromotedItem(o[1]);
 }
 
 core.int buildCounterInvideoPromotion = 0;
 buildInvideoPromotion() {
   var o = new api.InvideoPromotion();
   buildCounterInvideoPromotion++;
   if (buildCounterInvideoPromotion < 3) {
     o.defaultTiming = buildInvideoTiming();
-    o.items = buildUnnamed591();
+    o.items = buildUnnamed590();
     o.position = buildInvideoPosition();
     o.useSmartTiming = true;
   }
   buildCounterInvideoPromotion--;
   return o;
 }
 
 checkInvideoPromotion(api.InvideoPromotion o) {
   buildCounterInvideoPromotion++;
   if (buildCounterInvideoPromotion < 3) {
     checkInvideoTiming(o.defaultTiming);
-    checkUnnamed591(o.items);
+    checkUnnamed590(o.items);
     checkInvideoPosition(o.position);
     unittest.expect(o.useSmartTiming, unittest.isTrue);
   }
   buildCounterInvideoPromotion--;
 }
 
 core.int buildCounterInvideoTiming = 0;
 buildInvideoTiming() {
   var o = new api.InvideoTiming();
   buildCounterInvideoTiming++;
@@ skipping 87 matching lines @@
     o.startWithSlate = true;
   }
   buildCounterLiveBroadcastContentDetails--;
   return o;
 }
 
 checkLiveBroadcastContentDetails(api.LiveBroadcastContentDetails o) {
   buildCounterLiveBroadcastContentDetails++;
   if (buildCounterLiveBroadcastContentDetails < 3) {
     unittest.expect(o.boundStreamId, unittest.equals('foo'));
-    unittest.expect(o.boundStreamLastUpdateTimeMs, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.boundStreamLastUpdateTimeMs,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.closedCaptionsType, unittest.equals('foo'));
     unittest.expect(o.enableClosedCaptions, unittest.isTrue);
     unittest.expect(o.enableContentEncryption, unittest.isTrue);
     unittest.expect(o.enableDvr, unittest.isTrue);
     unittest.expect(o.enableEmbed, unittest.isTrue);
     unittest.expect(o.enableLowLatency, unittest.isTrue);
     checkMonitorStreamInfo(o.monitorStream);
     unittest.expect(o.projection, unittest.equals('foo'));
     unittest.expect(o.recordFromStart, unittest.isTrue);
     unittest.expect(o.startWithSlate, unittest.isTrue);
   }
   buildCounterLiveBroadcastContentDetails--;
 }
 
-buildUnnamed592() {
+buildUnnamed591() {
   var o = new core.List<api.LiveBroadcast>();
   o.add(buildLiveBroadcast());
   o.add(buildLiveBroadcast());
   return o;
 }
 
-checkUnnamed592(core.List<api.LiveBroadcast> o) {
+checkUnnamed591(core.List<api.LiveBroadcast> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveBroadcast(o[0]);
   checkLiveBroadcast(o[1]);
 }
 
 core.int buildCounterLiveBroadcastListResponse = 0;
 buildLiveBroadcastListResponse() {
   var o = new api.LiveBroadcastListResponse();
   buildCounterLiveBroadcastListResponse++;
   if (buildCounterLiveBroadcastListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed592();
+    o.items = buildUnnamed591();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterLiveBroadcastListResponse--;
   return o;
 }
 
 checkLiveBroadcastListResponse(api.LiveBroadcastListResponse o) {
   buildCounterLiveBroadcastListResponse++;
   if (buildCounterLiveBroadcastListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed592(o.items);
+    checkUnnamed591(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterLiveBroadcastListResponse--;
 }
 
@@ skipping 14 matching lines @@
     o.thumbnails = buildThumbnailDetails();
     o.title = "foo";
   }
   buildCounterLiveBroadcastSnippet--;
   return o;
 }
 
 checkLiveBroadcastSnippet(api.LiveBroadcastSnippet o) {
   buildCounterLiveBroadcastSnippet++;
   if (buildCounterLiveBroadcastSnippet < 3) {
-    unittest.expect(o.actualEndTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    unittest.expect(o.actualStartTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.actualEndTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.actualStartTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.isDefaultBroadcast, unittest.isTrue);
     unittest.expect(o.liveChatId, unittest.equals('foo'));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    unittest.expect(o.scheduledEndTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    unittest.expect(o.scheduledStartTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.scheduledEndTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.scheduledStartTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterLiveBroadcastSnippet--;
 }
 
 core.int buildCounterLiveBroadcastStatistics = 0;
 buildLiveBroadcastStatistics() {
   var o = new api.LiveBroadcastStatistics();
   buildCounterLiveBroadcastStatistics++;
@@ skipping 55 matching lines @@
 checkLiveBroadcastTopic(api.LiveBroadcastTopic o) {
   buildCounterLiveBroadcastTopic++;
   if (buildCounterLiveBroadcastTopic < 3) {
     checkLiveBroadcastTopicSnippet(o.snippet);
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.unmatched, unittest.isTrue);
   }
   buildCounterLiveBroadcastTopic--;
 }
 
-buildUnnamed593() {
+buildUnnamed592() {
   var o = new core.List<api.LiveBroadcastTopic>();
   o.add(buildLiveBroadcastTopic());
   o.add(buildLiveBroadcastTopic());
   return o;
 }
 
-checkUnnamed593(core.List<api.LiveBroadcastTopic> o) {
+checkUnnamed592(core.List<api.LiveBroadcastTopic> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveBroadcastTopic(o[0]);
   checkLiveBroadcastTopic(o[1]);
 }
 
 core.int buildCounterLiveBroadcastTopicDetails = 0;
 buildLiveBroadcastTopicDetails() {
   var o = new api.LiveBroadcastTopicDetails();
   buildCounterLiveBroadcastTopicDetails++;
   if (buildCounterLiveBroadcastTopicDetails < 3) {
-    o.topics = buildUnnamed593();
+    o.topics = buildUnnamed592();
   }
   buildCounterLiveBroadcastTopicDetails--;
   return o;
 }
 
 checkLiveBroadcastTopicDetails(api.LiveBroadcastTopicDetails o) {
   buildCounterLiveBroadcastTopicDetails++;
   if (buildCounterLiveBroadcastTopicDetails < 3) {
-    checkUnnamed593(o.topics);
+    checkUnnamed592(o.topics);
   }
   buildCounterLiveBroadcastTopicDetails--;
 }
 
 core.int buildCounterLiveBroadcastTopicSnippet = 0;
 buildLiveBroadcastTopicSnippet() {
   var o = new api.LiveBroadcastTopicSnippet();
   buildCounterLiveBroadcastTopicSnippet++;
   if (buildCounterLiveBroadcastTopicSnippet < 3) {
     o.name = "foo";
@@ skipping 159 matching lines @@
 }
 
 checkLiveChatMessageDeletedDetails(api.LiveChatMessageDeletedDetails o) {
   buildCounterLiveChatMessageDeletedDetails++;
   if (buildCounterLiveChatMessageDeletedDetails < 3) {
     unittest.expect(o.deletedMessageId, unittest.equals('foo'));
   }
   buildCounterLiveChatMessageDeletedDetails--;
 }
 
-buildUnnamed594() {
+buildUnnamed593() {
   var o = new core.List<api.LiveChatMessage>();
   o.add(buildLiveChatMessage());
   o.add(buildLiveChatMessage());
   return o;
 }
 
-checkUnnamed594(core.List<api.LiveChatMessage> o) {
+checkUnnamed593(core.List<api.LiveChatMessage> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveChatMessage(o[0]);
   checkLiveChatMessage(o[1]);
 }
 
 core.int buildCounterLiveChatMessageListResponse = 0;
 buildLiveChatMessageListResponse() {
   var o = new api.LiveChatMessageListResponse();
   buildCounterLiveChatMessageListResponse++;
   if (buildCounterLiveChatMessageListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed594();
+    o.items = buildUnnamed593();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.offlineAt = core.DateTime.parse("2002-02-27T14:01:02");
     o.pageInfo = buildPageInfo();
     o.pollingIntervalMillis = 42;
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterLiveChatMessageListResponse--;
   return o;
 }
 
 checkLiveChatMessageListResponse(api.LiveChatMessageListResponse o) {
   buildCounterLiveChatMessageListResponse++;
   if (buildCounterLiveChatMessageListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed594(o.items);
+    checkUnnamed593(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    unittest.expect(o.offlineAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.offlineAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.pollingIntervalMillis, unittest.equals(42));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterLiveChatMessageListResponse--;
 }
 
 core.int buildCounterLiveChatMessageRetractedDetails = 0;
 buildLiveChatMessageRetractedDetails() {
@@ skipping 47 matching lines @@
     unittest.expect(o.displayMessage, unittest.equals('foo'));
     checkLiveChatFanFundingEventDetails(o.fanFundingEventDetails);
     unittest.expect(o.hasDisplayContent, unittest.isTrue);
     unittest.expect(o.liveChatId, unittest.equals('foo'));
     checkLiveChatMessageDeletedDetails(o.messageDeletedDetails);
     checkLiveChatMessageRetractedDetails(o.messageRetractedDetails);
     checkLiveChatPollClosedDetails(o.pollClosedDetails);
     checkLiveChatPollEditedDetails(o.pollEditedDetails);
     checkLiveChatPollOpenedDetails(o.pollOpenedDetails);
     checkLiveChatPollVotedDetails(o.pollVotedDetails);
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkLiveChatSuperChatDetails(o.superChatDetails);
     checkLiveChatTextMessageDetails(o.textMessageDetails);
     unittest.expect(o.type, unittest.equals('foo'));
     checkLiveChatUserBannedMessageDetails(o.userBannedDetails);
   }
   buildCounterLiveChatMessageSnippet--;
 }
 
 core.int buildCounterLiveChatModerator = 0;
 buildLiveChatModerator() {
@@ skipping 13 matching lines @@
   buildCounterLiveChatModerator++;
   if (buildCounterLiveChatModerator < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkLiveChatModeratorSnippet(o.snippet);
   }
   buildCounterLiveChatModerator--;
 }
 
-buildUnnamed595() {
+buildUnnamed594() {
   var o = new core.List<api.LiveChatModerator>();
   o.add(buildLiveChatModerator());
   o.add(buildLiveChatModerator());
   return o;
 }
 
-checkUnnamed595(core.List<api.LiveChatModerator> o) {
+checkUnnamed594(core.List<api.LiveChatModerator> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveChatModerator(o[0]);
   checkLiveChatModerator(o[1]);
 }
 
 core.int buildCounterLiveChatModeratorListResponse = 0;
 buildLiveChatModeratorListResponse() {
   var o = new api.LiveChatModeratorListResponse();
   buildCounterLiveChatModeratorListResponse++;
   if (buildCounterLiveChatModeratorListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed595();
+    o.items = buildUnnamed594();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterLiveChatModeratorListResponse--;
   return o;
 }
 
 checkLiveChatModeratorListResponse(api.LiveChatModeratorListResponse o) {
   buildCounterLiveChatModeratorListResponse++;
   if (buildCounterLiveChatModeratorListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed595(o.items);
+    checkUnnamed594(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterLiveChatModeratorListResponse--;
 }
 
@@ skipping 30 matching lines @@
 }
 
 checkLiveChatPollClosedDetails(api.LiveChatPollClosedDetails o) {
   buildCounterLiveChatPollClosedDetails++;
   if (buildCounterLiveChatPollClosedDetails < 3) {
     unittest.expect(o.pollId, unittest.equals('foo'));
   }
   buildCounterLiveChatPollClosedDetails--;
 }
 
-buildUnnamed596() {
+buildUnnamed595() {
   var o = new core.List<api.LiveChatPollItem>();
   o.add(buildLiveChatPollItem());
   o.add(buildLiveChatPollItem());
   return o;
 }
 
-checkUnnamed596(core.List<api.LiveChatPollItem> o) {
+checkUnnamed595(core.List<api.LiveChatPollItem> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveChatPollItem(o[0]);
   checkLiveChatPollItem(o[1]);
 }
 
 core.int buildCounterLiveChatPollEditedDetails = 0;
 buildLiveChatPollEditedDetails() {
   var o = new api.LiveChatPollEditedDetails();
   buildCounterLiveChatPollEditedDetails++;
   if (buildCounterLiveChatPollEditedDetails < 3) {
     o.id = "foo";
-    o.items = buildUnnamed596();
+    o.items = buildUnnamed595();
     o.prompt = "foo";
   }
   buildCounterLiveChatPollEditedDetails--;
   return o;
 }
 
 checkLiveChatPollEditedDetails(api.LiveChatPollEditedDetails o) {
   buildCounterLiveChatPollEditedDetails++;
   if (buildCounterLiveChatPollEditedDetails < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed596(o.items);
+    checkUnnamed595(o.items);
     unittest.expect(o.prompt, unittest.equals('foo'));
   }
   buildCounterLiveChatPollEditedDetails--;
 }
 
 core.int buildCounterLiveChatPollItem = 0;
 buildLiveChatPollItem() {
   var o = new api.LiveChatPollItem();
   buildCounterLiveChatPollItem++;
   if (buildCounterLiveChatPollItem < 3) {
     o.description = "foo";
     o.itemId = "foo";
   }
   buildCounterLiveChatPollItem--;
   return o;
 }
 
 checkLiveChatPollItem(api.LiveChatPollItem o) {
   buildCounterLiveChatPollItem++;
   if (buildCounterLiveChatPollItem < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.itemId, unittest.equals('foo'));
   }
   buildCounterLiveChatPollItem--;
 }
 
-buildUnnamed597() {
+buildUnnamed596() {
   var o = new core.List<api.LiveChatPollItem>();
   o.add(buildLiveChatPollItem());
   o.add(buildLiveChatPollItem());
   return o;
 }
 
-checkUnnamed597(core.List<api.LiveChatPollItem> o) {
+checkUnnamed596(core.List<api.LiveChatPollItem> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveChatPollItem(o[0]);
   checkLiveChatPollItem(o[1]);
 }
 
 core.int buildCounterLiveChatPollOpenedDetails = 0;
 buildLiveChatPollOpenedDetails() {
   var o = new api.LiveChatPollOpenedDetails();
   buildCounterLiveChatPollOpenedDetails++;
   if (buildCounterLiveChatPollOpenedDetails < 3) {
     o.id = "foo";
-    o.items = buildUnnamed597();
+    o.items = buildUnnamed596();
     o.prompt = "foo";
   }
   buildCounterLiveChatPollOpenedDetails--;
   return o;
 }
 
 checkLiveChatPollOpenedDetails(api.LiveChatPollOpenedDetails o) {
   buildCounterLiveChatPollOpenedDetails++;
   if (buildCounterLiveChatPollOpenedDetails < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
-    checkUnnamed597(o.items);
+    checkUnnamed596(o.items);
     unittest.expect(o.prompt, unittest.equals('foo'));
   }
   buildCounterLiveChatPollOpenedDetails--;
 }
 
 core.int buildCounterLiveChatPollVotedDetails = 0;
 buildLiveChatPollVotedDetails() {
   var o = new api.LiveChatPollVotedDetails();
   buildCounterLiveChatPollVotedDetails++;
   if (buildCounterLiveChatPollVotedDetails < 3) {
@@ skipping 152 matching lines @@
 
 checkLiveStreamContentDetails(api.LiveStreamContentDetails o) {
   buildCounterLiveStreamContentDetails++;
   if (buildCounterLiveStreamContentDetails < 3) {
     unittest.expect(o.closedCaptionsIngestionUrl, unittest.equals('foo'));
     unittest.expect(o.isReusable, unittest.isTrue);
   }
   buildCounterLiveStreamContentDetails--;
 }
 
-buildUnnamed598() {
+buildUnnamed597() {
   var o = new core.List<api.LiveStreamConfigurationIssue>();
   o.add(buildLiveStreamConfigurationIssue());
   o.add(buildLiveStreamConfigurationIssue());
   return o;
 }
 
-checkUnnamed598(core.List<api.LiveStreamConfigurationIssue> o) {
+checkUnnamed597(core.List<api.LiveStreamConfigurationIssue> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveStreamConfigurationIssue(o[0]);
   checkLiveStreamConfigurationIssue(o[1]);
 }
 
 core.int buildCounterLiveStreamHealthStatus = 0;
 buildLiveStreamHealthStatus() {
   var o = new api.LiveStreamHealthStatus();
   buildCounterLiveStreamHealthStatus++;
   if (buildCounterLiveStreamHealthStatus < 3) {
-    o.configurationIssues = buildUnnamed598();
+    o.configurationIssues = buildUnnamed597();
     o.lastUpdateTimeSeconds = "foo";
     o.status = "foo";
   }
   buildCounterLiveStreamHealthStatus--;
   return o;
 }
 
 checkLiveStreamHealthStatus(api.LiveStreamHealthStatus o) {
   buildCounterLiveStreamHealthStatus++;
   if (buildCounterLiveStreamHealthStatus < 3) {
-    checkUnnamed598(o.configurationIssues);
+    checkUnnamed597(o.configurationIssues);
     unittest.expect(o.lastUpdateTimeSeconds, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
   }
   buildCounterLiveStreamHealthStatus--;
 }
 
-buildUnnamed599() {
+buildUnnamed598() {
   var o = new core.List<api.LiveStream>();
   o.add(buildLiveStream());
   o.add(buildLiveStream());
   return o;
 }
 
-checkUnnamed599(core.List<api.LiveStream> o) {
+checkUnnamed598(core.List<api.LiveStream> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLiveStream(o[0]);
   checkLiveStream(o[1]);
 }
 
 core.int buildCounterLiveStreamListResponse = 0;
 buildLiveStreamListResponse() {
   var o = new api.LiveStreamListResponse();
   buildCounterLiveStreamListResponse++;
   if (buildCounterLiveStreamListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed599();
+    o.items = buildUnnamed598();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterLiveStreamListResponse--;
   return o;
 }
 
 checkLiveStreamListResponse(api.LiveStreamListResponse o) {
   buildCounterLiveStreamListResponse++;
   if (buildCounterLiveStreamListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed599(o.items);
+    checkUnnamed598(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterLiveStreamListResponse--;
 }
 
@@ skipping 11 matching lines @@
   buildCounterLiveStreamSnippet--;
   return o;
 }
 
 checkLiveStreamSnippet(api.LiveStreamSnippet o) {
   buildCounterLiveStreamSnippet++;
   if (buildCounterLiveStreamSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.isDefaultStream, unittest.isTrue);
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterLiveStreamSnippet--;
 }
 
 core.int buildCounterLiveStreamStatus = 0;
 buildLiveStreamStatus() {
   var o = new api.LiveStreamStatus();
   buildCounterLiveStreamStatus++;
   if (buildCounterLiveStreamStatus < 3) {
     o.healthStatus = buildLiveStreamHealthStatus();
     o.streamStatus = "foo";
   }
   buildCounterLiveStreamStatus--;
   return o;
 }
 
 checkLiveStreamStatus(api.LiveStreamStatus o) {
   buildCounterLiveStreamStatus++;
   if (buildCounterLiveStreamStatus < 3) {
     checkLiveStreamHealthStatus(o.healthStatus);
     unittest.expect(o.streamStatus, unittest.equals('foo'));
   }
   buildCounterLiveStreamStatus--;
 }
 
-buildUnnamed600() {
+buildUnnamed599() {
   var o = new core.List<api.LocalizedString>();
   o.add(buildLocalizedString());
   o.add(buildLocalizedString());
   return o;
 }
 
-checkUnnamed600(core.List<api.LocalizedString> o) {
+checkUnnamed599(core.List<api.LocalizedString> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLocalizedString(o[0]);
   checkLocalizedString(o[1]);
 }
 
 core.int buildCounterLocalizedProperty = 0;
 buildLocalizedProperty() {
   var o = new api.LocalizedProperty();
   buildCounterLocalizedProperty++;
   if (buildCounterLocalizedProperty < 3) {
     o.default_ = "foo";
     o.defaultLanguage = buildLanguageTag();
-    o.localized = buildUnnamed600();
+    o.localized = buildUnnamed599();
   }
   buildCounterLocalizedProperty--;
   return o;
 }
 
 checkLocalizedProperty(api.LocalizedProperty o) {
   buildCounterLocalizedProperty++;
   if (buildCounterLocalizedProperty < 3) {
     unittest.expect(o.default_, unittest.equals('foo'));
     checkLanguageTag(o.defaultLanguage);
-    checkUnnamed600(o.localized);
+    checkUnnamed599(o.localized);
   }
   buildCounterLocalizedProperty--;
 }
 
 core.int buildCounterLocalizedString = 0;
 buildLocalizedString() {
   var o = new api.LocalizedString();
   buildCounterLocalizedString++;
   if (buildCounterLocalizedString < 3) {
     o.language = "foo";
@@ skipping 49 matching lines @@
 
 checkPageInfo(api.PageInfo o) {
   buildCounterPageInfo++;
   if (buildCounterPageInfo < 3) {
     unittest.expect(o.resultsPerPage, unittest.equals(42));
     unittest.expect(o.totalResults, unittest.equals(42));
   }
   buildCounterPageInfo--;
 }
 
-buildUnnamed601() {
+buildUnnamed600() {
   var o = new core.Map<core.String, api.PlaylistLocalization>();
   o["x"] = buildPlaylistLocalization();
   o["y"] = buildPlaylistLocalization();
   return o;
 }
 
-checkUnnamed601(core.Map<core.String, api.PlaylistLocalization> o) {
+checkUnnamed600(core.Map<core.String, api.PlaylistLocalization> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPlaylistLocalization(o["x"]);
   checkPlaylistLocalization(o["y"]);
 }
 
 core.int buildCounterPlaylist = 0;
 buildPlaylist() {
   var o = new api.Playlist();
   buildCounterPlaylist++;
   if (buildCounterPlaylist < 3) {
     o.contentDetails = buildPlaylistContentDetails();
     o.etag = "foo";
     o.id = "foo";
     o.kind = "foo";
-    o.localizations = buildUnnamed601();
+    o.localizations = buildUnnamed600();
     o.player = buildPlaylistPlayer();
     o.snippet = buildPlaylistSnippet();
     o.status = buildPlaylistStatus();
   }
   buildCounterPlaylist--;
   return o;
 }
 
 checkPlaylist(api.Playlist o) {
   buildCounterPlaylist++;
   if (buildCounterPlaylist < 3) {
     checkPlaylistContentDetails(o.contentDetails);
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed601(o.localizations);
+    checkUnnamed600(o.localizations);
     checkPlaylistPlayer(o.player);
     checkPlaylistSnippet(o.snippet);
     checkPlaylistStatus(o.status);
   }
   buildCounterPlaylist--;
 }
 
 core.int buildCounterPlaylistContentDetails = 0;
 buildPlaylistContentDetails() {
   var o = new api.PlaylistContentDetails();
@@ skipping 57 matching lines @@
   return o;
 }
 
 checkPlaylistItemContentDetails(api.PlaylistItemContentDetails o) {
   buildCounterPlaylistItemContentDetails++;
   if (buildCounterPlaylistItemContentDetails < 3) {
     unittest.expect(o.endAt, unittest.equals('foo'));
     unittest.expect(o.note, unittest.equals('foo'));
     unittest.expect(o.startAt, unittest.equals('foo'));
     unittest.expect(o.videoId, unittest.equals('foo'));
-    unittest.expect(o.videoPublishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.videoPublishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterPlaylistItemContentDetails--;
 }
 
-buildUnnamed602() {
+buildUnnamed601() {
   var o = new core.List<api.PlaylistItem>();
   o.add(buildPlaylistItem());
   o.add(buildPlaylistItem());
   return o;
 }
 
-checkUnnamed602(core.List<api.PlaylistItem> o) {
+checkUnnamed601(core.List<api.PlaylistItem> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPlaylistItem(o[0]);
   checkPlaylistItem(o[1]);
 }
 
 core.int buildCounterPlaylistItemListResponse = 0;
 buildPlaylistItemListResponse() {
   var o = new api.PlaylistItemListResponse();
   buildCounterPlaylistItemListResponse++;
   if (buildCounterPlaylistItemListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed602();
+    o.items = buildUnnamed601();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterPlaylistItemListResponse--;
   return o;
 }
 
 checkPlaylistItemListResponse(api.PlaylistItemListResponse o) {
   buildCounterPlaylistItemListResponse++;
   if (buildCounterPlaylistItemListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed602(o.items);
+    checkUnnamed601(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterPlaylistItemListResponse--;
 }
 
@@ skipping 17 matching lines @@
 }
 
 checkPlaylistItemSnippet(api.PlaylistItemSnippet o) {
   buildCounterPlaylistItemSnippet++;
   if (buildCounterPlaylistItemSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.playlistId, unittest.equals('foo'));
     unittest.expect(o.position, unittest.equals(42));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkResourceId(o.resourceId);
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterPlaylistItemSnippet--;
 }
 
 core.int buildCounterPlaylistItemStatus = 0;
 buildPlaylistItemStatus() {
   var o = new api.PlaylistItemStatus();
   buildCounterPlaylistItemStatus++;
   if (buildCounterPlaylistItemStatus < 3) {
     o.privacyStatus = "foo";
   }
   buildCounterPlaylistItemStatus--;
   return o;
 }
 
 checkPlaylistItemStatus(api.PlaylistItemStatus o) {
   buildCounterPlaylistItemStatus++;
   if (buildCounterPlaylistItemStatus < 3) {
     unittest.expect(o.privacyStatus, unittest.equals('foo'));
   }
   buildCounterPlaylistItemStatus--;
 }
 
-buildUnnamed603() {
+buildUnnamed602() {
   var o = new core.List<api.Playlist>();
   o.add(buildPlaylist());
   o.add(buildPlaylist());
   return o;
 }
 
-checkUnnamed603(core.List<api.Playlist> o) {
+checkUnnamed602(core.List<api.Playlist> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPlaylist(o[0]);
   checkPlaylist(o[1]);
 }
 
 core.int buildCounterPlaylistListResponse = 0;
 buildPlaylistListResponse() {
   var o = new api.PlaylistListResponse();
   buildCounterPlaylistListResponse++;
   if (buildCounterPlaylistListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed603();
+    o.items = buildUnnamed602();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterPlaylistListResponse--;
   return o;
 }
 
 checkPlaylistListResponse(api.PlaylistListResponse o) {
   buildCounterPlaylistListResponse++;
   if (buildCounterPlaylistListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed603(o.items);
+    checkUnnamed602(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterPlaylistListResponse--;
 }
 
@@ skipping 30 matching lines @@
 }
 
 checkPlaylistPlayer(api.PlaylistPlayer o) {
   buildCounterPlaylistPlayer++;
   if (buildCounterPlaylistPlayer < 3) {
     unittest.expect(o.embedHtml, unittest.equals('foo'));
   }
   buildCounterPlaylistPlayer--;
 }
 
-buildUnnamed604() {
+buildUnnamed603() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed604(core.List<core.String> o) {
+checkUnnamed603(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 buildCounterPlaylistSnippet = 0;
 buildPlaylistSnippet() {
   var o = new api.PlaylistSnippet();
   buildCounterPlaylistSnippet++;
   if (buildCounterPlaylistSnippet < 3) {
     o.channelId = "foo";
     o.channelTitle = "foo";
     o.defaultLanguage = "foo";
     o.description = "foo";
     o.localized = buildPlaylistLocalization();
     o.publishedAt = core.DateTime.parse("2002-02-27T14:01:02");
-    o.tags = buildUnnamed604();
+    o.tags = buildUnnamed603();
     o.thumbnails = buildThumbnailDetails();
     o.title = "foo";
   }
   buildCounterPlaylistSnippet--;
   return o;
 }
 
 checkPlaylistSnippet(api.PlaylistSnippet o) {
   buildCounterPlaylistSnippet++;
   if (buildCounterPlaylistSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.defaultLanguage, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     checkPlaylistLocalization(o.localized);
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    checkUnnamed604(o.tags);
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    checkUnnamed603(o.tags);
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterPlaylistSnippet--;
 }
 
 core.int buildCounterPlaylistStatus = 0;
 buildPlaylistStatus() {
   var o = new api.PlaylistStatus();
   buildCounterPlaylistStatus++;
@@ skipping 101 matching lines @@
   buildCounterResourceId++;
   if (buildCounterResourceId < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.playlistId, unittest.equals('foo'));
     unittest.expect(o.videoId, unittest.equals('foo'));
   }
   buildCounterResourceId--;
 }
 
-buildUnnamed605() {
+buildUnnamed604() {
   var o = new core.List<api.SearchResult>();
   o.add(buildSearchResult());
   o.add(buildSearchResult());
   return o;
 }
 
-checkUnnamed605(core.List<api.SearchResult> o) {
+checkUnnamed604(core.List<api.SearchResult> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSearchResult(o[0]);
   checkSearchResult(o[1]);
 }
 
 core.int buildCounterSearchListResponse = 0;
 buildSearchListResponse() {
   var o = new api.SearchListResponse();
   buildCounterSearchListResponse++;
   if (buildCounterSearchListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed605();
+    o.items = buildUnnamed604();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.regionCode = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterSearchListResponse--;
   return o;
 }
 
 checkSearchListResponse(api.SearchListResponse o) {
   buildCounterSearchListResponse++;
   if (buildCounterSearchListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed605(o.items);
+    checkUnnamed604(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     unittest.expect(o.regionCode, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterSearchListResponse--;
 }
@@ skipping 40 matching lines @@
   return o;
 }
 
 checkSearchResultSnippet(api.SearchResultSnippet o) {
   buildCounterSearchResultSnippet++;
   if (buildCounterSearchResultSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.liveBroadcastContent, unittest.equals('foo'));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterSearchResultSnippet--;
 }
 
 core.int buildCounterSponsor = 0;
 buildSponsor() {
   var o = new api.Sponsor();
   buildCounterSponsor++;
@@ skipping 11 matching lines @@
   buildCounterSponsor++;
   if (buildCounterSponsor < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkSponsorSnippet(o.snippet);
   }
   buildCounterSponsor--;
 }
 
-buildUnnamed606() {
+buildUnnamed605() {
   var o = new core.List<api.Sponsor>();
   o.add(buildSponsor());
   o.add(buildSponsor());
   return o;
 }
 
-checkUnnamed606(core.List<api.Sponsor> o) {
+checkUnnamed605(core.List<api.Sponsor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSponsor(o[0]);
   checkSponsor(o[1]);
 }
 
 core.int buildCounterSponsorListResponse = 0;
 buildSponsorListResponse() {
   var o = new api.SponsorListResponse();
   buildCounterSponsorListResponse++;
   if (buildCounterSponsorListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed606();
+    o.items = buildUnnamed605();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterSponsorListResponse--;
   return o;
 }
 
 checkSponsorListResponse(api.SponsorListResponse o) {
   buildCounterSponsorListResponse++;
   if (buildCounterSponsorListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed606(o.items);
+    checkUnnamed605(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterSponsorListResponse--;
 }
 
 core.int buildCounterSponsorSnippet = 0;
 buildSponsorSnippet() {
   var o = new api.SponsorSnippet();
   buildCounterSponsorSnippet++;
   if (buildCounterSponsorSnippet < 3) {
     o.channelId = "foo";
     o.sponsorDetails = buildChannelProfileDetails();
     o.sponsorSince = core.DateTime.parse("2002-02-27T14:01:02");
   }
   buildCounterSponsorSnippet--;
   return o;
 }
 
 checkSponsorSnippet(api.SponsorSnippet o) {
   buildCounterSponsorSnippet++;
   if (buildCounterSponsorSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     checkChannelProfileDetails(o.sponsorDetails);
-    unittest.expect(o.sponsorSince, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.sponsorSince,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterSponsorSnippet--;
 }
 
 core.int buildCounterSubscription = 0;
 buildSubscription() {
   var o = new api.Subscription();
   buildCounterSubscription++;
   if (buildCounterSubscription < 3) {
     o.contentDetails = buildSubscriptionContentDetails();
@@ skipping 36 matching lines @@
 checkSubscriptionContentDetails(api.SubscriptionContentDetails o) {
   buildCounterSubscriptionContentDetails++;
   if (buildCounterSubscriptionContentDetails < 3) {
     unittest.expect(o.activityType, unittest.equals('foo'));
     unittest.expect(o.newItemCount, unittest.equals(42));
     unittest.expect(o.totalItemCount, unittest.equals(42));
   }
   buildCounterSubscriptionContentDetails--;
 }
 
-buildUnnamed607() {
+buildUnnamed606() {
   var o = new core.List<api.Subscription>();
   o.add(buildSubscription());
   o.add(buildSubscription());
   return o;
 }
 
-checkUnnamed607(core.List<api.Subscription> o) {
+checkUnnamed606(core.List<api.Subscription> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSubscription(o[0]);
   checkSubscription(o[1]);
 }
 
 core.int buildCounterSubscriptionListResponse = 0;
 buildSubscriptionListResponse() {
   var o = new api.SubscriptionListResponse();
   buildCounterSubscriptionListResponse++;
   if (buildCounterSubscriptionListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed607();
+    o.items = buildUnnamed606();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterSubscriptionListResponse--;
   return o;
 }
 
 checkSubscriptionListResponse(api.SubscriptionListResponse o) {
   buildCounterSubscriptionListResponse++;
   if (buildCounterSubscriptionListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed607(o.items);
+    checkUnnamed606(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterSubscriptionListResponse--;
 }
 
@@ skipping 13 matching lines @@
   buildCounterSubscriptionSnippet--;
   return o;
 }
 
 checkSubscriptionSnippet(api.SubscriptionSnippet o) {
   buildCounterSubscriptionSnippet++;
   if (buildCounterSubscriptionSnippet < 3) {
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     checkResourceId(o.resourceId);
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterSubscriptionSnippet--;
 }
 
 core.int buildCounterSubscriptionSubscriberSnippet = 0;
 buildSubscriptionSubscriberSnippet() {
   var o = new api.SubscriptionSubscriberSnippet();
@@ skipping 37 matching lines @@
   buildCounterSuperChatEvent++;
   if (buildCounterSuperChatEvent < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkSuperChatEventSnippet(o.snippet);
   }
   buildCounterSuperChatEvent--;
 }
 
-buildUnnamed608() {
+buildUnnamed607() {
   var o = new core.List<api.SuperChatEvent>();
   o.add(buildSuperChatEvent());
   o.add(buildSuperChatEvent());
   return o;
 }
 
-checkUnnamed608(core.List<api.SuperChatEvent> o) {
+checkUnnamed607(core.List<api.SuperChatEvent> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSuperChatEvent(o[0]);
   checkSuperChatEvent(o[1]);
 }
 
 core.int buildCounterSuperChatEventListResponse = 0;
 buildSuperChatEventListResponse() {
   var o = new api.SuperChatEventListResponse();
   buildCounterSuperChatEventListResponse++;
   if (buildCounterSuperChatEventListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed608();
+    o.items = buildUnnamed607();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterSuperChatEventListResponse--;
   return o;
 }
 
 checkSuperChatEventListResponse(api.SuperChatEventListResponse o) {
   buildCounterSuperChatEventListResponse++;
   if (buildCounterSuperChatEventListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed608(o.items);
+    checkUnnamed607(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterSuperChatEventListResponse--;
 }
 
 core.int buildCounterSuperChatEventSnippet = 0;
@@ skipping 13 matching lines @@
   buildCounterSuperChatEventSnippet--;
   return o;
 }
 
 checkSuperChatEventSnippet(api.SuperChatEventSnippet o) {
   buildCounterSuperChatEventSnippet++;
   if (buildCounterSuperChatEventSnippet < 3) {
     unittest.expect(o.amountMicros, unittest.equals('foo'));
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.commentText, unittest.equals('foo'));
-    unittest.expect(o.createdAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.createdAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.currency, unittest.equals('foo'));
     unittest.expect(o.displayString, unittest.equals('foo'));
     unittest.expect(o.messageType, unittest.equals(42));
     checkChannelProfileDetails(o.supporterDetails);
   }
   buildCounterSuperChatEventSnippet--;
 }
 
 core.int buildCounterThumbnail = 0;
 buildThumbnail() {
@@ skipping 38 matching lines @@
   if (buildCounterThumbnailDetails < 3) {
     checkThumbnail(o.default_);
     checkThumbnail(o.high);
     checkThumbnail(o.maxres);
     checkThumbnail(o.medium);
     checkThumbnail(o.standard);
   }
   buildCounterThumbnailDetails--;
 }
 
-buildUnnamed609() {
+buildUnnamed608() {
   var o = new core.List<api.ThumbnailDetails>();
   o.add(buildThumbnailDetails());
   o.add(buildThumbnailDetails());
   return o;
 }
 
-checkUnnamed609(core.List<api.ThumbnailDetails> o) {
+checkUnnamed608(core.List<api.ThumbnailDetails> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkThumbnailDetails(o[0]);
   checkThumbnailDetails(o[1]);
 }
 
 core.int buildCounterThumbnailSetResponse = 0;
 buildThumbnailSetResponse() {
   var o = new api.ThumbnailSetResponse();
   buildCounterThumbnailSetResponse++;
   if (buildCounterThumbnailSetResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed609();
+    o.items = buildUnnamed608();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterThumbnailSetResponse--;
   return o;
 }
 
 checkThumbnailSetResponse(api.ThumbnailSetResponse o) {
   buildCounterThumbnailSetResponse++;
   if (buildCounterThumbnailSetResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed609(o.items);
+    checkUnnamed608(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterThumbnailSetResponse--;
 }
 
 core.int buildCounterTokenPagination = 0;
 buildTokenPagination() {
   var o = new api.TokenPagination();
   buildCounterTokenPagination++;
-  if (buildCounterTokenPagination < 3) {
-  }
+  if (buildCounterTokenPagination < 3) {}
   buildCounterTokenPagination--;
   return o;
 }
 
 checkTokenPagination(api.TokenPagination o) {
   buildCounterTokenPagination++;
-  if (buildCounterTokenPagination < 3) {
-  }
+  if (buildCounterTokenPagination < 3) {}
   buildCounterTokenPagination--;
 }
 
-buildUnnamed610() {
+buildUnnamed609() {
   var o = new core.Map<core.String, api.VideoLocalization>();
   o["x"] = buildVideoLocalization();
   o["y"] = buildVideoLocalization();
   return o;
 }
 
-checkUnnamed610(core.Map<core.String, api.VideoLocalization> o) {
+checkUnnamed609(core.Map<core.String, api.VideoLocalization> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoLocalization(o["x"]);
   checkVideoLocalization(o["y"]);
 }
 
 core.int buildCounterVideo = 0;
 buildVideo() {
   var o = new api.Video();
   buildCounterVideo++;
   if (buildCounterVideo < 3) {
     o.ageGating = buildVideoAgeGating();
     o.contentDetails = buildVideoContentDetails();
     o.etag = "foo";
     o.fileDetails = buildVideoFileDetails();
     o.id = "foo";
     o.kind = "foo";
     o.liveStreamingDetails = buildVideoLiveStreamingDetails();
-    o.localizations = buildUnnamed610();
+    o.localizations = buildUnnamed609();
     o.monetizationDetails = buildVideoMonetizationDetails();
     o.player = buildVideoPlayer();
     o.processingDetails = buildVideoProcessingDetails();
     o.projectDetails = buildVideoProjectDetails();
     o.recordingDetails = buildVideoRecordingDetails();
     o.snippet = buildVideoSnippet();
     o.statistics = buildVideoStatistics();
     o.status = buildVideoStatus();
     o.suggestions = buildVideoSuggestions();
     o.topicDetails = buildVideoTopicDetails();
   }
   buildCounterVideo--;
   return o;
 }
 
 checkVideo(api.Video o) {
   buildCounterVideo++;
   if (buildCounterVideo < 3) {
     checkVideoAgeGating(o.ageGating);
     checkVideoContentDetails(o.contentDetails);
     unittest.expect(o.etag, unittest.equals('foo'));
     checkVideoFileDetails(o.fileDetails);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkVideoLiveStreamingDetails(o.liveStreamingDetails);
-    checkUnnamed610(o.localizations);
+    checkUnnamed609(o.localizations);
     checkVideoMonetizationDetails(o.monetizationDetails);
     checkVideoPlayer(o.player);
     checkVideoProcessingDetails(o.processingDetails);
     checkVideoProjectDetails(o.projectDetails);
     checkVideoRecordingDetails(o.recordingDetails);
     checkVideoSnippet(o.snippet);
     checkVideoStatistics(o.statistics);
     checkVideoStatus(o.status);
     checkVideoSuggestions(o.suggestions);
     checkVideoTopicDetails(o.topicDetails);
@@ skipping 46 matching lines @@
   buildCounterVideoAbuseReportReason++;
   if (buildCounterVideoAbuseReportReason < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkVideoAbuseReportReasonSnippet(o.snippet);
   }
   buildCounterVideoAbuseReportReason--;
 }
 
-buildUnnamed611() {
+buildUnnamed610() {
   var o = new core.List<api.VideoAbuseReportReason>();
   o.add(buildVideoAbuseReportReason());
   o.add(buildVideoAbuseReportReason());
   return o;
 }
 
-checkUnnamed611(core.List<api.VideoAbuseReportReason> o) {
+checkUnnamed610(core.List<api.VideoAbuseReportReason> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoAbuseReportReason(o[0]);
   checkVideoAbuseReportReason(o[1]);
 }
 
 core.int buildCounterVideoAbuseReportReasonListResponse = 0;
 buildVideoAbuseReportReasonListResponse() {
   var o = new api.VideoAbuseReportReasonListResponse();
   buildCounterVideoAbuseReportReasonListResponse++;
   if (buildCounterVideoAbuseReportReasonListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed611();
+    o.items = buildUnnamed610();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterVideoAbuseReportReasonListResponse--;
   return o;
 }
 
-checkVideoAbuseReportReasonListResponse(api.VideoAbuseReportReasonListResponse o) {
+checkVideoAbuseReportReasonListResponse(
+    api.VideoAbuseReportReasonListResponse o) {
   buildCounterVideoAbuseReportReasonListResponse++;
   if (buildCounterVideoAbuseReportReasonListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed611(o.items);
+    checkUnnamed610(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterVideoAbuseReportReasonListResponse--;
 }
 
-buildUnnamed612() {
+buildUnnamed611() {
   var o = new core.List<api.VideoAbuseReportSecondaryReason>();
   o.add(buildVideoAbuseReportSecondaryReason());
   o.add(buildVideoAbuseReportSecondaryReason());
   return o;
 }
 
-checkUnnamed612(core.List<api.VideoAbuseReportSecondaryReason> o) {
+checkUnnamed611(core.List<api.VideoAbuseReportSecondaryReason> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoAbuseReportSecondaryReason(o[0]);
   checkVideoAbuseReportSecondaryReason(o[1]);
 }
 
 core.int buildCounterVideoAbuseReportReasonSnippet = 0;
 buildVideoAbuseReportReasonSnippet() {
   var o = new api.VideoAbuseReportReasonSnippet();
   buildCounterVideoAbuseReportReasonSnippet++;
   if (buildCounterVideoAbuseReportReasonSnippet < 3) {
     o.label = "foo";
-    o.secondaryReasons = buildUnnamed612();
+    o.secondaryReasons = buildUnnamed611();
   }
   buildCounterVideoAbuseReportReasonSnippet--;
   return o;
 }
 
 checkVideoAbuseReportReasonSnippet(api.VideoAbuseReportReasonSnippet o) {
   buildCounterVideoAbuseReportReasonSnippet++;
   if (buildCounterVideoAbuseReportReasonSnippet < 3) {
     unittest.expect(o.label, unittest.equals('foo'));
-    checkUnnamed612(o.secondaryReasons);
+    checkUnnamed611(o.secondaryReasons);
   }
   buildCounterVideoAbuseReportReasonSnippet--;
 }
 
 core.int buildCounterVideoAbuseReportSecondaryReason = 0;
 buildVideoAbuseReportSecondaryReason() {
   var o = new api.VideoAbuseReportSecondaryReason();
   buildCounterVideoAbuseReportSecondaryReason++;
   if (buildCounterVideoAbuseReportSecondaryReason < 3) {
     o.id = "foo";
@@ skipping 53 matching lines @@
   buildCounterVideoCategory++;
   if (buildCounterVideoCategory < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     checkVideoCategorySnippet(o.snippet);
   }
   buildCounterVideoCategory--;
 }
 
-buildUnnamed613() {
+buildUnnamed612() {
   var o = new core.List<api.VideoCategory>();
   o.add(buildVideoCategory());
   o.add(buildVideoCategory());
   return o;
 }
 
-checkUnnamed613(core.List<api.VideoCategory> o) {
+checkUnnamed612(core.List<api.VideoCategory> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoCategory(o[0]);
   checkVideoCategory(o[1]);
 }
 
 core.int buildCounterVideoCategoryListResponse = 0;
 buildVideoCategoryListResponse() {
   var o = new api.VideoCategoryListResponse();
   buildCounterVideoCategoryListResponse++;
   if (buildCounterVideoCategoryListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed613();
+    o.items = buildUnnamed612();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterVideoCategoryListResponse--;
   return o;
 }
 
 checkVideoCategoryListResponse(api.VideoCategoryListResponse o) {
   buildCounterVideoCategoryListResponse++;
   if (buildCounterVideoCategoryListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed613(o.items);
+    checkUnnamed612(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterVideoCategoryListResponse--;
 }
 
@@ skipping 50 matching lines @@
     unittest.expect(o.dimension, unittest.equals('foo'));
     unittest.expect(o.duration, unittest.equals('foo'));
     unittest.expect(o.hasCustomThumbnail, unittest.isTrue);
     unittest.expect(o.licensedContent, unittest.isTrue);
     unittest.expect(o.projection, unittest.equals('foo'));
     checkVideoContentDetailsRegionRestriction(o.regionRestriction);
   }
   buildCounterVideoContentDetails--;
 }
 
+buildUnnamed613() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed613(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'));
+}
+
 buildUnnamed614() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed614(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'));
-}
-
-buildUnnamed615() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed615(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 buildCounterVideoContentDetailsRegionRestriction = 0;
 buildVideoContentDetailsRegionRestriction() {
   var o = new api.VideoContentDetailsRegionRestriction();
   buildCounterVideoContentDetailsRegionRestriction++;
   if (buildCounterVideoContentDetailsRegionRestriction < 3) {
-    o.allowed = buildUnnamed614();
-    o.blocked = buildUnnamed615();
+    o.allowed = buildUnnamed613();
+    o.blocked = buildUnnamed614();
   }
   buildCounterVideoContentDetailsRegionRestriction--;
   return o;
 }
 
-checkVideoContentDetailsRegionRestriction(api.VideoContentDetailsRegionRestriction o) {
+checkVideoContentDetailsRegionRestriction(
+    api.VideoContentDetailsRegionRestriction o) {
   buildCounterVideoContentDetailsRegionRestriction++;
   if (buildCounterVideoContentDetailsRegionRestriction < 3) {
-    checkUnnamed614(o.allowed);
-    checkUnnamed615(o.blocked);
+    checkUnnamed613(o.allowed);
+    checkUnnamed614(o.blocked);
   }
   buildCounterVideoContentDetailsRegionRestriction--;
 }
 
-buildUnnamed616() {
+buildUnnamed615() {
   var o = new core.List<api.VideoFileDetailsAudioStream>();
   o.add(buildVideoFileDetailsAudioStream());
   o.add(buildVideoFileDetailsAudioStream());
   return o;
 }
 
-checkUnnamed616(core.List<api.VideoFileDetailsAudioStream> o) {
+checkUnnamed615(core.List<api.VideoFileDetailsAudioStream> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoFileDetailsAudioStream(o[0]);
   checkVideoFileDetailsAudioStream(o[1]);
 }
 
-buildUnnamed617() {
+buildUnnamed616() {
   var o = new core.List<api.VideoFileDetailsVideoStream>();
   o.add(buildVideoFileDetailsVideoStream());
   o.add(buildVideoFileDetailsVideoStream());
   return o;
 }
 
-checkUnnamed617(core.List<api.VideoFileDetailsVideoStream> o) {
+checkUnnamed616(core.List<api.VideoFileDetailsVideoStream> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoFileDetailsVideoStream(o[0]);
   checkVideoFileDetailsVideoStream(o[1]);
 }
 
 core.int buildCounterVideoFileDetails = 0;
 buildVideoFileDetails() {
   var o = new api.VideoFileDetails();
   buildCounterVideoFileDetails++;
   if (buildCounterVideoFileDetails < 3) {
-    o.audioStreams = buildUnnamed616();
+    o.audioStreams = buildUnnamed615();
     o.bitrateBps = "foo";
     o.container = "foo";
     o.creationTime = "foo";
     o.durationMs = "foo";
     o.fileName = "foo";
     o.fileSize = "foo";
     o.fileType = "foo";
-    o.videoStreams = buildUnnamed617();
+    o.videoStreams = buildUnnamed616();
   }
   buildCounterVideoFileDetails--;
   return o;
 }
 
 checkVideoFileDetails(api.VideoFileDetails o) {
   buildCounterVideoFileDetails++;
   if (buildCounterVideoFileDetails < 3) {
-    checkUnnamed616(o.audioStreams);
+    checkUnnamed615(o.audioStreams);
     unittest.expect(o.bitrateBps, unittest.equals('foo'));
     unittest.expect(o.container, unittest.equals('foo'));
     unittest.expect(o.creationTime, unittest.equals('foo'));
     unittest.expect(o.durationMs, unittest.equals('foo'));
     unittest.expect(o.fileName, unittest.equals('foo'));
     unittest.expect(o.fileSize, unittest.equals('foo'));
     unittest.expect(o.fileType, unittest.equals('foo'));
-    checkUnnamed617(o.videoStreams);
+    checkUnnamed616(o.videoStreams);
   }
   buildCounterVideoFileDetails--;
 }
 
 core.int buildCounterVideoFileDetailsAudioStream = 0;
 buildVideoFileDetailsAudioStream() {
   var o = new api.VideoFileDetailsAudioStream();
   buildCounterVideoFileDetailsAudioStream++;
   if (buildCounterVideoFileDetailsAudioStream < 3) {
     o.bitrateBps = "foo";
@@ skipping 42 matching lines @@
     unittest.expect(o.codec, unittest.equals('foo'));
     unittest.expect(o.frameRateFps, unittest.equals(42.0));
     unittest.expect(o.heightPixels, unittest.equals(42));
     unittest.expect(o.rotation, unittest.equals('foo'));
     unittest.expect(o.vendor, unittest.equals('foo'));
     unittest.expect(o.widthPixels, unittest.equals(42));
   }
   buildCounterVideoFileDetailsVideoStream--;
 }
 
-buildUnnamed618() {
+buildUnnamed617() {
   var o = new core.List<api.VideoRating>();
   o.add(buildVideoRating());
   o.add(buildVideoRating());
   return o;
 }
 
-checkUnnamed618(core.List<api.VideoRating> o) {
+checkUnnamed617(core.List<api.VideoRating> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoRating(o[0]);
   checkVideoRating(o[1]);
 }
 
 core.int buildCounterVideoGetRatingResponse = 0;
 buildVideoGetRatingResponse() {
   var o = new api.VideoGetRatingResponse();
   buildCounterVideoGetRatingResponse++;
   if (buildCounterVideoGetRatingResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed618();
+    o.items = buildUnnamed617();
     o.kind = "foo";
     o.visitorId = "foo";
   }
   buildCounterVideoGetRatingResponse--;
   return o;
 }
 
 checkVideoGetRatingResponse(api.VideoGetRatingResponse o) {
   buildCounterVideoGetRatingResponse++;
   if (buildCounterVideoGetRatingResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed618(o.items);
+    checkUnnamed617(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterVideoGetRatingResponse--;
 }
 
-buildUnnamed619() {
+buildUnnamed618() {
   var o = new core.List<api.Video>();
   o.add(buildVideo());
   o.add(buildVideo());
   return o;
 }
 
-checkUnnamed619(core.List<api.Video> o) {
+checkUnnamed618(core.List<api.Video> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideo(o[0]);
   checkVideo(o[1]);
 }
 
 core.int buildCounterVideoListResponse = 0;
 buildVideoListResponse() {
   var o = new api.VideoListResponse();
   buildCounterVideoListResponse++;
   if (buildCounterVideoListResponse < 3) {
     o.etag = "foo";
     o.eventId = "foo";
-    o.items = buildUnnamed619();
+    o.items = buildUnnamed618();
     o.kind = "foo";
     o.nextPageToken = "foo";
     o.pageInfo = buildPageInfo();
     o.prevPageToken = "foo";
     o.tokenPagination = buildTokenPagination();
     o.visitorId = "foo";
   }
   buildCounterVideoListResponse--;
   return o;
 }
 
 checkVideoListResponse(api.VideoListResponse o) {
   buildCounterVideoListResponse++;
   if (buildCounterVideoListResponse < 3) {
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.eventId, unittest.equals('foo'));
-    checkUnnamed619(o.items);
+    checkUnnamed618(o.items);
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
     checkPageInfo(o.pageInfo);
     unittest.expect(o.prevPageToken, unittest.equals('foo'));
     checkTokenPagination(o.tokenPagination);
     unittest.expect(o.visitorId, unittest.equals('foo'));
   }
   buildCounterVideoListResponse--;
 }
 
@@ skipping 10 matching lines @@
     o.scheduledStartTime = core.DateTime.parse("2002-02-27T14:01:02");
   }
   buildCounterVideoLiveStreamingDetails--;
   return o;
 }
 
 checkVideoLiveStreamingDetails(api.VideoLiveStreamingDetails o) {
   buildCounterVideoLiveStreamingDetails++;
   if (buildCounterVideoLiveStreamingDetails < 3) {
     unittest.expect(o.activeLiveChatId, unittest.equals('foo'));
-    unittest.expect(o.actualEndTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    unittest.expect(o.actualStartTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.actualEndTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.actualStartTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.concurrentViewers, unittest.equals('foo'));
-    unittest.expect(o.scheduledEndTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    unittest.expect(o.scheduledStartTime, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.scheduledEndTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.scheduledStartTime,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterVideoLiveStreamingDetails--;
 }
 
 core.int buildCounterVideoLocalization = 0;
 buildVideoLocalization() {
   var o = new api.VideoLocalization();
   buildCounterVideoLocalization++;
   if (buildCounterVideoLocalization < 3) {
     o.description = "foo";
@@ skipping 93 matching lines @@
   buildCounterVideoProcessingDetailsProcessingProgress++;
   if (buildCounterVideoProcessingDetailsProcessingProgress < 3) {
     o.partsProcessed = "foo";
     o.partsTotal = "foo";
     o.timeLeftMs = "foo";
   }
   buildCounterVideoProcessingDetailsProcessingProgress--;
   return o;
 }
 
-checkVideoProcessingDetailsProcessingProgress(api.VideoProcessingDetailsProcessingProgress o) {
+checkVideoProcessingDetailsProcessingProgress(
+    api.VideoProcessingDetailsProcessingProgress o) {
   buildCounterVideoProcessingDetailsProcessingProgress++;
   if (buildCounterVideoProcessingDetailsProcessingProgress < 3) {
     unittest.expect(o.partsProcessed, unittest.equals('foo'));
     unittest.expect(o.partsTotal, unittest.equals('foo'));
     unittest.expect(o.timeLeftMs, unittest.equals('foo'));
   }
   buildCounterVideoProcessingDetailsProcessingProgress--;
 }
 
-buildUnnamed620() {
+buildUnnamed619() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed620(core.List<core.String> o) {
+checkUnnamed619(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 buildCounterVideoProjectDetails = 0;
 buildVideoProjectDetails() {
   var o = new api.VideoProjectDetails();
   buildCounterVideoProjectDetails++;
   if (buildCounterVideoProjectDetails < 3) {
-    o.tags = buildUnnamed620();
+    o.tags = buildUnnamed619();
   }
   buildCounterVideoProjectDetails--;
   return o;
 }
 
 checkVideoProjectDetails(api.VideoProjectDetails o) {
   buildCounterVideoProjectDetails++;
   if (buildCounterVideoProjectDetails < 3) {
-    checkUnnamed620(o.tags);
+    checkUnnamed619(o.tags);
   }
   buildCounterVideoProjectDetails--;
 }
 
 core.int buildCounterVideoRating = 0;
 buildVideoRating() {
   var o = new api.VideoRating();
   buildCounterVideoRating++;
   if (buildCounterVideoRating < 3) {
     o.rating = "foo";
@@ skipping 23 matching lines @@
   }
   buildCounterVideoRecordingDetails--;
   return o;
 }
 
 checkVideoRecordingDetails(api.VideoRecordingDetails o) {
   buildCounterVideoRecordingDetails++;
   if (buildCounterVideoRecordingDetails < 3) {
     checkGeoPoint(o.location);
     unittest.expect(o.locationDescription, unittest.equals('foo'));
-    unittest.expect(o.recordingDate, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.recordingDate,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
   }
   buildCounterVideoRecordingDetails--;
 }
 
-buildUnnamed621() {
+buildUnnamed620() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed621(core.List<core.String> o) {
+checkUnnamed620(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 buildCounterVideoSnippet = 0;
 buildVideoSnippet() {
   var o = new api.VideoSnippet();
   buildCounterVideoSnippet++;
   if (buildCounterVideoSnippet < 3) {
     o.categoryId = "foo";
     o.channelId = "foo";
     o.channelTitle = "foo";
     o.defaultAudioLanguage = "foo";
     o.defaultLanguage = "foo";
     o.description = "foo";
     o.liveBroadcastContent = "foo";
     o.localized = buildVideoLocalization();
     o.publishedAt = core.DateTime.parse("2002-02-27T14:01:02");
-    o.tags = buildUnnamed621();
+    o.tags = buildUnnamed620();
     o.thumbnails = buildThumbnailDetails();
     o.title = "foo";
   }
   buildCounterVideoSnippet--;
   return o;
 }
 
 checkVideoSnippet(api.VideoSnippet o) {
   buildCounterVideoSnippet++;
   if (buildCounterVideoSnippet < 3) {
     unittest.expect(o.categoryId, unittest.equals('foo'));
     unittest.expect(o.channelId, unittest.equals('foo'));
     unittest.expect(o.channelTitle, unittest.equals('foo'));
     unittest.expect(o.defaultAudioLanguage, unittest.equals('foo'));
     unittest.expect(o.defaultLanguage, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.liveBroadcastContent, unittest.equals('foo'));
     checkVideoLocalization(o.localized);
-    unittest.expect(o.publishedAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
-    checkUnnamed621(o.tags);
+    unittest.expect(o.publishedAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    checkUnnamed620(o.tags);
     checkThumbnailDetails(o.thumbnails);
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterVideoSnippet--;
 }
 
 core.int buildCounterVideoStatistics = 0;
 buildVideoStatistics() {
   var o = new api.VideoStatistics();
   buildCounterVideoStatistics++;
@@ skipping 39 matching lines @@
 }
 
 checkVideoStatus(api.VideoStatus o) {
   buildCounterVideoStatus++;
   if (buildCounterVideoStatus < 3) {
     unittest.expect(o.embeddable, unittest.isTrue);
     unittest.expect(o.failureReason, unittest.equals('foo'));
     unittest.expect(o.license, unittest.equals('foo'));
     unittest.expect(o.privacyStatus, unittest.equals('foo'));
     unittest.expect(o.publicStatsViewable, unittest.isTrue);
-    unittest.expect(o.publishAt, unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
+    unittest.expect(o.publishAt,
+        unittest.equals(core.DateTime.parse("2002-02-27T14:01:02")));
     unittest.expect(o.rejectionReason, unittest.equals('foo'));
     unittest.expect(o.uploadStatus, unittest.equals('foo'));
   }
   buildCounterVideoStatus--;
 }
 
+buildUnnamed621() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed621(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'));
+}
+
 buildUnnamed622() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed622(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
@@ skipping 20 matching lines @@
   return o;
 }
 
 checkUnnamed624(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'));
 }
 
 buildUnnamed625() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed625(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'));
-}
-
-buildUnnamed626() {
   var o = new core.List<api.VideoSuggestionsTagSuggestion>();
   o.add(buildVideoSuggestionsTagSuggestion());
   o.add(buildVideoSuggestionsTagSuggestion());
   return o;
 }
 
-checkUnnamed626(core.List<api.VideoSuggestionsTagSuggestion> o) {
+checkUnnamed625(core.List<api.VideoSuggestionsTagSuggestion> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVideoSuggestionsTagSuggestion(o[0]);
   checkVideoSuggestionsTagSuggestion(o[1]);
 }
 
 core.int buildCounterVideoSuggestions = 0;
 buildVideoSuggestions() {
   var o = new api.VideoSuggestions();
   buildCounterVideoSuggestions++;
   if (buildCounterVideoSuggestions < 3) {
-    o.editorSuggestions = buildUnnamed622();
-    o.processingErrors = buildUnnamed623();
-    o.processingHints = buildUnnamed624();
-    o.processingWarnings = buildUnnamed625();
-    o.tagSuggestions = buildUnnamed626();
+    o.editorSuggestions = buildUnnamed621();
+    o.processingErrors = buildUnnamed622();
+    o.processingHints = buildUnnamed623();
+    o.processingWarnings = buildUnnamed624();
+    o.tagSuggestions = buildUnnamed625();
   }
   buildCounterVideoSuggestions--;
   return o;
 }
 
 checkVideoSuggestions(api.VideoSuggestions o) {
   buildCounterVideoSuggestions++;
   if (buildCounterVideoSuggestions < 3) {
-    checkUnnamed622(o.editorSuggestions);
-    checkUnnamed623(o.processingErrors);
-    checkUnnamed624(o.processingHints);
-    checkUnnamed625(o.processingWarnings);
-    checkUnnamed626(o.tagSuggestions);
+    checkUnnamed621(o.editorSuggestions);
+    checkUnnamed622(o.processingErrors);
+    checkUnnamed623(o.processingHints);
+    checkUnnamed624(o.processingWarnings);
+    checkUnnamed625(o.tagSuggestions);
   }
   buildCounterVideoSuggestions--;
 }
 
-buildUnnamed627() {
+buildUnnamed626() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed627(core.List<core.String> o) {
+checkUnnamed626(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 buildCounterVideoSuggestionsTagSuggestion = 0;
 buildVideoSuggestionsTagSuggestion() {
   var o = new api.VideoSuggestionsTagSuggestion();
   buildCounterVideoSuggestionsTagSuggestion++;
   if (buildCounterVideoSuggestionsTagSuggestion < 3) {
-    o.categoryRestricts = buildUnnamed627();
+    o.categoryRestricts = buildUnnamed626();
     o.tag = "foo";
   }
   buildCounterVideoSuggestionsTagSuggestion--;
   return o;
 }
 
 checkVideoSuggestionsTagSuggestion(api.VideoSuggestionsTagSuggestion o) {
   buildCounterVideoSuggestionsTagSuggestion++;
   if (buildCounterVideoSuggestionsTagSuggestion < 3) {
-    checkUnnamed627(o.categoryRestricts);
+    checkUnnamed626(o.categoryRestricts);
     unittest.expect(o.tag, unittest.equals('foo'));
   }
   buildCounterVideoSuggestionsTagSuggestion--;
 }
 
+buildUnnamed627() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed627(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'));
+}
+
 buildUnnamed628() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed628(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'));
 }
 
 buildUnnamed629() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed629(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'));
-}
-
-buildUnnamed630() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed630(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 buildCounterVideoTopicDetails = 0;
 buildVideoTopicDetails() {
   var o = new api.VideoTopicDetails();
   buildCounterVideoTopicDetails++;
   if (buildCounterVideoTopicDetails < 3) {
-    o.relevantTopicIds = buildUnnamed628();
-    o.topicCategories = buildUnnamed629();
-    o.topicIds = buildUnnamed630();
+    o.relevantTopicIds = buildUnnamed627();
+    o.topicCategories = buildUnnamed628();
+    o.topicIds = buildUnnamed629();
   }
   buildCounterVideoTopicDetails--;
   return o;
 }
 
 checkVideoTopicDetails(api.VideoTopicDetails o) {
   buildCounterVideoTopicDetails++;
   if (buildCounterVideoTopicDetails < 3) {
-    checkUnnamed628(o.relevantTopicIds);
-    checkUnnamed629(o.topicCategories);
-    checkUnnamed630(o.topicIds);
+    checkUnnamed627(o.relevantTopicIds);
+    checkUnnamed628(o.topicCategories);
+    checkUnnamed629(o.topicIds);
   }
   buildCounterVideoTopicDetails--;
 }
 
 core.int buildCounterWatchSettings = 0;
 buildWatchSettings() {
   var o = new api.WatchSettings();
   buildCounterWatchSettings++;
   if (buildCounterWatchSettings < 3) {
     o.backgroundColor = "foo";
     o.featuredPlaylistId = "foo";
     o.textColor = "foo";
   }
   buildCounterWatchSettings--;
   return o;
 }
 
 checkWatchSettings(api.WatchSettings o) {
   buildCounterWatchSettings++;
   if (buildCounterWatchSettings < 3) {
     unittest.expect(o.backgroundColor, unittest.equals('foo'));
     unittest.expect(o.featuredPlaylistId, unittest.equals('foo'));
     unittest.expect(o.textColor, unittest.equals('foo'));
   }
   buildCounterWatchSettings--;
 }
 
-
 main() {
   unittest.group("obj-schema-AccessPolicy", () {
     unittest.test("to-json--from-json", () {
       var o = buildAccessPolicy();
       var od = new api.AccessPolicy.fromJson(o.toJson());
       checkAccessPolicy(od);
     });
   });
 
-
   unittest.group("obj-schema-Activity", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivity();
       var od = new api.Activity.fromJson(o.toJson());
       checkActivity(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetails();
       var od = new api.ActivityContentDetails.fromJson(o.toJson());
       checkActivityContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsBulletin", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsBulletin();
       var od = new api.ActivityContentDetailsBulletin.fromJson(o.toJson());
       checkActivityContentDetailsBulletin(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsChannelItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsChannelItem();
       var od = new api.ActivityContentDetailsChannelItem.fromJson(o.toJson());
       checkActivityContentDetailsChannelItem(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsComment", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsComment();
       var od = new api.ActivityContentDetailsComment.fromJson(o.toJson());
       checkActivityContentDetailsComment(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsFavorite", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsFavorite();
       var od = new api.ActivityContentDetailsFavorite.fromJson(o.toJson());
       checkActivityContentDetailsFavorite(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsLike", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsLike();
       var od = new api.ActivityContentDetailsLike.fromJson(o.toJson());
       checkActivityContentDetailsLike(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsPlaylistItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsPlaylistItem();
       var od = new api.ActivityContentDetailsPlaylistItem.fromJson(o.toJson());
       checkActivityContentDetailsPlaylistItem(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsPromotedItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsPromotedItem();
       var od = new api.ActivityContentDetailsPromotedItem.fromJson(o.toJson());
       checkActivityContentDetailsPromotedItem(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsRecommendation", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsRecommendation();
-      var od = new api.ActivityContentDetailsRecommendation.fromJson(o.toJson());
+      var od =
+          new api.ActivityContentDetailsRecommendation.fromJson(o.toJson());
       checkActivityContentDetailsRecommendation(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsSocial", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsSocial();
       var od = new api.ActivityContentDetailsSocial.fromJson(o.toJson());
       checkActivityContentDetailsSocial(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsSubscription", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsSubscription();
       var od = new api.ActivityContentDetailsSubscription.fromJson(o.toJson());
       checkActivityContentDetailsSubscription(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityContentDetailsUpload", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityContentDetailsUpload();
       var od = new api.ActivityContentDetailsUpload.fromJson(o.toJson());
       checkActivityContentDetailsUpload(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivityListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivityListResponse();
       var od = new api.ActivityListResponse.fromJson(o.toJson());
       checkActivityListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ActivitySnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildActivitySnippet();
       var od = new api.ActivitySnippet.fromJson(o.toJson());
       checkActivitySnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-Caption", () {
     unittest.test("to-json--from-json", () {
       var o = buildCaption();
       var od = new api.Caption.fromJson(o.toJson());
       checkCaption(od);
     });
   });
 
-
   unittest.group("obj-schema-CaptionListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildCaptionListResponse();
       var od = new api.CaptionListResponse.fromJson(o.toJson());
       checkCaptionListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-CaptionSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildCaptionSnippet();
       var od = new api.CaptionSnippet.fromJson(o.toJson());
       checkCaptionSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-CdnSettings", () {
     unittest.test("to-json--from-json", () {
       var o = buildCdnSettings();
       var od = new api.CdnSettings.fromJson(o.toJson());
       checkCdnSettings(od);
     });
   });
 
-
   unittest.group("obj-schema-Channel", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannel();
       var od = new api.Channel.fromJson(o.toJson());
       checkChannel(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelAuditDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelAuditDetails();
       var od = new api.ChannelAuditDetails.fromJson(o.toJson());
       checkChannelAuditDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelBannerResource", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelBannerResource();
       var od = new api.ChannelBannerResource.fromJson(o.toJson());
       checkChannelBannerResource(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelBrandingSettings", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelBrandingSettings();
       var od = new api.ChannelBrandingSettings.fromJson(o.toJson());
       checkChannelBrandingSettings(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelContentDetailsRelatedPlaylists", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelContentDetailsRelatedPlaylists();
-      var od = new api.ChannelContentDetailsRelatedPlaylists.fromJson(o.toJson());
+      var od =
+          new api.ChannelContentDetailsRelatedPlaylists.fromJson(o.toJson());
       checkChannelContentDetailsRelatedPlaylists(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelContentDetails();
       var od = new api.ChannelContentDetails.fromJson(o.toJson());
       checkChannelContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelContentOwnerDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelContentOwnerDetails();
       var od = new api.ChannelContentOwnerDetails.fromJson(o.toJson());
       checkChannelContentOwnerDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelConversionPing", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelConversionPing();
       var od = new api.ChannelConversionPing.fromJson(o.toJson());
       checkChannelConversionPing(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelConversionPings", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelConversionPings();
       var od = new api.ChannelConversionPings.fromJson(o.toJson());
       checkChannelConversionPings(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelListResponse();
       var od = new api.ChannelListResponse.fromJson(o.toJson());
       checkChannelListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelLocalization", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelLocalization();
       var od = new api.ChannelLocalization.fromJson(o.toJson());
       checkChannelLocalization(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelProfileDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelProfileDetails();
       var od = new api.ChannelProfileDetails.fromJson(o.toJson());
       checkChannelProfileDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSection", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSection();
       var od = new api.ChannelSection.fromJson(o.toJson());
       checkChannelSection(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSectionContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSectionContentDetails();
       var od = new api.ChannelSectionContentDetails.fromJson(o.toJson());
       checkChannelSectionContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSectionListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSectionListResponse();
       var od = new api.ChannelSectionListResponse.fromJson(o.toJson());
       checkChannelSectionListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSectionLocalization", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSectionLocalization();
       var od = new api.ChannelSectionLocalization.fromJson(o.toJson());
       checkChannelSectionLocalization(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSectionSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSectionSnippet();
       var od = new api.ChannelSectionSnippet.fromJson(o.toJson());
       checkChannelSectionSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSectionTargeting", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSectionTargeting();
       var od = new api.ChannelSectionTargeting.fromJson(o.toJson());
       checkChannelSectionTargeting(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSettings", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSettings();
       var od = new api.ChannelSettings.fromJson(o.toJson());
       checkChannelSettings(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelSnippet();
       var od = new api.ChannelSnippet.fromJson(o.toJson());
       checkChannelSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelStatistics", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelStatistics();
       var od = new api.ChannelStatistics.fromJson(o.toJson());
       checkChannelStatistics(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelStatus();
       var od = new api.ChannelStatus.fromJson(o.toJson());
       checkChannelStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-ChannelTopicDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildChannelTopicDetails();
       var od = new api.ChannelTopicDetails.fromJson(o.toJson());
       checkChannelTopicDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-Comment", () {
     unittest.test("to-json--from-json", () {
       var o = buildComment();
       var od = new api.Comment.fromJson(o.toJson());
       checkComment(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentListResponse();
       var od = new api.CommentListResponse.fromJson(o.toJson());
       checkCommentListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentSnippet();
       var od = new api.CommentSnippet.fromJson(o.toJson());
       checkCommentSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentThread", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentThread();
       var od = new api.CommentThread.fromJson(o.toJson());
       checkCommentThread(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentThreadListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentThreadListResponse();
       var od = new api.CommentThreadListResponse.fromJson(o.toJson());
       checkCommentThreadListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentThreadReplies", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentThreadReplies();
       var od = new api.CommentThreadReplies.fromJson(o.toJson());
       checkCommentThreadReplies(od);
     });
   });
 
-
   unittest.group("obj-schema-CommentThreadSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildCommentThreadSnippet();
       var od = new api.CommentThreadSnippet.fromJson(o.toJson());
       checkCommentThreadSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-ContentRating", () {
     unittest.test("to-json--from-json", () {
       var o = buildContentRating();
       var od = new api.ContentRating.fromJson(o.toJson());
       checkContentRating(od);
     });
   });
 
-
   unittest.group("obj-schema-FanFundingEvent", () {
     unittest.test("to-json--from-json", () {
       var o = buildFanFundingEvent();
       var od = new api.FanFundingEvent.fromJson(o.toJson());
       checkFanFundingEvent(od);
     });
   });
 
-
   unittest.group("obj-schema-FanFundingEventListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildFanFundingEventListResponse();
       var od = new api.FanFundingEventListResponse.fromJson(o.toJson());
       checkFanFundingEventListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-FanFundingEventSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildFanFundingEventSnippet();
       var od = new api.FanFundingEventSnippet.fromJson(o.toJson());
       checkFanFundingEventSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-GeoPoint", () {
     unittest.test("to-json--from-json", () {
       var o = buildGeoPoint();
       var od = new api.GeoPoint.fromJson(o.toJson());
       checkGeoPoint(od);
     });
   });
 
-
   unittest.group("obj-schema-GuideCategory", () {
     unittest.test("to-json--from-json", () {
       var o = buildGuideCategory();
       var od = new api.GuideCategory.fromJson(o.toJson());
       checkGuideCategory(od);
     });
   });
 
-
   unittest.group("obj-schema-GuideCategoryListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildGuideCategoryListResponse();
       var od = new api.GuideCategoryListResponse.fromJson(o.toJson());
       checkGuideCategoryListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-GuideCategorySnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildGuideCategorySnippet();
       var od = new api.GuideCategorySnippet.fromJson(o.toJson());
       checkGuideCategorySnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nLanguage", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nLanguage();
       var od = new api.I18nLanguage.fromJson(o.toJson());
       checkI18nLanguage(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nLanguageListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nLanguageListResponse();
       var od = new api.I18nLanguageListResponse.fromJson(o.toJson());
       checkI18nLanguageListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nLanguageSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nLanguageSnippet();
       var od = new api.I18nLanguageSnippet.fromJson(o.toJson());
       checkI18nLanguageSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nRegion", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nRegion();
       var od = new api.I18nRegion.fromJson(o.toJson());
       checkI18nRegion(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nRegionListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nRegionListResponse();
       var od = new api.I18nRegionListResponse.fromJson(o.toJson());
       checkI18nRegionListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-I18nRegionSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildI18nRegionSnippet();
       var od = new api.I18nRegionSnippet.fromJson(o.toJson());
       checkI18nRegionSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-ImageSettings", () {
     unittest.test("to-json--from-json", () {
       var o = buildImageSettings();
       var od = new api.ImageSettings.fromJson(o.toJson());
       checkImageSettings(od);
     });
   });
 
-
   unittest.group("obj-schema-IngestionInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildIngestionInfo();
       var od = new api.IngestionInfo.fromJson(o.toJson());
       checkIngestionInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-InvideoBranding", () {
     unittest.test("to-json--from-json", () {
       var o = buildInvideoBranding();
       var od = new api.InvideoBranding.fromJson(o.toJson());
       checkInvideoBranding(od);
     });
   });
 
-
   unittest.group("obj-schema-InvideoPosition", () {
     unittest.test("to-json--from-json", () {
       var o = buildInvideoPosition();
       var od = new api.InvideoPosition.fromJson(o.toJson());
       checkInvideoPosition(od);
     });
   });
 
-
   unittest.group("obj-schema-InvideoPromotion", () {
     unittest.test("to-json--from-json", () {
       var o = buildInvideoPromotion();
       var od = new api.InvideoPromotion.fromJson(o.toJson());
       checkInvideoPromotion(od);
     });
   });
 
-
   unittest.group("obj-schema-InvideoTiming", () {
     unittest.test("to-json--from-json", () {
       var o = buildInvideoTiming();
       var od = new api.InvideoTiming.fromJson(o.toJson());
       checkInvideoTiming(od);
     });
   });
 
-
   unittest.group("obj-schema-LanguageTag", () {
     unittest.test("to-json--from-json", () {
       var o = buildLanguageTag();
       var od = new api.LanguageTag.fromJson(o.toJson());
       checkLanguageTag(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcast", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcast();
       var od = new api.LiveBroadcast.fromJson(o.toJson());
       checkLiveBroadcast(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastContentDetails();
       var od = new api.LiveBroadcastContentDetails.fromJson(o.toJson());
       checkLiveBroadcastContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastListResponse();
       var od = new api.LiveBroadcastListResponse.fromJson(o.toJson());
       checkLiveBroadcastListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastSnippet();
       var od = new api.LiveBroadcastSnippet.fromJson(o.toJson());
       checkLiveBroadcastSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastStatistics", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastStatistics();
       var od = new api.LiveBroadcastStatistics.fromJson(o.toJson());
       checkLiveBroadcastStatistics(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastStatus();
       var od = new api.LiveBroadcastStatus.fromJson(o.toJson());
       checkLiveBroadcastStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastTopic", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastTopic();
       var od = new api.LiveBroadcastTopic.fromJson(o.toJson());
       checkLiveBroadcastTopic(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastTopicDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastTopicDetails();
       var od = new api.LiveBroadcastTopicDetails.fromJson(o.toJson());
       checkLiveBroadcastTopicDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveBroadcastTopicSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveBroadcastTopicSnippet();
       var od = new api.LiveBroadcastTopicSnippet.fromJson(o.toJson());
       checkLiveBroadcastTopicSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatBan", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatBan();
       var od = new api.LiveChatBan.fromJson(o.toJson());
       checkLiveChatBan(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatBanSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatBanSnippet();
       var od = new api.LiveChatBanSnippet.fromJson(o.toJson());
       checkLiveChatBanSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatFanFundingEventDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatFanFundingEventDetails();
       var od = new api.LiveChatFanFundingEventDetails.fromJson(o.toJson());
       checkLiveChatFanFundingEventDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessage", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessage();
       var od = new api.LiveChatMessage.fromJson(o.toJson());
       checkLiveChatMessage(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessageAuthorDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessageAuthorDetails();
       var od = new api.LiveChatMessageAuthorDetails.fromJson(o.toJson());
       checkLiveChatMessageAuthorDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessageDeletedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessageDeletedDetails();
       var od = new api.LiveChatMessageDeletedDetails.fromJson(o.toJson());
       checkLiveChatMessageDeletedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessageListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessageListResponse();
       var od = new api.LiveChatMessageListResponse.fromJson(o.toJson());
       checkLiveChatMessageListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessageRetractedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessageRetractedDetails();
       var od = new api.LiveChatMessageRetractedDetails.fromJson(o.toJson());
       checkLiveChatMessageRetractedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatMessageSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatMessageSnippet();
       var od = new api.LiveChatMessageSnippet.fromJson(o.toJson());
       checkLiveChatMessageSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatModerator", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatModerator();
       var od = new api.LiveChatModerator.fromJson(o.toJson());
       checkLiveChatModerator(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatModeratorListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatModeratorListResponse();
       var od = new api.LiveChatModeratorListResponse.fromJson(o.toJson());
       checkLiveChatModeratorListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatModeratorSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatModeratorSnippet();
       var od = new api.LiveChatModeratorSnippet.fromJson(o.toJson());
       checkLiveChatModeratorSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatPollClosedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatPollClosedDetails();
       var od = new api.LiveChatPollClosedDetails.fromJson(o.toJson());
       checkLiveChatPollClosedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatPollEditedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatPollEditedDetails();
       var od = new api.LiveChatPollEditedDetails.fromJson(o.toJson());
       checkLiveChatPollEditedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatPollItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatPollItem();
       var od = new api.LiveChatPollItem.fromJson(o.toJson());
       checkLiveChatPollItem(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatPollOpenedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatPollOpenedDetails();
       var od = new api.LiveChatPollOpenedDetails.fromJson(o.toJson());
       checkLiveChatPollOpenedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatPollVotedDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatPollVotedDetails();
       var od = new api.LiveChatPollVotedDetails.fromJson(o.toJson());
       checkLiveChatPollVotedDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatSuperChatDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatSuperChatDetails();
       var od = new api.LiveChatSuperChatDetails.fromJson(o.toJson());
       checkLiveChatSuperChatDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatTextMessageDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatTextMessageDetails();
       var od = new api.LiveChatTextMessageDetails.fromJson(o.toJson());
       checkLiveChatTextMessageDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveChatUserBannedMessageDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveChatUserBannedMessageDetails();
       var od = new api.LiveChatUserBannedMessageDetails.fromJson(o.toJson());
       checkLiveChatUserBannedMessageDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStream", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStream();
       var od = new api.LiveStream.fromJson(o.toJson());
       checkLiveStream(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamConfigurationIssue", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamConfigurationIssue();
       var od = new api.LiveStreamConfigurationIssue.fromJson(o.toJson());
       checkLiveStreamConfigurationIssue(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamContentDetails();
       var od = new api.LiveStreamContentDetails.fromJson(o.toJson());
       checkLiveStreamContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamHealthStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamHealthStatus();
       var od = new api.LiveStreamHealthStatus.fromJson(o.toJson());
       checkLiveStreamHealthStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamListResponse();
       var od = new api.LiveStreamListResponse.fromJson(o.toJson());
       checkLiveStreamListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamSnippet();
       var od = new api.LiveStreamSnippet.fromJson(o.toJson());
       checkLiveStreamSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-LiveStreamStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildLiveStreamStatus();
       var od = new api.LiveStreamStatus.fromJson(o.toJson());
       checkLiveStreamStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-LocalizedProperty", () {
     unittest.test("to-json--from-json", () {
       var o = buildLocalizedProperty();
       var od = new api.LocalizedProperty.fromJson(o.toJson());
       checkLocalizedProperty(od);
     });
   });
 
-
   unittest.group("obj-schema-LocalizedString", () {
     unittest.test("to-json--from-json", () {
       var o = buildLocalizedString();
       var od = new api.LocalizedString.fromJson(o.toJson());
       checkLocalizedString(od);
     });
   });
 
-
   unittest.group("obj-schema-MonitorStreamInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildMonitorStreamInfo();
       var od = new api.MonitorStreamInfo.fromJson(o.toJson());
       checkMonitorStreamInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-PageInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildPageInfo();
       var od = new api.PageInfo.fromJson(o.toJson());
       checkPageInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-Playlist", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylist();
       var od = new api.Playlist.fromJson(o.toJson());
       checkPlaylist(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistContentDetails();
       var od = new api.PlaylistContentDetails.fromJson(o.toJson());
       checkPlaylistContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistItem();
       var od = new api.PlaylistItem.fromJson(o.toJson());
       checkPlaylistItem(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistItemContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistItemContentDetails();
       var od = new api.PlaylistItemContentDetails.fromJson(o.toJson());
       checkPlaylistItemContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistItemListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistItemListResponse();
       var od = new api.PlaylistItemListResponse.fromJson(o.toJson());
       checkPlaylistItemListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistItemSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistItemSnippet();
       var od = new api.PlaylistItemSnippet.fromJson(o.toJson());
       checkPlaylistItemSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistItemStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistItemStatus();
       var od = new api.PlaylistItemStatus.fromJson(o.toJson());
       checkPlaylistItemStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistListResponse();
       var od = new api.PlaylistListResponse.fromJson(o.toJson());
       checkPlaylistListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistLocalization", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistLocalization();
       var od = new api.PlaylistLocalization.fromJson(o.toJson());
       checkPlaylistLocalization(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistPlayer", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistPlayer();
       var od = new api.PlaylistPlayer.fromJson(o.toJson());
       checkPlaylistPlayer(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistSnippet();
       var od = new api.PlaylistSnippet.fromJson(o.toJson());
       checkPlaylistSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-PlaylistStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildPlaylistStatus();
       var od = new api.PlaylistStatus.fromJson(o.toJson());
       checkPlaylistStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-PromotedItem", () {
     unittest.test("to-json--from-json", () {
       var o = buildPromotedItem();
       var od = new api.PromotedItem.fromJson(o.toJson());
       checkPromotedItem(od);
     });
   });
 
-
   unittest.group("obj-schema-PromotedItemId", () {
     unittest.test("to-json--from-json", () {
       var o = buildPromotedItemId();
       var od = new api.PromotedItemId.fromJson(o.toJson());
       checkPromotedItemId(od);
     });
   });
 
-
   unittest.group("obj-schema-PropertyValue", () {
     unittest.test("to-json--from-json", () {
       var o = buildPropertyValue();
       var od = new api.PropertyValue.fromJson(o.toJson());
       checkPropertyValue(od);
     });
   });
 
-
   unittest.group("obj-schema-ResourceId", () {
     unittest.test("to-json--from-json", () {
       var o = buildResourceId();
       var od = new api.ResourceId.fromJson(o.toJson());
       checkResourceId(od);
     });
   });
 
-
   unittest.group("obj-schema-SearchListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchListResponse();
       var od = new api.SearchListResponse.fromJson(o.toJson());
       checkSearchListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-SearchResult", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchResult();
       var od = new api.SearchResult.fromJson(o.toJson());
       checkSearchResult(od);
     });
   });
 
-
   unittest.group("obj-schema-SearchResultSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildSearchResultSnippet();
       var od = new api.SearchResultSnippet.fromJson(o.toJson());
       checkSearchResultSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-Sponsor", () {
     unittest.test("to-json--from-json", () {
       var o = buildSponsor();
       var od = new api.Sponsor.fromJson(o.toJson());
       checkSponsor(od);
     });
   });
 
-
   unittest.group("obj-schema-SponsorListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSponsorListResponse();
       var od = new api.SponsorListResponse.fromJson(o.toJson());
       checkSponsorListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-SponsorSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildSponsorSnippet();
       var od = new api.SponsorSnippet.fromJson(o.toJson());
       checkSponsorSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-Subscription", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubscription();
       var od = new api.Subscription.fromJson(o.toJson());
       checkSubscription(od);
     });
   });
 
-
   unittest.group("obj-schema-SubscriptionContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubscriptionContentDetails();
       var od = new api.SubscriptionContentDetails.fromJson(o.toJson());
       checkSubscriptionContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-SubscriptionListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubscriptionListResponse();
       var od = new api.SubscriptionListResponse.fromJson(o.toJson());
       checkSubscriptionListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-SubscriptionSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubscriptionSnippet();
       var od = new api.SubscriptionSnippet.fromJson(o.toJson());
       checkSubscriptionSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-SubscriptionSubscriberSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubscriptionSubscriberSnippet();
       var od = new api.SubscriptionSubscriberSnippet.fromJson(o.toJson());
       checkSubscriptionSubscriberSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-SuperChatEvent", () {
     unittest.test("to-json--from-json", () {
       var o = buildSuperChatEvent();
       var od = new api.SuperChatEvent.fromJson(o.toJson());
       checkSuperChatEvent(od);
     });
   });
 
-
   unittest.group("obj-schema-SuperChatEventListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSuperChatEventListResponse();
       var od = new api.SuperChatEventListResponse.fromJson(o.toJson());
       checkSuperChatEventListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-SuperChatEventSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildSuperChatEventSnippet();
       var od = new api.SuperChatEventSnippet.fromJson(o.toJson());
       checkSuperChatEventSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-Thumbnail", () {
     unittest.test("to-json--from-json", () {
       var o = buildThumbnail();
       var od = new api.Thumbnail.fromJson(o.toJson());
       checkThumbnail(od);
     });
   });
 
-
   unittest.group("obj-schema-ThumbnailDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildThumbnailDetails();
       var od = new api.ThumbnailDetails.fromJson(o.toJson());
       checkThumbnailDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-ThumbnailSetResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildThumbnailSetResponse();
       var od = new api.ThumbnailSetResponse.fromJson(o.toJson());
       checkThumbnailSetResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-TokenPagination", () {
     unittest.test("to-json--from-json", () {
       var o = buildTokenPagination();
       var od = new api.TokenPagination.fromJson(o.toJson());
       checkTokenPagination(od);
     });
   });
 
-
   unittest.group("obj-schema-Video", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideo();
       var od = new api.Video.fromJson(o.toJson());
       checkVideo(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAbuseReport", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAbuseReport();
       var od = new api.VideoAbuseReport.fromJson(o.toJson());
       checkVideoAbuseReport(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAbuseReportReason", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAbuseReportReason();
       var od = new api.VideoAbuseReportReason.fromJson(o.toJson());
       checkVideoAbuseReportReason(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAbuseReportReasonListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAbuseReportReasonListResponse();
       var od = new api.VideoAbuseReportReasonListResponse.fromJson(o.toJson());
       checkVideoAbuseReportReasonListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAbuseReportReasonSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAbuseReportReasonSnippet();
       var od = new api.VideoAbuseReportReasonSnippet.fromJson(o.toJson());
       checkVideoAbuseReportReasonSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAbuseReportSecondaryReason", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAbuseReportSecondaryReason();
       var od = new api.VideoAbuseReportSecondaryReason.fromJson(o.toJson());
       checkVideoAbuseReportSecondaryReason(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoAgeGating", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoAgeGating();
       var od = new api.VideoAgeGating.fromJson(o.toJson());
       checkVideoAgeGating(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoCategory", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoCategory();
       var od = new api.VideoCategory.fromJson(o.toJson());
       checkVideoCategory(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoCategoryListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoCategoryListResponse();
       var od = new api.VideoCategoryListResponse.fromJson(o.toJson());
       checkVideoCategoryListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoCategorySnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoCategorySnippet();
       var od = new api.VideoCategorySnippet.fromJson(o.toJson());
       checkVideoCategorySnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoContentDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoContentDetails();
       var od = new api.VideoContentDetails.fromJson(o.toJson());
       checkVideoContentDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoContentDetailsRegionRestriction", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoContentDetailsRegionRestriction();
-      var od = new api.VideoContentDetailsRegionRestriction.fromJson(o.toJson());
+      var od =
+          new api.VideoContentDetailsRegionRestriction.fromJson(o.toJson());
       checkVideoContentDetailsRegionRestriction(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoFileDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoFileDetails();
       var od = new api.VideoFileDetails.fromJson(o.toJson());
       checkVideoFileDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoFileDetailsAudioStream", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoFileDetailsAudioStream();
       var od = new api.VideoFileDetailsAudioStream.fromJson(o.toJson());
       checkVideoFileDetailsAudioStream(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoFileDetailsVideoStream", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoFileDetailsVideoStream();
       var od = new api.VideoFileDetailsVideoStream.fromJson(o.toJson());
       checkVideoFileDetailsVideoStream(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoGetRatingResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoGetRatingResponse();
       var od = new api.VideoGetRatingResponse.fromJson(o.toJson());
       checkVideoGetRatingResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoListResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoListResponse();
       var od = new api.VideoListResponse.fromJson(o.toJson());
       checkVideoListResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoLiveStreamingDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoLiveStreamingDetails();
       var od = new api.VideoLiveStreamingDetails.fromJson(o.toJson());
       checkVideoLiveStreamingDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoLocalization", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoLocalization();
       var od = new api.VideoLocalization.fromJson(o.toJson());
       checkVideoLocalization(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoMonetizationDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoMonetizationDetails();
       var od = new api.VideoMonetizationDetails.fromJson(o.toJson());
       checkVideoMonetizationDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoPlayer", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoPlayer();
       var od = new api.VideoPlayer.fromJson(o.toJson());
       checkVideoPlayer(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoProcessingDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoProcessingDetails();
       var od = new api.VideoProcessingDetails.fromJson(o.toJson());
       checkVideoProcessingDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoProcessingDetailsProcessingProgress", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoProcessingDetailsProcessingProgress();
-      var od = new api.VideoProcessingDetailsProcessingProgress.fromJson(o.toJson());
+      var od =
+          new api.VideoProcessingDetailsProcessingProgress.fromJson(o.toJson());
       checkVideoProcessingDetailsProcessingProgress(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoProjectDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoProjectDetails();
       var od = new api.VideoProjectDetails.fromJson(o.toJson());
       checkVideoProjectDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoRating", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoRating();
       var od = new api.VideoRating.fromJson(o.toJson());
       checkVideoRating(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoRecordingDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoRecordingDetails();
       var od = new api.VideoRecordingDetails.fromJson(o.toJson());
       checkVideoRecordingDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoSnippet", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoSnippet();
       var od = new api.VideoSnippet.fromJson(o.toJson());
       checkVideoSnippet(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoStatistics", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoStatistics();
       var od = new api.VideoStatistics.fromJson(o.toJson());
       checkVideoStatistics(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoStatus", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoStatus();
       var od = new api.VideoStatus.fromJson(o.toJson());
       checkVideoStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoSuggestions", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoSuggestions();
       var od = new api.VideoSuggestions.fromJson(o.toJson());
       checkVideoSuggestions(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoSuggestionsTagSuggestion", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoSuggestionsTagSuggestion();
       var od = new api.VideoSuggestionsTagSuggestion.fromJson(o.toJson());
       checkVideoSuggestionsTagSuggestion(od);
     });
   });
 
-
   unittest.group("obj-schema-VideoTopicDetails", () {
     unittest.test("to-json--from-json", () {
       var o = buildVideoTopicDetails();
       var od = new api.VideoTopicDetails.fromJson(o.toJson());
       checkVideoTopicDetails(od);
     });
   });
 
-
   unittest.group("obj-schema-WatchSettings", () {
     unittest.test("to-json--from-json", () {
       var o = buildWatchSettings();
       var od = new api.WatchSettings.fromJson(o.toJson());
       checkWatchSettings(od);
     });
   });
 
-
   unittest.group("resource-ActivitiesResourceApi", () {
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.ActivitiesResourceApi res = new api.YoutubeApi(mock).activities;
       var arg_request = buildActivity();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Activity.fromJson(json);
         checkActivity(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("activities"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10),
+            unittest.equals("activities"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildActivity());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.Activity response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.Activity response) {
         checkActivity(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.ActivitiesResourceApi res = new api.YoutubeApi(mock).activities;
       var arg_part = "foo";
       var arg_channelId = "foo";
       var arg_home = true;
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_pageToken = "foo";
       var arg_publishedAfter = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_publishedBefore = core.DateTime.parse("2002-02-27T14:01:02");
       var arg_regionCode = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("activities"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10),
+            unittest.equals("activities"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
         unittest.expect(queryMap["home"].first, unittest.equals("$arg_home"));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.DateTime.parse(queryMap["publishedAfter"].first), unittest.equals(arg_publishedAfter));
-        unittest.expect(core.DateTime.parse(queryMap["publishedBefore"].first), unittest.equals(arg_publishedBefore));
-        unittest.expect(queryMap["regionCode"].first, unittest.equals(arg_regionCode));
-
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.DateTime.parse(queryMap["publishedAfter"].first),
+            unittest.equals(arg_publishedAfter));
+        unittest.expect(core.DateTime.parse(queryMap["publishedBefore"].first),
+            unittest.equals(arg_publishedBefore));
+        unittest.expect(
+            queryMap["regionCode"].first, unittest.equals(arg_regionCode));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildActivityListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, channelId: arg_channelId, home: arg_home, maxResults: arg_maxResults, mine: arg_mine, pageToken: arg_pageToken, publishedAfter: arg_publishedAfter, publishedBefore: arg_publishedBefore, regionCode: arg_regionCode).then(unittest.expectAsync1(((api.ActivityListResponse response) {
+      res
+          .list(arg_part,
+              channelId: arg_channelId,
+              home: arg_home,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              pageToken: arg_pageToken,
+              publishedAfter: arg_publishedAfter,
+              publishedBefore: arg_publishedBefore,
+              regionCode: arg_regionCode)
+          .then(unittest.expectAsync1(((api.ActivityListResponse response) {
         checkActivityListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-CaptionsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.CaptionsResourceApi res = new api.YoutubeApi(mock).captions;
       var arg_id = "foo";
       var arg_onBehalfOf = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("captions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("captions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(
+            queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOf: arg_onBehalfOf, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id,
+              onBehalfOf: arg_onBehalfOf,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--download", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.CaptionsResourceApi res = new api.YoutubeApi(mock).captions;
       var arg_id = "foo";
       var arg_onBehalfOf = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_tfmt = "foo";
       var arg_tlang = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("captions/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("captions/"));
         pathOffset += 9;
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
         unittest.expect(queryMap["tfmt"].first, unittest.equals(arg_tfmt));
         unittest.expect(queryMap["tlang"].first, unittest.equals(arg_tlang));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.download(arg_id, onBehalfOf: arg_onBehalfOf, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, tfmt: arg_tfmt, tlang: arg_tlang).then(unittest.expectAsync1((_) {}));
+      res
+          .download(arg_id,
+              onBehalfOf: arg_onBehalfOf,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              tfmt: arg_tfmt,
+              tlang: arg_tlang)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.CaptionsResourceApi res = new api.YoutubeApi(mock).captions;
       var arg_request = buildCaption();
       var arg_part = "foo";
       var arg_onBehalfOf = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_sync = true;
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Caption.fromJson(json);
         checkCaption(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("captions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("captions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
         unittest.expect(queryMap["sync"].first, unittest.equals("$arg_sync"));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCaption());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOf: arg_onBehalfOf, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, sync: arg_sync).then(unittest.expectAsync1(((api.Caption response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOf: arg_onBehalfOf,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              sync: arg_sync)
+          .then(unittest.expectAsync1(((api.Caption response) {
         checkCaption(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.CaptionsResourceApi res = new api.YoutubeApi(mock).captions;
       var arg_part = "foo";
       var arg_videoId = "foo";
       var arg_id = "foo";
       var arg_onBehalfOf = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("captions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("captions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["videoId"].first, unittest.equals(arg_videoId));
+        unittest.expect(
+            queryMap["videoId"].first, unittest.equals(arg_videoId));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(
+            queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCaptionListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, arg_videoId, id: arg_id, onBehalfOf: arg_onBehalfOf, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.CaptionListResponse response) {
+      res
+          .list(arg_part, arg_videoId,
+              id: arg_id,
+              onBehalfOf: arg_onBehalfOf,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.CaptionListResponse response) {
         checkCaptionListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.CaptionsResourceApi res = new api.YoutubeApi(mock).captions;
       var arg_request = buildCaption();
       var arg_part = "foo";
       var arg_onBehalfOf = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_sync = true;
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Caption.fromJson(json);
         checkCaption(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("captions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("captions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["onBehalfOf"].first, unittest.equals(arg_onBehalfOf));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
         unittest.expect(queryMap["sync"].first, unittest.equals("$arg_sync"));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCaption());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOf: arg_onBehalfOf, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, sync: arg_sync).then(unittest.expectAsync1(((api.Caption response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOf: arg_onBehalfOf,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              sync: arg_sync)
+          .then(unittest.expectAsync1(((api.Caption response) {
         checkCaption(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ChannelBannersResourceApi", () {
     unittest.test("method--insert", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
-      api.ChannelBannersResourceApi res = new api.YoutubeApi(mock).channelBanners;
+      api.ChannelBannersResourceApi res =
+          new api.YoutubeApi(mock).channelBanners;
       var arg_request = buildChannelBannerResource();
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.ChannelBannerResource.fromJson(json);
         checkChannelBannerResource(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("channelBanners/insert"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 21),
+            unittest.equals("channelBanners/insert"));
         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]));
           }
         }
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannelBannerResource());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.ChannelBannerResource response) {
+      res
+          .insert(arg_request,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.ChannelBannerResource response) {
         checkChannelBannerResource(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ChannelSectionsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
-      api.ChannelSectionsResourceApi res = new api.YoutubeApi(mock).channelSections;
+      api.ChannelSectionsResourceApi res =
+          new api.YoutubeApi(mock).channelSections;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("channelSections"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("channelSections"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
-      api.ChannelSectionsResourceApi res = new api.YoutubeApi(mock).channelSections;
+      api.ChannelSectionsResourceApi res =
+          new api.YoutubeApi(mock).channelSections;
       var arg_request = buildChannelSection();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.ChannelSection.fromJson(json);
         checkChannelSection(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("channelSections"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("channelSections"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannelSection());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.ChannelSection response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.ChannelSection response) {
         checkChannelSection(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.ChannelSectionsResourceApi res = new api.YoutubeApi(mock).channelSections;
+      api.ChannelSectionsResourceApi res =
+          new api.YoutubeApi(mock).channelSections;
       var arg_part = "foo";
       var arg_channelId = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_mine = true;
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("channelSections"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("channelSections"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannelSectionListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, channelId: arg_channelId, hl: arg_hl, id: arg_id, mine: arg_mine, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.ChannelSectionListResponse response) {
+      res
+          .list(arg_part,
+              channelId: arg_channelId,
+              hl: arg_hl,
+              id: arg_id,
+              mine: arg_mine,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(
+              unittest.expectAsync1(((api.ChannelSectionListResponse response) {
         checkChannelSectionListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
-      api.ChannelSectionsResourceApi res = new api.YoutubeApi(mock).channelSections;
+      api.ChannelSectionsResourceApi res =
+          new api.YoutubeApi(mock).channelSections;
       var arg_request = buildChannelSection();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.ChannelSection.fromJson(json);
         checkChannelSection(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("channelSections"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("channelSections"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannelSection());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.ChannelSection response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.ChannelSection response) {
         checkChannelSection(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ChannelsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.ChannelsResourceApi res = new api.YoutubeApi(mock).channels;
       var arg_part = "foo";
       var arg_categoryId = "foo";
       var arg_forUsername = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_managedByMe = true;
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_mySubscribers = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("channels"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("channels"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["categoryId"].first, unittest.equals(arg_categoryId));
-        unittest.expect(queryMap["forUsername"].first, unittest.equals(arg_forUsername));
+        unittest.expect(
+            queryMap["categoryId"].first, unittest.equals(arg_categoryId));
+        unittest.expect(
+            queryMap["forUsername"].first, unittest.equals(arg_forUsername));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["managedByMe"].first, unittest.equals("$arg_managedByMe"));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(
+            queryMap["managedByMe"].first, unittest.equals("$arg_managedByMe"));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["mySubscribers"].first, unittest.equals("$arg_mySubscribers"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(queryMap["mySubscribers"].first,
+            unittest.equals("$arg_mySubscribers"));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannelListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, categoryId: arg_categoryId, forUsername: arg_forUsername, hl: arg_hl, id: arg_id, managedByMe: arg_managedByMe, maxResults: arg_maxResults, mine: arg_mine, mySubscribers: arg_mySubscribers, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.ChannelListResponse response) {
+      res
+          .list(arg_part,
+              categoryId: arg_categoryId,
+              forUsername: arg_forUsername,
+              hl: arg_hl,
+              id: arg_id,
+              managedByMe: arg_managedByMe,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              mySubscribers: arg_mySubscribers,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              pageToken: arg_pageToken)
+          .then(unittest.expectAsync1(((api.ChannelListResponse response) {
         checkChannelListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.ChannelsResourceApi res = new api.YoutubeApi(mock).channels;
       var arg_request = buildChannel();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Channel.fromJson(json);
         checkChannel(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("channels"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("channels"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildChannel());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.Channel response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.Channel response) {
         checkChannel(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-CommentThreadsResourceApi", () {
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
-      api.CommentThreadsResourceApi res = new api.YoutubeApi(mock).commentThreads;
+      api.CommentThreadsResourceApi res =
+          new api.YoutubeApi(mock).commentThreads;
       var arg_request = buildCommentThread();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.CommentThread.fromJson(json);
         checkCommentThread(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("commentThreads"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("commentThreads"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentThread());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.CommentThread response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.CommentThread response) {
         checkCommentThread(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.CommentThreadsResourceApi res = new api.YoutubeApi(mock).commentThreads;
+      api.CommentThreadsResourceApi res =
+          new api.YoutubeApi(mock).commentThreads;
       var arg_part = "foo";
       var arg_allThreadsRelatedToChannelId = "foo";
       var arg_channelId = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_moderationStatus = "foo";
       var arg_order = "foo";
       var arg_pageToken = "foo";
       var arg_searchTerms = "foo";
       var arg_textFormat = "foo";
       var arg_videoId = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("commentThreads"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("commentThreads"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["allThreadsRelatedToChannelId"].first, unittest.equals(arg_allThreadsRelatedToChannelId));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(queryMap["allThreadsRelatedToChannelId"].first,
+            unittest.equals(arg_allThreadsRelatedToChannelId));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["moderationStatus"].first, unittest.equals(arg_moderationStatus));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["moderationStatus"].first,
+            unittest.equals(arg_moderationStatus));
         unittest.expect(queryMap["order"].first, unittest.equals(arg_order));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["searchTerms"].first, unittest.equals(arg_searchTerms));
-        unittest.expect(queryMap["textFormat"].first, unittest.equals(arg_textFormat));
-        unittest.expect(queryMap["videoId"].first, unittest.equals(arg_videoId));
-
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(
+            queryMap["searchTerms"].first, unittest.equals(arg_searchTerms));
+        unittest.expect(
+            queryMap["textFormat"].first, unittest.equals(arg_textFormat));
+        unittest.expect(
+            queryMap["videoId"].first, unittest.equals(arg_videoId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentThreadListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, allThreadsRelatedToChannelId: arg_allThreadsRelatedToChannelId, channelId: arg_channelId, id: arg_id, maxResults: arg_maxResults, moderationStatus: arg_moderationStatus, order: arg_order, pageToken: arg_pageToken, searchTerms: arg_searchTerms, textFormat: arg_textFormat, videoId: arg_videoId).then(unittest.expectAsync1(((api.CommentThreadListResponse response) {
+      res
+          .list(arg_part,
+              allThreadsRelatedToChannelId: arg_allThreadsRelatedToChannelId,
+              channelId: arg_channelId,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              moderationStatus: arg_moderationStatus,
+              order: arg_order,
+              pageToken: arg_pageToken,
+              searchTerms: arg_searchTerms,
+              textFormat: arg_textFormat,
+              videoId: arg_videoId)
+          .then(
+              unittest.expectAsync1(((api.CommentThreadListResponse response) {
         checkCommentThreadListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
-      api.CommentThreadsResourceApi res = new api.YoutubeApi(mock).commentThreads;
+      api.CommentThreadsResourceApi res =
+          new api.YoutubeApi(mock).commentThreads;
       var arg_request = buildCommentThread();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.CommentThread.fromJson(json);
         checkCommentThread(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("commentThreads"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("commentThreads"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentThread());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part).then(unittest.expectAsync1(((api.CommentThread response) {
+      res
+          .update(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.CommentThread response) {
         checkCommentThread(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-CommentsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("comments"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("comments"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_request = buildComment();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Comment.fromJson(json);
         checkComment(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("comments"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("comments"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.Comment response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.Comment response) {
         checkComment(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_part = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_parentId = "foo";
       var arg_textFormat = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("comments"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("comments"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["parentId"].first, unittest.equals(arg_parentId));
-        unittest.expect(queryMap["textFormat"].first, unittest.equals(arg_textFormat));
-
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(
+            queryMap["parentId"].first, unittest.equals(arg_parentId));
+        unittest.expect(
+            queryMap["textFormat"].first, unittest.equals(arg_textFormat));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildCommentListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, id: arg_id, maxResults: arg_maxResults, pageToken: arg_pageToken, parentId: arg_parentId, textFormat: arg_textFormat).then(unittest.expectAsync1(((api.CommentListResponse response) {
+      res
+          .list(arg_part,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              pageToken: arg_pageToken,
+              parentId: arg_parentId,
+              textFormat: arg_textFormat)
+          .then(unittest.expectAsync1(((api.CommentListResponse response) {
         checkCommentListResponse(response);
       })));
     });
 
     unittest.test("method--markAsSpam", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("comments/markAsSpam"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19),
+            unittest.equals("comments/markAsSpam"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.markAsSpam(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--setModerationStatus", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_id = "foo";
       var arg_moderationStatus = "foo";
       var arg_banAuthor = true;
       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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 28), unittest.equals("comments/setModerationStatus"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 28),
+            unittest.equals("comments/setModerationStatus"));
         pathOffset += 28;
 
         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["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["moderationStatus"].first, unittest.equals(arg_moderationStatus));
-        unittest.expect(queryMap["banAuthor"].first, unittest.equals("$arg_banAuthor"));
-
+        unittest.expect(queryMap["moderationStatus"].first,
+            unittest.equals(arg_moderationStatus));
+        unittest.expect(
+            queryMap["banAuthor"].first, unittest.equals("$arg_banAuthor"));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.setModerationStatus(arg_id, arg_moderationStatus, banAuthor: arg_banAuthor).then(unittest.expectAsync1((_) {}));
+      res
+          .setModerationStatus(arg_id, arg_moderationStatus,
+              banAuthor: arg_banAuthor)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.CommentsResourceApi res = new api.YoutubeApi(mock).comments;
       var arg_request = buildComment();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Comment.fromJson(json);
         checkComment(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("comments"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("comments"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildComment());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part).then(unittest.expectAsync1(((api.Comment response) {
+      res
+          .update(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.Comment response) {
         checkComment(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-FanFundingEventsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.FanFundingEventsResourceApi res = new api.YoutubeApi(mock).fanFundingEvents;
+      api.FanFundingEventsResourceApi res =
+          new api.YoutubeApi(mock).fanFundingEvents;
       var arg_part = "foo";
       var arg_hl = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("fanFundingEvents"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16),
+            unittest.equals("fanFundingEvents"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        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",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildFanFundingEventListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.FanFundingEventListResponse response) {
+      res
+          .list(arg_part,
+              hl: arg_hl, maxResults: arg_maxResults, pageToken: arg_pageToken)
+          .then(unittest
+              .expectAsync1(((api.FanFundingEventListResponse response) {
         checkFanFundingEventListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-GuideCategoriesResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.GuideCategoriesResourceApi res = new api.YoutubeApi(mock).guideCategories;
+      api.GuideCategoriesResourceApi res =
+          new api.YoutubeApi(mock).guideCategories;
       var arg_part = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_regionCode = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("guideCategories"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("guideCategories"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["regionCode"].first, unittest.equals(arg_regionCode));
-
+        unittest.expect(
+            queryMap["regionCode"].first, unittest.equals(arg_regionCode));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildGuideCategoryListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl, id: arg_id, regionCode: arg_regionCode).then(unittest.expectAsync1(((api.GuideCategoryListResponse response) {
+      res
+          .list(arg_part, hl: arg_hl, id: arg_id, regionCode: arg_regionCode)
+          .then(
+              unittest.expectAsync1(((api.GuideCategoryListResponse response) {
         checkGuideCategoryListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-I18nLanguagesResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.I18nLanguagesResourceApi res = new api.YoutubeApi(mock).i18nLanguages;
       var arg_part = "foo";
       var arg_hl = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("i18nLanguages"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("i18nLanguages"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildI18nLanguageListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl).then(unittest.expectAsync1(((api.I18nLanguageListResponse response) {
+      res
+          .list(arg_part, hl: arg_hl)
+          .then(unittest.expectAsync1(((api.I18nLanguageListResponse response) {
         checkI18nLanguageListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-I18nRegionsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.I18nRegionsResourceApi res = new api.YoutubeApi(mock).i18nRegions;
       var arg_part = "foo";
       var arg_hl = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("i18nRegions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("i18nRegions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildI18nRegionListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl).then(unittest.expectAsync1(((api.I18nRegionListResponse response) {
+      res
+          .list(arg_part, hl: arg_hl)
+          .then(unittest.expectAsync1(((api.I18nRegionListResponse response) {
         checkI18nRegionListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-LiveBroadcastsResourceApi", () {
     unittest.test("method--bind", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_id = "foo";
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_streamId = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("liveBroadcasts/bind"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19),
+            unittest.equals("liveBroadcasts/bind"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(queryMap["streamId"].first, unittest.equals(arg_streamId));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(
+            queryMap["streamId"].first, unittest.equals(arg_streamId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcast());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.bind(arg_id, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, streamId: arg_streamId).then(unittest.expectAsync1(((api.LiveBroadcast response) {
+      res
+          .bind(arg_id, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              streamId: arg_streamId)
+          .then(unittest.expectAsync1(((api.LiveBroadcast response) {
         checkLiveBroadcast(response);
       })));
     });
 
     unittest.test("method--control", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_id = "foo";
       var arg_part = "foo";
       var arg_displaySlate = true;
       var arg_offsetTimeMs = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_walltime = core.DateTime.parse("2002-02-27T14:01:02");
       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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.equals("liveBroadcasts/control"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 22),
+            unittest.equals("liveBroadcasts/control"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["displaySlate"].first, unittest.equals("$arg_displaySlate"));
-        unittest.expect(queryMap["offsetTimeMs"].first, unittest.equals(arg_offsetTimeMs));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(core.DateTime.parse(queryMap["walltime"].first), unittest.equals(arg_walltime));
-
+        unittest.expect(queryMap["displaySlate"].first,
+            unittest.equals("$arg_displaySlate"));
+        unittest.expect(
+            queryMap["offsetTimeMs"].first, unittest.equals(arg_offsetTimeMs));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(core.DateTime.parse(queryMap["walltime"].first),
+            unittest.equals(arg_walltime));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcast());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.control(arg_id, arg_part, displaySlate: arg_displaySlate, offsetTimeMs: arg_offsetTimeMs, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, walltime: arg_walltime).then(unittest.expectAsync1(((api.LiveBroadcast response) {
+      res
+          .control(arg_id, arg_part,
+              displaySlate: arg_displaySlate,
+              offsetTimeMs: arg_offsetTimeMs,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              walltime: arg_walltime)
+          .then(unittest.expectAsync1(((api.LiveBroadcast response) {
         checkLiveBroadcast(response);
       })));
     });
 
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("liveBroadcasts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("liveBroadcasts"));
         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]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_request = buildLiveBroadcast();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveBroadcast.fromJson(json);
         checkLiveBroadcast(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("liveBroadcasts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("liveBroadcasts"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcast());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.LiveBroadcast response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.LiveBroadcast response) {
         checkLiveBroadcast(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_part = "foo";
       var arg_broadcastStatus = "foo";
       var arg_broadcastType = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("liveBroadcasts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("liveBroadcasts"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["broadcastStatus"].first, unittest.equals(arg_broadcastStatus));
-        unittest.expect(queryMap["broadcastType"].first, unittest.equals(arg_broadcastType));
+        unittest.expect(queryMap["broadcastStatus"].first,
+            unittest.equals(arg_broadcastStatus));
+        unittest.expect(queryMap["broadcastType"].first,
+            unittest.equals(arg_broadcastType));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcastListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, broadcastStatus: arg_broadcastStatus, broadcastType: arg_broadcastType, id: arg_id, maxResults: arg_maxResults, mine: arg_mine, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.LiveBroadcastListResponse response) {
+      res
+          .list(arg_part,
+              broadcastStatus: arg_broadcastStatus,
+              broadcastType: arg_broadcastType,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              pageToken: arg_pageToken)
+          .then(
+              unittest.expectAsync1(((api.LiveBroadcastListResponse response) {
         checkLiveBroadcastListResponse(response);
       })));
     });
 
     unittest.test("method--transition", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_broadcastStatus = "foo";
       var arg_id = "foo";
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 25), unittest.equals("liveBroadcasts/transition"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 25),
+            unittest.equals("liveBroadcasts/transition"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["broadcastStatus"].first, unittest.equals(arg_broadcastStatus));
+        unittest.expect(queryMap["broadcastStatus"].first,
+            unittest.equals(arg_broadcastStatus));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcast());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.transition(arg_broadcastStatus, arg_id, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.LiveBroadcast response) {
+      res
+          .transition(arg_broadcastStatus, arg_id, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.LiveBroadcast response) {
         checkLiveBroadcast(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
-      api.LiveBroadcastsResourceApi res = new api.YoutubeApi(mock).liveBroadcasts;
+      api.LiveBroadcastsResourceApi res =
+          new api.YoutubeApi(mock).liveBroadcasts;
       var arg_request = buildLiveBroadcast();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveBroadcast.fromJson(json);
         checkLiveBroadcast(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("liveBroadcasts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("liveBroadcasts"));
         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]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveBroadcast());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.LiveBroadcast response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.LiveBroadcast response) {
         checkLiveBroadcast(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-LiveChatBansResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.LiveChatBansResourceApi res = new api.YoutubeApi(mock).liveChatBans;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("liveChat/bans"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("liveChat/bans"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.LiveChatBansResourceApi res = new api.YoutubeApi(mock).liveChatBans;
       var arg_request = buildLiveChatBan();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveChatBan.fromJson(json);
         checkLiveChatBan(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("liveChat/bans"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("liveChat/bans"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveChatBan());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.LiveChatBan response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.LiveChatBan response) {
         checkLiveChatBan(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-LiveChatMessagesResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatMessagesResourceApi res = new api.YoutubeApi(mock).liveChatMessages;
+      api.LiveChatMessagesResourceApi res =
+          new api.YoutubeApi(mock).liveChatMessages;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("liveChat/messages"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17),
+            unittest.equals("liveChat/messages"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatMessagesResourceApi res = new api.YoutubeApi(mock).liveChatMessages;
+      api.LiveChatMessagesResourceApi res =
+          new api.YoutubeApi(mock).liveChatMessages;
       var arg_request = buildLiveChatMessage();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveChatMessage.fromJson(json);
         checkLiveChatMessage(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("liveChat/messages"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17),
+            unittest.equals("liveChat/messages"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveChatMessage());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.LiveChatMessage response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.LiveChatMessage response) {
         checkLiveChatMessage(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatMessagesResourceApi res = new api.YoutubeApi(mock).liveChatMessages;
+      api.LiveChatMessagesResourceApi res =
+          new api.YoutubeApi(mock).liveChatMessages;
       var arg_liveChatId = "foo";
       var arg_part = "foo";
       var arg_hl = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "foo";
       var arg_profileImageSize = 42;
       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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 17), unittest.equals("liveChat/messages"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 17),
+            unittest.equals("liveChat/messages"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["liveChatId"].first, unittest.equals(arg_liveChatId));
+        unittest.expect(
+            queryMap["liveChatId"].first, unittest.equals(arg_liveChatId));
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.int.parse(queryMap["profileImageSize"].first), unittest.equals(arg_profileImageSize));
-
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.int.parse(queryMap["profileImageSize"].first),
+            unittest.equals(arg_profileImageSize));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveChatMessageListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_liveChatId, arg_part, hl: arg_hl, maxResults: arg_maxResults, pageToken: arg_pageToken, profileImageSize: arg_profileImageSize).then(unittest.expectAsync1(((api.LiveChatMessageListResponse response) {
+      res
+          .list(arg_liveChatId, arg_part,
+              hl: arg_hl,
+              maxResults: arg_maxResults,
+              pageToken: arg_pageToken,
+              profileImageSize: arg_profileImageSize)
+          .then(unittest
+              .expectAsync1(((api.LiveChatMessageListResponse response) {
         checkLiveChatMessageListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-LiveChatModeratorsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatModeratorsResourceApi res = new api.YoutubeApi(mock).liveChatModerators;
+      api.LiveChatModeratorsResourceApi res =
+          new api.YoutubeApi(mock).liveChatModerators;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("liveChat/moderators"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19),
+            unittest.equals("liveChat/moderators"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatModeratorsResourceApi res = new api.YoutubeApi(mock).liveChatModerators;
+      api.LiveChatModeratorsResourceApi res =
+          new api.YoutubeApi(mock).liveChatModerators;
       var arg_request = buildLiveChatModerator();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveChatModerator.fromJson(json);
         checkLiveChatModerator(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("liveChat/moderators"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19),
+            unittest.equals("liveChat/moderators"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveChatModerator());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.LiveChatModerator response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.LiveChatModerator response) {
         checkLiveChatModerator(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.LiveChatModeratorsResourceApi res = new api.YoutubeApi(mock).liveChatModerators;
+      api.LiveChatModeratorsResourceApi res =
+          new api.YoutubeApi(mock).liveChatModerators;
       var arg_liveChatId = "foo";
       var arg_part = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.equals("liveChat/moderators"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 19),
+            unittest.equals("liveChat/moderators"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["liveChatId"].first, unittest.equals(arg_liveChatId));
+        unittest.expect(
+            queryMap["liveChatId"].first, unittest.equals(arg_liveChatId));
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        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",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveChatModeratorListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_liveChatId, arg_part, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.LiveChatModeratorListResponse response) {
+      res
+          .list(arg_liveChatId, arg_part,
+              maxResults: arg_maxResults, pageToken: arg_pageToken)
+          .then(unittest
+              .expectAsync1(((api.LiveChatModeratorListResponse response) {
         checkLiveChatModeratorListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-LiveStreamsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.LiveStreamsResourceApi res = new api.YoutubeApi(mock).liveStreams;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("liveStreams"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("liveStreams"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.LiveStreamsResourceApi res = new api.YoutubeApi(mock).liveStreams;
       var arg_request = buildLiveStream();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveStream.fromJson(json);
         checkLiveStream(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("liveStreams"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("liveStreams"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveStream());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.LiveStream response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.LiveStream response) {
         checkLiveStream(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.LiveStreamsResourceApi res = new api.YoutubeApi(mock).liveStreams;
       var arg_part = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("liveStreams"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("liveStreams"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveStreamListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, id: arg_id, maxResults: arg_maxResults, mine: arg_mine, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.LiveStreamListResponse response) {
+      res
+          .list(arg_part,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              pageToken: arg_pageToken)
+          .then(unittest.expectAsync1(((api.LiveStreamListResponse response) {
         checkLiveStreamListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.LiveStreamsResourceApi res = new api.YoutubeApi(mock).liveStreams;
       var arg_request = buildLiveStream();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.LiveStream.fromJson(json);
         checkLiveStream(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("liveStreams"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("liveStreams"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildLiveStream());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.LiveStream response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.LiveStream response) {
         checkLiveStream(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-PlaylistItemsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.PlaylistItemsResourceApi res = new api.YoutubeApi(mock).playlistItems;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("playlistItems"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("playlistItems"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.PlaylistItemsResourceApi res = new api.YoutubeApi(mock).playlistItems;
       var arg_request = buildPlaylistItem();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.PlaylistItem.fromJson(json);
         checkPlaylistItem(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("playlistItems"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("playlistItems"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylistItem());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.PlaylistItem response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.PlaylistItem response) {
         checkPlaylistItem(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.PlaylistItemsResourceApi res = new api.YoutubeApi(mock).playlistItems;
       var arg_part = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_pageToken = "foo";
       var arg_playlistId = "foo";
       var arg_videoId = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("playlistItems"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("playlistItems"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["playlistId"].first, unittest.equals(arg_playlistId));
-        unittest.expect(queryMap["videoId"].first, unittest.equals(arg_videoId));
-
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(
+            queryMap["playlistId"].first, unittest.equals(arg_playlistId));
+        unittest.expect(
+            queryMap["videoId"].first, unittest.equals(arg_videoId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylistItemListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, id: arg_id, maxResults: arg_maxResults, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, pageToken: arg_pageToken, playlistId: arg_playlistId, videoId: arg_videoId).then(unittest.expectAsync1(((api.PlaylistItemListResponse response) {
+      res
+          .list(arg_part,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              pageToken: arg_pageToken,
+              playlistId: arg_playlistId,
+              videoId: arg_videoId)
+          .then(unittest.expectAsync1(((api.PlaylistItemListResponse response) {
         checkPlaylistItemListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.PlaylistItemsResourceApi res = new api.YoutubeApi(mock).playlistItems;
       var arg_request = buildPlaylistItem();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.PlaylistItem.fromJson(json);
         checkPlaylistItem(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("playlistItems"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("playlistItems"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylistItem());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.PlaylistItem response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.PlaylistItem response) {
         checkPlaylistItem(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-PlaylistsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.PlaylistsResourceApi res = new api.YoutubeApi(mock).playlists;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("playlists"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("playlists"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.PlaylistsResourceApi res = new api.YoutubeApi(mock).playlists;
       var arg_request = buildPlaylist();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Playlist.fromJson(json);
         checkPlaylist(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("playlists"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("playlists"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylist());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel).then(unittest.expectAsync1(((api.Playlist response) {
+      res
+          .insert(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel)
+          .then(unittest.expectAsync1(((api.Playlist response) {
         checkPlaylist(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.PlaylistsResourceApi res = new api.YoutubeApi(mock).playlists;
       var arg_part = "foo";
       var arg_channelId = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("playlists"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("playlists"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylistListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, channelId: arg_channelId, hl: arg_hl, id: arg_id, maxResults: arg_maxResults, mine: arg_mine, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.PlaylistListResponse response) {
+      res
+          .list(arg_part,
+              channelId: arg_channelId,
+              hl: arg_hl,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              pageToken: arg_pageToken)
+          .then(unittest.expectAsync1(((api.PlaylistListResponse response) {
         checkPlaylistListResponse(response);
       })));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.PlaylistsResourceApi res = new api.YoutubeApi(mock).playlists;
       var arg_request = buildPlaylist();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Playlist.fromJson(json);
         checkPlaylist(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("playlists"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("playlists"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPlaylist());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.Playlist response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.Playlist response) {
         checkPlaylist(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-SearchResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.SearchResourceApi res = new api.YoutubeApi(mock).search;
       var arg_part = "foo";
       var arg_channelId = "foo";
       var arg_channelType = "foo";
       var arg_eventType = "foo";
       var arg_forContentOwner = true;
       var arg_forDeveloper = true;
       var arg_forMine = true;
       var arg_location = "foo";
@@ skipping 18 matching lines @@
       var arg_videoDuration = "foo";
       var arg_videoEmbeddable = "foo";
       var arg_videoLicense = "foo";
       var arg_videoSyndicated = "foo";
       var arg_videoType = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("search"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6),
+            unittest.equals("search"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
-        unittest.expect(queryMap["channelType"].first, unittest.equals(arg_channelType));
-        unittest.expect(queryMap["eventType"].first, unittest.equals(arg_eventType));
-        unittest.expect(queryMap["forContentOwner"].first, unittest.equals("$arg_forContentOwner"));
-        unittest.expect(queryMap["forDeveloper"].first, unittest.equals("$arg_forDeveloper"));
-        unittest.expect(queryMap["forMine"].first, unittest.equals("$arg_forMine"));
-        unittest.expect(queryMap["location"].first, unittest.equals(arg_location));
-        unittest.expect(queryMap["locationRadius"].first, unittest.equals(arg_locationRadius));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(
+            queryMap["channelType"].first, unittest.equals(arg_channelType));
+        unittest.expect(
+            queryMap["eventType"].first, unittest.equals(arg_eventType));
+        unittest.expect(queryMap["forContentOwner"].first,
+            unittest.equals("$arg_forContentOwner"));
+        unittest.expect(queryMap["forDeveloper"].first,
+            unittest.equals("$arg_forDeveloper"));
+        unittest.expect(
+            queryMap["forMine"].first, unittest.equals("$arg_forMine"));
+        unittest.expect(
+            queryMap["location"].first, unittest.equals(arg_location));
+        unittest.expect(queryMap["locationRadius"].first,
+            unittest.equals(arg_locationRadius));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
         unittest.expect(queryMap["order"].first, unittest.equals(arg_order));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.DateTime.parse(queryMap["publishedAfter"].first), unittest.equals(arg_publishedAfter));
-        unittest.expect(core.DateTime.parse(queryMap["publishedBefore"].first), unittest.equals(arg_publishedBefore));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.DateTime.parse(queryMap["publishedAfter"].first),
+            unittest.equals(arg_publishedAfter));
+        unittest.expect(core.DateTime.parse(queryMap["publishedBefore"].first),
+            unittest.equals(arg_publishedBefore));
         unittest.expect(queryMap["q"].first, unittest.equals(arg_q));
-        unittest.expect(queryMap["regionCode"].first, unittest.equals(arg_regionCode));
-        unittest.expect(queryMap["relatedToVideoId"].first, unittest.equals(arg_relatedToVideoId));
-        unittest.expect(queryMap["relevanceLanguage"].first, unittest.equals(arg_relevanceLanguage));
-        unittest.expect(queryMap["safeSearch"].first, unittest.equals(arg_safeSearch));
-        unittest.expect(queryMap["topicId"].first, unittest.equals(arg_topicId));
+        unittest.expect(
+            queryMap["regionCode"].first, unittest.equals(arg_regionCode));
+        unittest.expect(queryMap["relatedToVideoId"].first,
+            unittest.equals(arg_relatedToVideoId));
+        unittest.expect(queryMap["relevanceLanguage"].first,
+            unittest.equals(arg_relevanceLanguage));
+        unittest.expect(
+            queryMap["safeSearch"].first, unittest.equals(arg_safeSearch));
+        unittest.expect(
+            queryMap["topicId"].first, unittest.equals(arg_topicId));
         unittest.expect(queryMap["type"].first, unittest.equals(arg_type));
-        unittest.expect(queryMap["videoCaption"].first, unittest.equals(arg_videoCaption));
-        unittest.expect(queryMap["videoCategoryId"].first, unittest.equals(arg_videoCategoryId));
-        unittest.expect(queryMap["videoDefinition"].first, unittest.equals(arg_videoDefinition));
-        unittest.expect(queryMap["videoDimension"].first, unittest.equals(arg_videoDimension));
-        unittest.expect(queryMap["videoDuration"].first, unittest.equals(arg_videoDuration));
-        unittest.expect(queryMap["videoEmbeddable"].first, unittest.equals(arg_videoEmbeddable));
-        unittest.expect(queryMap["videoLicense"].first, unittest.equals(arg_videoLicense));
-        unittest.expect(queryMap["videoSyndicated"].first, unittest.equals(arg_videoSyndicated));
-        unittest.expect(queryMap["videoType"].first, unittest.equals(arg_videoType));
-
+        unittest.expect(
+            queryMap["videoCaption"].first, unittest.equals(arg_videoCaption));
+        unittest.expect(queryMap["videoCategoryId"].first,
+            unittest.equals(arg_videoCategoryId));
+        unittest.expect(queryMap["videoDefinition"].first,
+            unittest.equals(arg_videoDefinition));
+        unittest.expect(queryMap["videoDimension"].first,
+            unittest.equals(arg_videoDimension));
+        unittest.expect(queryMap["videoDuration"].first,
+            unittest.equals(arg_videoDuration));
+        unittest.expect(queryMap["videoEmbeddable"].first,
+            unittest.equals(arg_videoEmbeddable));
+        unittest.expect(
+            queryMap["videoLicense"].first, unittest.equals(arg_videoLicense));
+        unittest.expect(queryMap["videoSyndicated"].first,
+            unittest.equals(arg_videoSyndicated));
+        unittest.expect(
+            queryMap["videoType"].first, unittest.equals(arg_videoType));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSearchListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, channelId: arg_channelId, channelType: arg_channelType, eventType: arg_eventType, forContentOwner: arg_forContentOwner, forDeveloper: arg_forDeveloper, forMine: arg_forMine, location: arg_location, locationRadius: arg_locationRadius, maxResults: arg_maxResults, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, order: arg_order, pageToken: arg_pageToken, publishedAfter: arg_publishedAfter, publishedBefore: arg_publishedBefore, q: arg_q, regionCode: arg_regionCode, relatedToVideoId: arg_relatedToVideoId, relevanceLanguage: arg_relevanceLanguage, safeSearch: arg_safeSearch, topicId: arg_topicId, type: arg_type, videoCaption: arg_videoCaption, videoCategoryId: arg_videoCategoryId, videoDefinition: arg_videoDefinition, videoDimension: arg_videoDimension, videoDuration: arg_videoDuration, videoEmbeddable: arg_videoEmbeddable, videoLicense: arg_videoLicense, videoSyndicated: arg_videoSyndicated, videoType: arg_videoType).then(unittest.expectAsync1(((api.SearchListResponse response) {
+      res
+          .list(arg_part,
+              channelId: arg_channelId,
+              channelType: arg_channelType,
+              eventType: arg_eventType,
+              forContentOwner: arg_forContentOwner,
+              forDeveloper: arg_forDeveloper,
+              forMine: arg_forMine,
+              location: arg_location,
+              locationRadius: arg_locationRadius,
+              maxResults: arg_maxResults,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              order: arg_order,
+              pageToken: arg_pageToken,
+              publishedAfter: arg_publishedAfter,
+              publishedBefore: arg_publishedBefore,
+              q: arg_q,
+              regionCode: arg_regionCode,
+              relatedToVideoId: arg_relatedToVideoId,
+              relevanceLanguage: arg_relevanceLanguage,
+              safeSearch: arg_safeSearch,
+              topicId: arg_topicId,
+              type: arg_type,
+              videoCaption: arg_videoCaption,
+              videoCategoryId: arg_videoCategoryId,
+              videoDefinition: arg_videoDefinition,
+              videoDimension: arg_videoDimension,
+              videoDuration: arg_videoDuration,
+              videoEmbeddable: arg_videoEmbeddable,
+              videoLicense: arg_videoLicense,
+              videoSyndicated: arg_videoSyndicated,
+              videoType: arg_videoType)
+          .then(unittest.expectAsync1(((api.SearchListResponse response) {
         checkSearchListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-SponsorsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.SponsorsResourceApi res = new api.YoutubeApi(mock).sponsors;
       var arg_part = "foo";
       var arg_filter = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("sponsors"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("sponsors"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         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));
-
+        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",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSponsorListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, filter: arg_filter, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.SponsorListResponse response) {
+      res
+          .list(arg_part,
+              filter: arg_filter,
+              maxResults: arg_maxResults,
+              pageToken: arg_pageToken)
+          .then(unittest.expectAsync1(((api.SponsorListResponse response) {
         checkSponsorListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-SubscriptionsResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.SubscriptionsResourceApi res = new api.YoutubeApi(mock).subscriptions;
       var arg_id = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("subscriptions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("subscriptions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.delete(arg_id).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--insert", () {
-
       var mock = new HttpServerMock();
       api.SubscriptionsResourceApi res = new api.YoutubeApi(mock).subscriptions;
       var arg_request = buildSubscription();
       var arg_part = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Subscription.fromJson(json);
         checkSubscription(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("subscriptions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("subscriptions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSubscription());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part).then(unittest.expectAsync1(((api.Subscription response) {
+      res
+          .insert(arg_request, arg_part)
+          .then(unittest.expectAsync1(((api.Subscription response) {
         checkSubscription(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.SubscriptionsResourceApi res = new api.YoutubeApi(mock).subscriptions;
       var arg_part = "foo";
       var arg_channelId = "foo";
       var arg_forChannelId = "foo";
       var arg_id = "foo";
       var arg_maxResults = 42;
       var arg_mine = true;
       var arg_myRecentSubscribers = true;
       var arg_mySubscribers = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_order = "foo";
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("subscriptions"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("subscriptions"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
-        unittest.expect(queryMap["forChannelId"].first, unittest.equals(arg_forChannelId));
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(
+            queryMap["forChannelId"].first, unittest.equals(arg_forChannelId));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
         unittest.expect(queryMap["mine"].first, unittest.equals("$arg_mine"));
-        unittest.expect(queryMap["myRecentSubscribers"].first, unittest.equals("$arg_myRecentSubscribers"));
-        unittest.expect(queryMap["mySubscribers"].first, unittest.equals("$arg_mySubscribers"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(queryMap["myRecentSubscribers"].first,
+            unittest.equals("$arg_myRecentSubscribers"));
+        unittest.expect(queryMap["mySubscribers"].first,
+            unittest.equals("$arg_mySubscribers"));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
         unittest.expect(queryMap["order"].first, unittest.equals(arg_order));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSubscriptionListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, channelId: arg_channelId, forChannelId: arg_forChannelId, id: arg_id, maxResults: arg_maxResults, mine: arg_mine, myRecentSubscribers: arg_myRecentSubscribers, mySubscribers: arg_mySubscribers, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, order: arg_order, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.SubscriptionListResponse response) {
+      res
+          .list(arg_part,
+              channelId: arg_channelId,
+              forChannelId: arg_forChannelId,
+              id: arg_id,
+              maxResults: arg_maxResults,
+              mine: arg_mine,
+              myRecentSubscribers: arg_myRecentSubscribers,
+              mySubscribers: arg_mySubscribers,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              order: arg_order,
+              pageToken: arg_pageToken)
+          .then(unittest.expectAsync1(((api.SubscriptionListResponse response) {
         checkSubscriptionListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-SuperChatEventsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.SuperChatEventsResourceApi res = new api.YoutubeApi(mock).superChatEvents;
+      api.SuperChatEventsResourceApi res =
+          new api.YoutubeApi(mock).superChatEvents;
       var arg_part = "foo";
       var arg_hl = "foo";
       var arg_maxResults = 42;
       var arg_pageToken = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("superChatEvents"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("superChatEvents"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        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",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildSuperChatEventListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.SuperChatEventListResponse response) {
+      res
+          .list(arg_part,
+              hl: arg_hl, maxResults: arg_maxResults, pageToken: arg_pageToken)
+          .then(
+              unittest.expectAsync1(((api.SuperChatEventListResponse response) {
         checkSuperChatEventListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ThumbnailsResourceApi", () {
     unittest.test("method--set", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.ThumbnailsResourceApi res = new api.YoutubeApi(mock).thumbnails;
       var arg_videoId = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("thumbnails/set"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("thumbnails/set"));
         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]));
           }
         }
-        unittest.expect(queryMap["videoId"].first, unittest.equals(arg_videoId));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(
+            queryMap["videoId"].first, unittest.equals(arg_videoId));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildThumbnailSetResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.set(arg_videoId, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.ThumbnailSetResponse response) {
+      res
+          .set(arg_videoId, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.ThumbnailSetResponse response) {
         checkThumbnailSetResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-VideoAbuseReportReasonsResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.VideoAbuseReportReasonsResourceApi res = new api.YoutubeApi(mock).videoAbuseReportReasons;
+      api.VideoAbuseReportReasonsResourceApi res =
+          new api.YoutubeApi(mock).videoAbuseReportReasons;
       var arg_part = "foo";
       var arg_hl = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 23), unittest.equals("videoAbuseReportReasons"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 23),
+            unittest.equals("videoAbuseReportReasons"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
-        var resp = convert.JSON.encode(buildVideoAbuseReportReasonListResponse());
+        var resp =
+            convert.JSON.encode(buildVideoAbuseReportReasonListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl).then(unittest.expectAsync1(((api.VideoAbuseReportReasonListResponse response) {
+      res.list(arg_part, hl: arg_hl).then(unittest
+          .expectAsync1(((api.VideoAbuseReportReasonListResponse response) {
         checkVideoAbuseReportReasonListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-VideoCategoriesResourceApi", () {
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.VideoCategoriesResourceApi res = new api.YoutubeApi(mock).videoCategories;
+      api.VideoCategoriesResourceApi res =
+          new api.YoutubeApi(mock).videoCategories;
       var arg_part = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_regionCode = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("videoCategories"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("videoCategories"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["regionCode"].first, unittest.equals(arg_regionCode));
-
+        unittest.expect(
+            queryMap["regionCode"].first, unittest.equals(arg_regionCode));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVideoCategoryListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, hl: arg_hl, id: arg_id, regionCode: arg_regionCode).then(unittest.expectAsync1(((api.VideoCategoryListResponse response) {
+      res
+          .list(arg_part, hl: arg_hl, id: arg_id, regionCode: arg_regionCode)
+          .then(
+              unittest.expectAsync1(((api.VideoCategoryListResponse response) {
         checkVideoCategoryListResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-VideosResourceApi", () {
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("videos"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6),
+            unittest.equals("videos"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .delete(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--getRating", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_id = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("videos/getRating"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16),
+            unittest.equals("videos/getRating"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVideoGetRatingResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.getRating(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.VideoGetRatingResponse response) {
+      res
+          .getRating(arg_id, onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.VideoGetRatingResponse response) {
         checkVideoGetRatingResponse(response);
       })));
     });
 
     unittest.test("method--insert", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_request = buildVideo();
       var arg_part = "foo";
       var arg_autoLevels = true;
       var arg_notifySubscribers = true;
       var arg_onBehalfOfContentOwner = "foo";
       var arg_onBehalfOfContentOwnerChannel = "foo";
       var arg_stabilize = true;
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Video.fromJson(json);
         checkVideo(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("videos"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6),
+            unittest.equals("videos"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["autoLevels"].first, unittest.equals("$arg_autoLevels"));
-        unittest.expect(queryMap["notifySubscribers"].first, unittest.equals("$arg_notifySubscribers"));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first, unittest.equals(arg_onBehalfOfContentOwnerChannel));
-        unittest.expect(queryMap["stabilize"].first, unittest.equals("$arg_stabilize"));
-
+        unittest.expect(
+            queryMap["autoLevels"].first, unittest.equals("$arg_autoLevels"));
+        unittest.expect(queryMap["notifySubscribers"].first,
+            unittest.equals("$arg_notifySubscribers"));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(queryMap["onBehalfOfContentOwnerChannel"].first,
+            unittest.equals(arg_onBehalfOfContentOwnerChannel));
+        unittest.expect(
+            queryMap["stabilize"].first, unittest.equals("$arg_stabilize"));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVideo());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.insert(arg_request, arg_part, autoLevels: arg_autoLevels, notifySubscribers: arg_notifySubscribers, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel, stabilize: arg_stabilize).then(unittest.expectAsync1(((api.Video response) {
+      res
+          .insert(arg_request, arg_part,
+              autoLevels: arg_autoLevels,
+              notifySubscribers: arg_notifySubscribers,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              onBehalfOfContentOwnerChannel: arg_onBehalfOfContentOwnerChannel,
+              stabilize: arg_stabilize)
+          .then(unittest.expectAsync1(((api.Video response) {
         checkVideo(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_part = "foo";
       var arg_chart = "foo";
       var arg_hl = "foo";
       var arg_id = "foo";
       var arg_locale = "foo";
       var arg_maxHeight = 42;
       var arg_maxResults = 42;
       var arg_maxWidth = 42;
       var arg_myRating = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       var arg_pageToken = "foo";
       var arg_regionCode = "foo";
       var arg_videoCategoryId = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("videos"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6),
+            unittest.equals("videos"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
         unittest.expect(queryMap["chart"].first, unittest.equals(arg_chart));
         unittest.expect(queryMap["hl"].first, unittest.equals(arg_hl));
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));
-        unittest.expect(core.int.parse(queryMap["maxHeight"].first), unittest.equals(arg_maxHeight));
-        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
-        unittest.expect(core.int.parse(queryMap["maxWidth"].first), unittest.equals(arg_maxWidth));
-        unittest.expect(queryMap["myRating"].first, unittest.equals(arg_myRating));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["regionCode"].first, unittest.equals(arg_regionCode));
-        unittest.expect(queryMap["videoCategoryId"].first, unittest.equals(arg_videoCategoryId));
-
+        unittest.expect(core.int.parse(queryMap["maxHeight"].first),
+            unittest.equals(arg_maxHeight));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first),
+            unittest.equals(arg_maxResults));
+        unittest.expect(core.int.parse(queryMap["maxWidth"].first),
+            unittest.equals(arg_maxWidth));
+        unittest.expect(
+            queryMap["myRating"].first, unittest.equals(arg_myRating));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(
+            queryMap["regionCode"].first, unittest.equals(arg_regionCode));
+        unittest.expect(queryMap["videoCategoryId"].first,
+            unittest.equals(arg_videoCategoryId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVideoListResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_part, chart: arg_chart, hl: arg_hl, id: arg_id, locale: arg_locale, maxHeight: arg_maxHeight, maxResults: arg_maxResults, maxWidth: arg_maxWidth, myRating: arg_myRating, onBehalfOfContentOwner: arg_onBehalfOfContentOwner, pageToken: arg_pageToken, regionCode: arg_regionCode, videoCategoryId: arg_videoCategoryId).then(unittest.expectAsync1(((api.VideoListResponse response) {
+      res
+          .list(arg_part,
+              chart: arg_chart,
+              hl: arg_hl,
+              id: arg_id,
+              locale: arg_locale,
+              maxHeight: arg_maxHeight,
+              maxResults: arg_maxResults,
+              maxWidth: arg_maxWidth,
+              myRating: arg_myRating,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner,
+              pageToken: arg_pageToken,
+              regionCode: arg_regionCode,
+              videoCategoryId: arg_videoCategoryId)
+          .then(unittest.expectAsync1(((api.VideoListResponse response) {
         checkVideoListResponse(response);
       })));
     });
 
     unittest.test("method--rate", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_id = "foo";
       var arg_rating = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("videos/rate"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("videos/rate"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["id"].first, unittest.equals(arg_id));
         unittest.expect(queryMap["rating"].first, unittest.equals(arg_rating));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.rate(arg_id, arg_rating).then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--reportAbuse", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_request = buildVideoAbuseReport();
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.VideoAbuseReport.fromJson(json);
         checkVideoAbuseReport(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("videos/reportAbuse"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 18),
+            unittest.equals("videos/reportAbuse"));
         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]));
           }
         }
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.reportAbuse(arg_request, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .reportAbuse(arg_request,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--update", () {
-
       var mock = new HttpServerMock();
       api.VideosResourceApi res = new api.YoutubeApi(mock).videos;
       var arg_request = buildVideo();
       var arg_part = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Video.fromJson(json);
         checkVideo(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("videos"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6),
+            unittest.equals("videos"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["part"].first, unittest.equals(arg_part));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildVideo());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.update(arg_request, arg_part, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1(((api.Video response) {
+      res
+          .update(arg_request, arg_part,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1(((api.Video response) {
         checkVideo(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-WatermarksResourceApi", () {
     unittest.test("method--set", () {
       // TODO: Implement tests for media upload;
       // TODO: Implement tests for media download;
 
       var mock = new HttpServerMock();
       api.WatermarksResourceApi res = new api.YoutubeApi(mock).watermarks;
       var arg_request = buildInvideoBranding();
       var arg_channelId = "foo";
       var arg_onBehalfOfContentOwner = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.InvideoBranding.fromJson(json);
         checkInvideoBranding(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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("watermarks/set"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14),
+            unittest.equals("watermarks/set"));
         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]));
           }
         }
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.set(arg_request, arg_channelId, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .set(arg_request, arg_channelId,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
 
     unittest.test("method--unset", () {
-
       var mock = new HttpServerMock();
       api.WatermarksResourceApi res = new api.YoutubeApi(mock).watermarks;
       var arg_channelId = "foo";
       var arg_onBehalfOfContentOwner = "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 + 11), unittest.equals("youtube/v3/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("youtube/v3/"));
         pathOffset += 11;
-        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("watermarks/unset"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 16),
+            unittest.equals("watermarks/unset"));
         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]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["channelId"].first, unittest.equals(arg_channelId));
-        unittest.expect(queryMap["onBehalfOfContentOwner"].first, unittest.equals(arg_onBehalfOfContentOwner));
-
+        unittest.expect(
+            queryMap["channelId"].first, unittest.equals(arg_channelId));
+        unittest.expect(queryMap["onBehalfOfContentOwner"].first,
+            unittest.equals(arg_onBehalfOfContentOwner));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = "";
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.unset(arg_channelId, onBehalfOfContentOwner: arg_onBehalfOfContentOwner).then(unittest.expectAsync1((_) {}));
+      res
+          .unset(arg_channelId,
+              onBehalfOfContentOwner: arg_onBehalfOfContentOwner)
+          .then(unittest.expectAsync1((_) {}));
     });
-
   });
-
-
 }
-