Api-Roll 54: 2017-09-11

generated/googleapis/test/servicemanagement/v1_test.dart

 library googleapis.servicemanagement.v1.test;
 
 import "dart:core" as core;
-import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
-import 'package:http/testing.dart' as http_testing;
 import 'package:test/test.dart' as unittest;
 
 import 'package:googleapis/servicemanagement/v1.dart' as api;
 
 class HttpServerMock extends http.BaseClient {
   core.Function _callback;
   core.bool _expectJson;
 
   void register(core.Function callback, core.bool expectJson) {
     _callback = callback;
     _expectJson = expectJson;
   }
 
   async.Future<http.StreamedResponse> send(http.BaseRequest request) {
     if (_expectJson) {
-      return request.finalize()
+      return request
+          .finalize()
           .transform(convert.UTF8.decoder)
           .join('')
           .then((core.String jsonString) {
         if (jsonString.isEmpty) {
           return _callback(request, null);
         } else {
           return _callback(request, convert.JSON.decode(jsonString));
         }
       });
     } else {
       var stream = request.finalize();
       if (stream == null) {
         return _callback(request, []);
       } else {
         return stream.toBytes().then((data) {
           return _callback(request, data);
         });
       }
     }
   }
 }
 
-http.StreamedResponse stringResponse(
-    core.int status, core.Map<core.String, core.String> headers, core.String body) {
+http.StreamedResponse stringResponse(core.int status,
+    core.Map<core.String, core.String> headers, core.String body) {
   var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
   return new http.StreamedResponse(stream, status, headers: headers);
 }
 
 core.int buildCounterAdvice = 0;
 buildAdvice() {
   var o = new api.Advice();
   buildCounterAdvice++;
   if (buildCounterAdvice < 3) {
     o.description = "foo";
   }
   buildCounterAdvice--;
   return o;
 }
 
 checkAdvice(api.Advice o) {
   buildCounterAdvice++;
   if (buildCounterAdvice < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
   }
   buildCounterAdvice--;
 }
 
-buildUnnamed1141() {
+buildUnnamed1144() {
   var o = new core.List<api.Method>();
   o.add(buildMethod());
   o.add(buildMethod());
   return o;
 }
 
-checkUnnamed1141(core.List<api.Method> o) {
+checkUnnamed1144(core.List<api.Method> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMethod(o[0]);
   checkMethod(o[1]);
 }
 
-buildUnnamed1142() {
+buildUnnamed1145() {
   var o = new core.List<api.Mixin>();
   o.add(buildMixin());
   o.add(buildMixin());
   return o;
 }
 
-checkUnnamed1142(core.List<api.Mixin> o) {
+checkUnnamed1145(core.List<api.Mixin> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMixin(o[0]);
   checkMixin(o[1]);
 }
 
-buildUnnamed1143() {
+buildUnnamed1146() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1143(core.List<api.Option> o) {
+checkUnnamed1146(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterApi = 0;
 buildApi() {
   var o = new api.Api();
   buildCounterApi++;
   if (buildCounterApi < 3) {
-    o.methods = buildUnnamed1141();
-    o.mixins = buildUnnamed1142();
+    o.methods = buildUnnamed1144();
+    o.mixins = buildUnnamed1145();
     o.name = "foo";
-    o.options = buildUnnamed1143();
+    o.options = buildUnnamed1146();
     o.sourceContext = buildSourceContext();
     o.syntax = "foo";
     o.version = "foo";
   }
   buildCounterApi--;
   return o;
 }
 
 checkApi(api.Api o) {
   buildCounterApi++;
   if (buildCounterApi < 3) {
-    checkUnnamed1141(o.methods);
-    checkUnnamed1142(o.mixins);
+    checkUnnamed1144(o.methods);
+    checkUnnamed1145(o.mixins);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1143(o.options);
+    checkUnnamed1146(o.options);
     checkSourceContext(o.sourceContext);
     unittest.expect(o.syntax, unittest.equals('foo'));
     unittest.expect(o.version, unittest.equals('foo'));
   }
   buildCounterApi--;
 }
 
-buildUnnamed1144() {
+buildUnnamed1147() {
   var o = new core.List<api.AuditLogConfig>();
   o.add(buildAuditLogConfig());
   o.add(buildAuditLogConfig());
   return o;
 }
 
-checkUnnamed1144(core.List<api.AuditLogConfig> o) {
+checkUnnamed1147(core.List<api.AuditLogConfig> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAuditLogConfig(o[0]);
   checkAuditLogConfig(o[1]);
 }
 
-buildUnnamed1145() {
+buildUnnamed1148() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1145(core.List<core.String> o) {
+checkUnnamed1148(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 buildCounterAuditConfig = 0;
 buildAuditConfig() {
   var o = new api.AuditConfig();
   buildCounterAuditConfig++;
   if (buildCounterAuditConfig < 3) {
-    o.auditLogConfigs = buildUnnamed1144();
-    o.exemptedMembers = buildUnnamed1145();
+    o.auditLogConfigs = buildUnnamed1147();
+    o.exemptedMembers = buildUnnamed1148();
     o.service = "foo";
   }
   buildCounterAuditConfig--;
   return o;
 }
 
 checkAuditConfig(api.AuditConfig o) {
   buildCounterAuditConfig++;
   if (buildCounterAuditConfig < 3) {
-    checkUnnamed1144(o.auditLogConfigs);
-    checkUnnamed1145(o.exemptedMembers);
+    checkUnnamed1147(o.auditLogConfigs);
+    checkUnnamed1148(o.exemptedMembers);
     unittest.expect(o.service, unittest.equals('foo'));
   }
   buildCounterAuditConfig--;
 }
 
-buildUnnamed1146() {
+buildUnnamed1149() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1146(core.List<core.String> o) {
+checkUnnamed1149(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 buildCounterAuditLogConfig = 0;
 buildAuditLogConfig() {
   var o = new api.AuditLogConfig();
   buildCounterAuditLogConfig++;
   if (buildCounterAuditLogConfig < 3) {
-    o.exemptedMembers = buildUnnamed1146();
+    o.exemptedMembers = buildUnnamed1149();
     o.logType = "foo";
   }
   buildCounterAuditLogConfig--;
   return o;
 }
 
 checkAuditLogConfig(api.AuditLogConfig o) {
   buildCounterAuditLogConfig++;
   if (buildCounterAuditLogConfig < 3) {
-    checkUnnamed1146(o.exemptedMembers);
+    checkUnnamed1149(o.exemptedMembers);
     unittest.expect(o.logType, unittest.equals('foo'));
   }
   buildCounterAuditLogConfig--;
 }
 
 core.int buildCounterAuthProvider = 0;
 buildAuthProvider() {
   var o = new api.AuthProvider();
   buildCounterAuthProvider++;
   if (buildCounterAuthProvider < 3) {
@@ skipping 33 matching lines @@
 
 checkAuthRequirement(api.AuthRequirement o) {
   buildCounterAuthRequirement++;
   if (buildCounterAuthRequirement < 3) {
     unittest.expect(o.audiences, unittest.equals('foo'));
     unittest.expect(o.providerId, unittest.equals('foo'));
   }
   buildCounterAuthRequirement--;
 }
 
-buildUnnamed1147() {
+buildUnnamed1150() {
   var o = new core.List<api.AuthProvider>();
   o.add(buildAuthProvider());
   o.add(buildAuthProvider());
   return o;
 }
 
-checkUnnamed1147(core.List<api.AuthProvider> o) {
+checkUnnamed1150(core.List<api.AuthProvider> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAuthProvider(o[0]);
   checkAuthProvider(o[1]);
 }
 
-buildUnnamed1148() {
+buildUnnamed1151() {
   var o = new core.List<api.AuthenticationRule>();
   o.add(buildAuthenticationRule());
   o.add(buildAuthenticationRule());
   return o;
 }
 
-checkUnnamed1148(core.List<api.AuthenticationRule> o) {
+checkUnnamed1151(core.List<api.AuthenticationRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAuthenticationRule(o[0]);
   checkAuthenticationRule(o[1]);
 }
 
 core.int buildCounterAuthentication = 0;
 buildAuthentication() {
   var o = new api.Authentication();
   buildCounterAuthentication++;
   if (buildCounterAuthentication < 3) {
-    o.providers = buildUnnamed1147();
-    o.rules = buildUnnamed1148();
+    o.providers = buildUnnamed1150();
+    o.rules = buildUnnamed1151();
   }
   buildCounterAuthentication--;
   return o;
 }
 
 checkAuthentication(api.Authentication o) {
   buildCounterAuthentication++;
   if (buildCounterAuthentication < 3) {
-    checkUnnamed1147(o.providers);
-    checkUnnamed1148(o.rules);
+    checkUnnamed1150(o.providers);
+    checkUnnamed1151(o.rules);
   }
   buildCounterAuthentication--;
 }
 
-buildUnnamed1149() {
+buildUnnamed1152() {
   var o = new core.List<api.AuthRequirement>();
   o.add(buildAuthRequirement());
   o.add(buildAuthRequirement());
   return o;
 }
 
-checkUnnamed1149(core.List<api.AuthRequirement> o) {
+checkUnnamed1152(core.List<api.AuthRequirement> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAuthRequirement(o[0]);
   checkAuthRequirement(o[1]);
 }
 
 core.int buildCounterAuthenticationRule = 0;
 buildAuthenticationRule() {
   var o = new api.AuthenticationRule();
   buildCounterAuthenticationRule++;
   if (buildCounterAuthenticationRule < 3) {
     o.allowWithoutCredential = true;
     o.customAuth = buildCustomAuthRequirements();
     o.oauth = buildOAuthRequirements();
-    o.requirements = buildUnnamed1149();
+    o.requirements = buildUnnamed1152();
     o.selector = "foo";
   }
   buildCounterAuthenticationRule--;
   return o;
 }
 
 checkAuthenticationRule(api.AuthenticationRule o) {
   buildCounterAuthenticationRule++;
   if (buildCounterAuthenticationRule < 3) {
     unittest.expect(o.allowWithoutCredential, unittest.isTrue);
     checkCustomAuthRequirements(o.customAuth);
     checkOAuthRequirements(o.oauth);
-    checkUnnamed1149(o.requirements);
+    checkUnnamed1152(o.requirements);
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterAuthenticationRule--;
 }
 
 core.int buildCounterAuthorizationConfig = 0;
 buildAuthorizationConfig() {
   var o = new api.AuthorizationConfig();
   buildCounterAuthorizationConfig++;
   if (buildCounterAuthorizationConfig < 3) {
     o.provider = "foo";
   }
   buildCounterAuthorizationConfig--;
   return o;
 }
 
 checkAuthorizationConfig(api.AuthorizationConfig o) {
   buildCounterAuthorizationConfig++;
   if (buildCounterAuthorizationConfig < 3) {
     unittest.expect(o.provider, unittest.equals('foo'));
   }
   buildCounterAuthorizationConfig--;
 }
 
-buildUnnamed1150() {
+buildUnnamed1153() {
   var o = new core.List<api.BackendRule>();
   o.add(buildBackendRule());
   o.add(buildBackendRule());
   return o;
 }
 
-checkUnnamed1150(core.List<api.BackendRule> o) {
+checkUnnamed1153(core.List<api.BackendRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBackendRule(o[0]);
   checkBackendRule(o[1]);
 }
 
 core.int buildCounterBackend = 0;
 buildBackend() {
   var o = new api.Backend();
   buildCounterBackend++;
   if (buildCounterBackend < 3) {
-    o.rules = buildUnnamed1150();
+    o.rules = buildUnnamed1153();
   }
   buildCounterBackend--;
   return o;
 }
 
 checkBackend(api.Backend o) {
   buildCounterBackend++;
   if (buildCounterBackend < 3) {
-    checkUnnamed1150(o.rules);
+    checkUnnamed1153(o.rules);
   }
   buildCounterBackend--;
 }
 
 core.int buildCounterBackendRule = 0;
 buildBackendRule() {
   var o = new api.BackendRule();
   buildCounterBackendRule++;
   if (buildCounterBackendRule < 3) {
     o.address = "foo";
     o.deadline = 42.0;
     o.minDeadline = 42.0;
     o.selector = "foo";
   }
   buildCounterBackendRule--;
   return o;
 }
 
 checkBackendRule(api.BackendRule o) {
   buildCounterBackendRule++;
   if (buildCounterBackendRule < 3) {
     unittest.expect(o.address, unittest.equals('foo'));
     unittest.expect(o.deadline, unittest.equals(42.0));
     unittest.expect(o.minDeadline, unittest.equals(42.0));
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterBackendRule--;
 }
 
-buildUnnamed1151() {
+buildUnnamed1154() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1151(core.List<core.String> o) {
+checkUnnamed1154(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 buildCounterBinding = 0;
 buildBinding() {
   var o = new api.Binding();
   buildCounterBinding++;
   if (buildCounterBinding < 3) {
     o.condition = buildExpr();
-    o.members = buildUnnamed1151();
+    o.members = buildUnnamed1154();
     o.role = "foo";
   }
   buildCounterBinding--;
   return o;
 }
 
 checkBinding(api.Binding o) {
   buildCounterBinding++;
   if (buildCounterBinding < 3) {
     checkExpr(o.condition);
-    checkUnnamed1151(o.members);
+    checkUnnamed1154(o.members);
     unittest.expect(o.role, unittest.equals('foo'));
   }
   buildCounterBinding--;
 }
 
-buildUnnamed1152() {
+buildUnnamed1155() {
   var o = new core.List<api.ConfigChange>();
   o.add(buildConfigChange());
   o.add(buildConfigChange());
   return o;
 }
 
-checkUnnamed1152(core.List<api.ConfigChange> o) {
+checkUnnamed1155(core.List<api.ConfigChange> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkConfigChange(o[0]);
   checkConfigChange(o[1]);
 }
 
 core.int buildCounterChangeReport = 0;
 buildChangeReport() {
   var o = new api.ChangeReport();
   buildCounterChangeReport++;
   if (buildCounterChangeReport < 3) {
-    o.configChanges = buildUnnamed1152();
+    o.configChanges = buildUnnamed1155();
   }
   buildCounterChangeReport--;
   return o;
 }
 
 checkChangeReport(api.ChangeReport o) {
   buildCounterChangeReport++;
   if (buildCounterChangeReport < 3) {
-    checkUnnamed1152(o.configChanges);
+    checkUnnamed1155(o.configChanges);
   }
   buildCounterChangeReport--;
 }
 
-core.int buildCounterCloudAuditOptions = 0;
-buildCloudAuditOptions() {
-  var o = new api.CloudAuditOptions();
-  buildCounterCloudAuditOptions++;
-  if (buildCounterCloudAuditOptions < 3) {
-    o.logName = "foo";
-  }
-  buildCounterCloudAuditOptions--;
-  return o;
-}
-
-checkCloudAuditOptions(api.CloudAuditOptions o) {
-  buildCounterCloudAuditOptions++;
-  if (buildCounterCloudAuditOptions < 3) {
-    unittest.expect(o.logName, unittest.equals('foo'));
-  }
-  buildCounterCloudAuditOptions--;
-}
-
-buildUnnamed1153() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1153(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 buildCounterCondition = 0;
-buildCondition() {
-  var o = new api.Condition();
-  buildCounterCondition++;
-  if (buildCounterCondition < 3) {
-    o.iam = "foo";
-    o.op = "foo";
-    o.svc = "foo";
-    o.sys = "foo";
-    o.value = "foo";
-    o.values = buildUnnamed1153();
-  }
-  buildCounterCondition--;
-  return o;
-}
-
-checkCondition(api.Condition o) {
-  buildCounterCondition++;
-  if (buildCounterCondition < 3) {
-    unittest.expect(o.iam, unittest.equals('foo'));
-    unittest.expect(o.op, unittest.equals('foo'));
-    unittest.expect(o.svc, unittest.equals('foo'));
-    unittest.expect(o.sys, unittest.equals('foo'));
-    unittest.expect(o.value, unittest.equals('foo'));
-    checkUnnamed1153(o.values);
-  }
-  buildCounterCondition--;
-}
-
-buildUnnamed1154() {
+buildUnnamed1156() {
   var o = new core.List<api.Advice>();
   o.add(buildAdvice());
   o.add(buildAdvice());
   return o;
 }
 
-checkUnnamed1154(core.List<api.Advice> o) {
+checkUnnamed1156(core.List<api.Advice> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAdvice(o[0]);
   checkAdvice(o[1]);
 }
 
 core.int buildCounterConfigChange = 0;
 buildConfigChange() {
   var o = new api.ConfigChange();
   buildCounterConfigChange++;
   if (buildCounterConfigChange < 3) {
-    o.advices = buildUnnamed1154();
+    o.advices = buildUnnamed1156();
     o.changeType = "foo";
     o.element = "foo";
     o.newValue = "foo";
     o.oldValue = "foo";
   }
   buildCounterConfigChange--;
   return o;
 }
 
 checkConfigChange(api.ConfigChange o) {
   buildCounterConfigChange++;
   if (buildCounterConfigChange < 3) {
-    checkUnnamed1154(o.advices);
+    checkUnnamed1156(o.advices);
     unittest.expect(o.changeType, unittest.equals('foo'));
     unittest.expect(o.element, unittest.equals('foo'));
     unittest.expect(o.newValue, unittest.equals('foo'));
     unittest.expect(o.oldValue, unittest.equals('foo'));
   }
   buildCounterConfigChange--;
 }
 
 core.int buildCounterConfigFile = 0;
 buildConfigFile() {
@@ skipping 30 matching lines @@
 }
 
 checkConfigRef(api.ConfigRef o) {
   buildCounterConfigRef++;
   if (buildCounterConfigRef < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterConfigRef--;
 }
 
-buildUnnamed1155() {
+buildUnnamed1157() {
   var o = new core.List<api.ConfigFile>();
   o.add(buildConfigFile());
   o.add(buildConfigFile());
   return o;
 }
 
-checkUnnamed1155(core.List<api.ConfigFile> o) {
+checkUnnamed1157(core.List<api.ConfigFile> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkConfigFile(o[0]);
   checkConfigFile(o[1]);
 }
 
 core.int buildCounterConfigSource = 0;
 buildConfigSource() {
   var o = new api.ConfigSource();
   buildCounterConfigSource++;
   if (buildCounterConfigSource < 3) {
-    o.files = buildUnnamed1155();
+    o.files = buildUnnamed1157();
     o.id = "foo";
   }
   buildCounterConfigSource--;
   return o;
 }
 
 checkConfigSource(api.ConfigSource o) {
   buildCounterConfigSource++;
   if (buildCounterConfigSource < 3) {
-    checkUnnamed1155(o.files);
+    checkUnnamed1157(o.files);
     unittest.expect(o.id, unittest.equals('foo'));
   }
   buildCounterConfigSource--;
 }
 
-buildUnnamed1156() {
+buildUnnamed1158() {
   var o = new core.List<api.ContextRule>();
   o.add(buildContextRule());
   o.add(buildContextRule());
   return o;
 }
 
-checkUnnamed1156(core.List<api.ContextRule> o) {
+checkUnnamed1158(core.List<api.ContextRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkContextRule(o[0]);
   checkContextRule(o[1]);
 }
 
 core.int buildCounterContext = 0;
 buildContext() {
   var o = new api.Context();
   buildCounterContext++;
   if (buildCounterContext < 3) {
-    o.rules = buildUnnamed1156();
+    o.rules = buildUnnamed1158();
   }
   buildCounterContext--;
   return o;
 }
 
 checkContext(api.Context o) {
   buildCounterContext++;
   if (buildCounterContext < 3) {
-    checkUnnamed1156(o.rules);
+    checkUnnamed1158(o.rules);
   }
   buildCounterContext--;
 }
 
-buildUnnamed1157() {
+buildUnnamed1159() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1157(core.List<core.String> o) {
+checkUnnamed1159(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'));
 }
 
-buildUnnamed1158() {
+buildUnnamed1160() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1158(core.List<core.String> o) {
+checkUnnamed1160(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 buildCounterContextRule = 0;
 buildContextRule() {
   var o = new api.ContextRule();
   buildCounterContextRule++;
   if (buildCounterContextRule < 3) {
-    o.provided = buildUnnamed1157();
-    o.requested = buildUnnamed1158();
+    o.provided = buildUnnamed1159();
+    o.requested = buildUnnamed1160();
     o.selector = "foo";
   }
   buildCounterContextRule--;
   return o;
 }
 
 checkContextRule(api.ContextRule o) {
   buildCounterContextRule++;
   if (buildCounterContextRule < 3) {
-    checkUnnamed1157(o.provided);
-    checkUnnamed1158(o.requested);
+    checkUnnamed1159(o.provided);
+    checkUnnamed1160(o.requested);
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterContextRule--;
 }
 
 core.int buildCounterControl = 0;
 buildControl() {
   var o = new api.Control();
   buildCounterControl++;
   if (buildCounterControl < 3) {
     o.environment = "foo";
   }
   buildCounterControl--;
   return o;
 }
 
 checkControl(api.Control o) {
   buildCounterControl++;
   if (buildCounterControl < 3) {
     unittest.expect(o.environment, unittest.equals('foo'));
   }
   buildCounterControl--;
 }
 
-core.int buildCounterCounterOptions = 0;
-buildCounterOptions() {
-  var o = new api.CounterOptions();
-  buildCounterCounterOptions++;
-  if (buildCounterCounterOptions < 3) {
-    o.field = "foo";
-    o.metric = "foo";
-  }
-  buildCounterCounterOptions--;
-  return o;
-}
-
-checkCounterOptions(api.CounterOptions o) {
-  buildCounterCounterOptions++;
-  if (buildCounterCounterOptions < 3) {
-    unittest.expect(o.field, unittest.equals('foo'));
-    unittest.expect(o.metric, unittest.equals('foo'));
-  }
-  buildCounterCounterOptions--;
-}
-
 core.int buildCounterCustomAuthRequirements = 0;
 buildCustomAuthRequirements() {
   var o = new api.CustomAuthRequirements();
   buildCounterCustomAuthRequirements++;
   if (buildCounterCustomAuthRequirements < 3) {
     o.provider = "foo";
   }
   buildCounterCustomAuthRequirements--;
   return o;
 }
 
 checkCustomAuthRequirements(api.CustomAuthRequirements o) {
   buildCounterCustomAuthRequirements++;
   if (buildCounterCustomAuthRequirements < 3) {
     unittest.expect(o.provider, unittest.equals('foo'));
   }
   buildCounterCustomAuthRequirements--;
 }
 
-buildUnnamed1159() {
+buildUnnamed1161() {
   var o = new core.List<api.CustomErrorRule>();
   o.add(buildCustomErrorRule());
   o.add(buildCustomErrorRule());
   return o;
 }
 
-checkUnnamed1159(core.List<api.CustomErrorRule> o) {
+checkUnnamed1161(core.List<api.CustomErrorRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkCustomErrorRule(o[0]);
   checkCustomErrorRule(o[1]);
 }
 
-buildUnnamed1160() {
+buildUnnamed1162() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1160(core.List<core.String> o) {
+checkUnnamed1162(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 buildCounterCustomError = 0;
 buildCustomError() {
   var o = new api.CustomError();
   buildCounterCustomError++;
   if (buildCounterCustomError < 3) {
-    o.rules = buildUnnamed1159();
-    o.types = buildUnnamed1160();
+    o.rules = buildUnnamed1161();
+    o.types = buildUnnamed1162();
   }
   buildCounterCustomError--;
   return o;
 }
 
 checkCustomError(api.CustomError o) {
   buildCounterCustomError++;
   if (buildCounterCustomError < 3) {
-    checkUnnamed1159(o.rules);
-    checkUnnamed1160(o.types);
+    checkUnnamed1161(o.rules);
+    checkUnnamed1162(o.types);
   }
   buildCounterCustomError--;
 }
 
 core.int buildCounterCustomErrorRule = 0;
 buildCustomErrorRule() {
   var o = new api.CustomErrorRule();
   buildCounterCustomErrorRule++;
   if (buildCounterCustomErrorRule < 3) {
     o.isErrorType = true;
@@ skipping 26 matching lines @@
 
 checkCustomHttpPattern(api.CustomHttpPattern o) {
   buildCounterCustomHttpPattern++;
   if (buildCounterCustomHttpPattern < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.path, unittest.equals('foo'));
   }
   buildCounterCustomHttpPattern--;
 }
 
-core.int buildCounterDataAccessOptions = 0;
-buildDataAccessOptions() {
-  var o = new api.DataAccessOptions();
-  buildCounterDataAccessOptions++;
-  if (buildCounterDataAccessOptions < 3) {
-    o.logMode = "foo";
-  }
-  buildCounterDataAccessOptions--;
-  return o;
-}
-
-checkDataAccessOptions(api.DataAccessOptions o) {
-  buildCounterDataAccessOptions++;
-  if (buildCounterDataAccessOptions < 3) {
-    unittest.expect(o.logMode, unittest.equals('foo'));
-  }
-  buildCounterDataAccessOptions--;
-}
-
 core.int buildCounterDeleteServiceStrategy = 0;
 buildDeleteServiceStrategy() {
   var o = new api.DeleteServiceStrategy();
   buildCounterDeleteServiceStrategy++;
-  if (buildCounterDeleteServiceStrategy < 3) {
-  }
+  if (buildCounterDeleteServiceStrategy < 3) {}
   buildCounterDeleteServiceStrategy--;
   return o;
 }
 
 checkDeleteServiceStrategy(api.DeleteServiceStrategy o) {
   buildCounterDeleteServiceStrategy++;
-  if (buildCounterDeleteServiceStrategy < 3) {
-  }
+  if (buildCounterDeleteServiceStrategy < 3) {}
   buildCounterDeleteServiceStrategy--;
 }
 
 core.int buildCounterDiagnostic = 0;
 buildDiagnostic() {
   var o = new api.Diagnostic();
   buildCounterDiagnostic++;
   if (buildCounterDiagnostic < 3) {
     o.kind = "foo";
     o.location = "foo";
@@ skipping 25 matching lines @@
 }
 
 checkDisableServiceRequest(api.DisableServiceRequest o) {
   buildCounterDisableServiceRequest++;
   if (buildCounterDisableServiceRequest < 3) {
     unittest.expect(o.consumerId, unittest.equals('foo'));
   }
   buildCounterDisableServiceRequest--;
 }
 
-buildUnnamed1161() {
+buildUnnamed1163() {
   var o = new core.List<api.Page>();
   o.add(buildPage());
   o.add(buildPage());
   return o;
 }
 
-checkUnnamed1161(core.List<api.Page> o) {
+checkUnnamed1163(core.List<api.Page> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPage(o[0]);
   checkPage(o[1]);
 }
 
-buildUnnamed1162() {
+buildUnnamed1164() {
   var o = new core.List<api.DocumentationRule>();
   o.add(buildDocumentationRule());
   o.add(buildDocumentationRule());
   return o;
 }
 
-checkUnnamed1162(core.List<api.DocumentationRule> o) {
+checkUnnamed1164(core.List<api.DocumentationRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDocumentationRule(o[0]);
   checkDocumentationRule(o[1]);
 }
 
 core.int buildCounterDocumentation = 0;
 buildDocumentation() {
   var o = new api.Documentation();
   buildCounterDocumentation++;
   if (buildCounterDocumentation < 3) {
     o.documentationRootUrl = "foo";
     o.overview = "foo";
-    o.pages = buildUnnamed1161();
-    o.rules = buildUnnamed1162();
+    o.pages = buildUnnamed1163();
+    o.rules = buildUnnamed1164();
     o.summary = "foo";
   }
   buildCounterDocumentation--;
   return o;
 }
 
 checkDocumentation(api.Documentation o) {
   buildCounterDocumentation++;
   if (buildCounterDocumentation < 3) {
     unittest.expect(o.documentationRootUrl, unittest.equals('foo'));
     unittest.expect(o.overview, unittest.equals('foo'));
-    checkUnnamed1161(o.pages);
-    checkUnnamed1162(o.rules);
+    checkUnnamed1163(o.pages);
+    checkUnnamed1164(o.rules);
     unittest.expect(o.summary, unittest.equals('foo'));
   }
   buildCounterDocumentation--;
 }
 
 core.int buildCounterDocumentationRule = 0;
 buildDocumentationRule() {
   var o = new api.DocumentationRule();
   buildCounterDocumentationRule++;
   if (buildCounterDocumentationRule < 3) {
@@ skipping 27 matching lines @@
 }
 
 checkEnableServiceRequest(api.EnableServiceRequest o) {
   buildCounterEnableServiceRequest++;
   if (buildCounterEnableServiceRequest < 3) {
     unittest.expect(o.consumerId, unittest.equals('foo'));
   }
   buildCounterEnableServiceRequest--;
 }
 
-buildUnnamed1163() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1163(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'));
-}
-
-buildUnnamed1164() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1164(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'));
-}
-
 buildUnnamed1165() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
 checkUnnamed1165(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'));
+}
+
+buildUnnamed1166() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1166(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'));
+}
+
+buildUnnamed1167() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed1167(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 buildCounterEndpoint = 0;
 buildEndpoint() {
   var o = new api.Endpoint();
   buildCounterEndpoint++;
   if (buildCounterEndpoint < 3) {
-    o.aliases = buildUnnamed1163();
+    o.aliases = buildUnnamed1165();
     o.allowCors = true;
-    o.apis = buildUnnamed1164();
-    o.features = buildUnnamed1165();
+    o.apis = buildUnnamed1166();
+    o.features = buildUnnamed1167();
     o.name = "foo";
     o.target = "foo";
   }
   buildCounterEndpoint--;
   return o;
 }
 
 checkEndpoint(api.Endpoint o) {
   buildCounterEndpoint++;
   if (buildCounterEndpoint < 3) {
-    checkUnnamed1163(o.aliases);
+    checkUnnamed1165(o.aliases);
     unittest.expect(o.allowCors, unittest.isTrue);
-    checkUnnamed1164(o.apis);
-    checkUnnamed1165(o.features);
+    checkUnnamed1166(o.apis);
+    checkUnnamed1167(o.features);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.target, unittest.equals('foo'));
   }
   buildCounterEndpoint--;
 }
 
-buildUnnamed1166() {
+buildUnnamed1168() {
   var o = new core.List<api.EnumValue>();
   o.add(buildEnumValue());
   o.add(buildEnumValue());
   return o;
 }
 
-checkUnnamed1166(core.List<api.EnumValue> o) {
+checkUnnamed1168(core.List<api.EnumValue> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEnumValue(o[0]);
   checkEnumValue(o[1]);
 }
 
-buildUnnamed1167() {
+buildUnnamed1169() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1167(core.List<api.Option> o) {
+checkUnnamed1169(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterEnum = 0;
 buildEnum() {
   var o = new api.Enum();
   buildCounterEnum++;
   if (buildCounterEnum < 3) {
-    o.enumvalue = buildUnnamed1166();
+    o.enumvalue = buildUnnamed1168();
     o.name = "foo";
-    o.options = buildUnnamed1167();
+    o.options = buildUnnamed1169();
     o.sourceContext = buildSourceContext();
     o.syntax = "foo";
   }
   buildCounterEnum--;
   return o;
 }
 
 checkEnum(api.Enum o) {
   buildCounterEnum++;
   if (buildCounterEnum < 3) {
-    checkUnnamed1166(o.enumvalue);
+    checkUnnamed1168(o.enumvalue);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1167(o.options);
+    checkUnnamed1169(o.options);
     checkSourceContext(o.sourceContext);
     unittest.expect(o.syntax, unittest.equals('foo'));
   }
   buildCounterEnum--;
 }
 
-buildUnnamed1168() {
+buildUnnamed1170() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1168(core.List<api.Option> o) {
+checkUnnamed1170(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterEnumValue = 0;
 buildEnumValue() {
   var o = new api.EnumValue();
   buildCounterEnumValue++;
   if (buildCounterEnumValue < 3) {
     o.name = "foo";
     o.number = 42;
-    o.options = buildUnnamed1168();
+    o.options = buildUnnamed1170();
   }
   buildCounterEnumValue--;
   return o;
 }
 
 checkEnumValue(api.EnumValue o) {
   buildCounterEnumValue++;
   if (buildCounterEnumValue < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.number, unittest.equals(42));
-    checkUnnamed1168(o.options);
+    checkUnnamed1170(o.options);
   }
   buildCounterEnumValue--;
 }
 
 core.int buildCounterExperimental = 0;
 buildExperimental() {
   var o = new api.Experimental();
   buildCounterExperimental++;
   if (buildCounterExperimental < 3) {
     o.authorization = buildAuthorizationConfig();
@@ skipping 28 matching lines @@
   buildCounterExpr++;
   if (buildCounterExpr < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.expression, unittest.equals('foo'));
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.title, unittest.equals('foo'));
   }
   buildCounterExpr--;
 }
 
-buildUnnamed1169() {
+buildUnnamed1171() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1169(core.List<api.Option> o) {
+checkUnnamed1171(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterField = 0;
 buildField() {
   var o = new api.Field();
   buildCounterField++;
   if (buildCounterField < 3) {
     o.cardinality = "foo";
     o.defaultValue = "foo";
     o.jsonName = "foo";
     o.kind = "foo";
     o.name = "foo";
     o.number = 42;
     o.oneofIndex = 42;
-    o.options = buildUnnamed1169();
+    o.options = buildUnnamed1171();
     o.packed = true;
     o.typeUrl = "foo";
   }
   buildCounterField--;
   return o;
 }
 
 checkField(api.Field o) {
   buildCounterField++;
   if (buildCounterField < 3) {
     unittest.expect(o.cardinality, unittest.equals('foo'));
     unittest.expect(o.defaultValue, unittest.equals('foo'));
     unittest.expect(o.jsonName, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.number, unittest.equals(42));
     unittest.expect(o.oneofIndex, unittest.equals(42));
-    checkUnnamed1169(o.options);
+    checkUnnamed1171(o.options);
     unittest.expect(o.packed, unittest.isTrue);
     unittest.expect(o.typeUrl, unittest.equals('foo'));
   }
   buildCounterField--;
 }
 
-buildUnnamed1170() {
+buildUnnamed1172() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1170(core.List<core.String> o) {
+checkUnnamed1172(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 buildCounterFlowOperationMetadata = 0;
 buildFlowOperationMetadata() {
   var o = new api.FlowOperationMetadata();
   buildCounterFlowOperationMetadata++;
   if (buildCounterFlowOperationMetadata < 3) {
     o.cancelState = "foo";
     o.deadline = "foo";
     o.flowName = "foo";
-    o.resourceNames = buildUnnamed1170();
+    o.resourceNames = buildUnnamed1172();
     o.startTime = "foo";
   }
   buildCounterFlowOperationMetadata--;
   return o;
 }
 
 checkFlowOperationMetadata(api.FlowOperationMetadata o) {
   buildCounterFlowOperationMetadata++;
   if (buildCounterFlowOperationMetadata < 3) {
     unittest.expect(o.cancelState, unittest.equals('foo'));
     unittest.expect(o.deadline, unittest.equals('foo'));
     unittest.expect(o.flowName, unittest.equals('foo'));
-    checkUnnamed1170(o.resourceNames);
+    checkUnnamed1172(o.resourceNames);
     unittest.expect(o.startTime, unittest.equals('foo'));
   }
   buildCounterFlowOperationMetadata--;
 }
 
-buildUnnamed1171() {
+buildUnnamed1173() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1171(core.Map<core.String, core.Object> o) {
+checkUnnamed1173(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted1 = (o["x"]) as core.Map; unittest.expect(casted1, unittest.hasLength(3)); unittest.expect(casted1["list"], unittest.equals([1, 2, 3])); unittest.expect(casted1["bool"], unittest.equals(true)); unittest.expect(casted1["string"], unittest.equals('foo')); 
-  var casted2 = (o["y"]) as core.Map; unittest.expect(casted2, unittest.hasLength(3)); unittest.expect(casted2["list"], unittest.equals([1, 2, 3])); unittest.expect(casted2["bool"], unittest.equals(true)); unittest.expect(casted2["string"], unittest.equals('foo')); 
+  var casted1 = (o["x"]) as core.Map;
+  unittest.expect(casted1, unittest.hasLength(3));
+  unittest.expect(casted1["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted1["bool"], unittest.equals(true));
+  unittest.expect(casted1["string"], unittest.equals('foo'));
+  var casted2 = (o["y"]) as core.Map;
+  unittest.expect(casted2, unittest.hasLength(3));
+  unittest.expect(casted2["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted2["bool"], unittest.equals(true));
+  unittest.expect(casted2["string"], unittest.equals('foo'));
 }
 
-buildUnnamed1172() {
+buildUnnamed1174() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1172(core.Map<core.String, core.Object> o) {
+checkUnnamed1174(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted3 = (o["x"]) as core.Map; unittest.expect(casted3, unittest.hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo')); 
-  var casted4 = (o["y"]) as core.Map; unittest.expect(casted4, unittest.hasLength(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], unittest.equals('foo')); 
+  var casted3 = (o["x"]) as core.Map;
+  unittest.expect(casted3, unittest.hasLength(3));
+  unittest.expect(casted3["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted3["bool"], unittest.equals(true));
+  unittest.expect(casted3["string"], unittest.equals('foo'));
+  var casted4 = (o["y"]) as core.Map;
+  unittest.expect(casted4, unittest.hasLength(3));
+  unittest.expect(casted4["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted4["bool"], unittest.equals(true));
+  unittest.expect(casted4["string"], unittest.equals('foo'));
 }
 
 core.int buildCounterGenerateConfigReportRequest = 0;
 buildGenerateConfigReportRequest() {
   var o = new api.GenerateConfigReportRequest();
   buildCounterGenerateConfigReportRequest++;
   if (buildCounterGenerateConfigReportRequest < 3) {
-    o.newConfig = buildUnnamed1171();
-    o.oldConfig = buildUnnamed1172();
+    o.newConfig = buildUnnamed1173();
+    o.oldConfig = buildUnnamed1174();
   }
   buildCounterGenerateConfigReportRequest--;
   return o;
 }
 
 checkGenerateConfigReportRequest(api.GenerateConfigReportRequest o) {
   buildCounterGenerateConfigReportRequest++;
   if (buildCounterGenerateConfigReportRequest < 3) {
-    checkUnnamed1171(o.newConfig);
-    checkUnnamed1172(o.oldConfig);
+    checkUnnamed1173(o.newConfig);
+    checkUnnamed1174(o.oldConfig);
   }
   buildCounterGenerateConfigReportRequest--;
 }
 
-buildUnnamed1173() {
+buildUnnamed1175() {
   var o = new core.List<api.ChangeReport>();
   o.add(buildChangeReport());
   o.add(buildChangeReport());
   return o;
 }
 
-checkUnnamed1173(core.List<api.ChangeReport> o) {
+checkUnnamed1175(core.List<api.ChangeReport> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkChangeReport(o[0]);
   checkChangeReport(o[1]);
 }
 
-buildUnnamed1174() {
+buildUnnamed1176() {
   var o = new core.List<api.Diagnostic>();
   o.add(buildDiagnostic());
   o.add(buildDiagnostic());
   return o;
 }
 
-checkUnnamed1174(core.List<api.Diagnostic> o) {
+checkUnnamed1176(core.List<api.Diagnostic> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDiagnostic(o[0]);
   checkDiagnostic(o[1]);
 }
 
 core.int buildCounterGenerateConfigReportResponse = 0;
 buildGenerateConfigReportResponse() {
   var o = new api.GenerateConfigReportResponse();
   buildCounterGenerateConfigReportResponse++;
   if (buildCounterGenerateConfigReportResponse < 3) {
-    o.changeReports = buildUnnamed1173();
-    o.diagnostics = buildUnnamed1174();
+    o.changeReports = buildUnnamed1175();
+    o.diagnostics = buildUnnamed1176();
     o.id = "foo";
     o.serviceName = "foo";
   }
   buildCounterGenerateConfigReportResponse--;
   return o;
 }
 
 checkGenerateConfigReportResponse(api.GenerateConfigReportResponse o) {
   buildCounterGenerateConfigReportResponse++;
   if (buildCounterGenerateConfigReportResponse < 3) {
-    checkUnnamed1173(o.changeReports);
-    checkUnnamed1174(o.diagnostics);
+    checkUnnamed1175(o.changeReports);
+    checkUnnamed1176(o.diagnostics);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.serviceName, unittest.equals('foo'));
   }
   buildCounterGenerateConfigReportResponse--;
 }
 
 core.int buildCounterGetIamPolicyRequest = 0;
 buildGetIamPolicyRequest() {
   var o = new api.GetIamPolicyRequest();
   buildCounterGetIamPolicyRequest++;
-  if (buildCounterGetIamPolicyRequest < 3) {
-  }
+  if (buildCounterGetIamPolicyRequest < 3) {}
   buildCounterGetIamPolicyRequest--;
   return o;
 }
 
 checkGetIamPolicyRequest(api.GetIamPolicyRequest o) {
   buildCounterGetIamPolicyRequest++;
-  if (buildCounterGetIamPolicyRequest < 3) {
-  }
+  if (buildCounterGetIamPolicyRequest < 3) {}
   buildCounterGetIamPolicyRequest--;
 }
 
-buildUnnamed1175() {
+buildUnnamed1177() {
   var o = new core.List<api.HttpRule>();
   o.add(buildHttpRule());
   o.add(buildHttpRule());
   return o;
 }
 
-checkUnnamed1175(core.List<api.HttpRule> o) {
+checkUnnamed1177(core.List<api.HttpRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkHttpRule(o[0]);
   checkHttpRule(o[1]);
 }
 
 core.int buildCounterHttp = 0;
 buildHttp() {
   var o = new api.Http();
   buildCounterHttp++;
   if (buildCounterHttp < 3) {
     o.fullyDecodeReservedExpansion = true;
-    o.rules = buildUnnamed1175();
+    o.rules = buildUnnamed1177();
   }
   buildCounterHttp--;
   return o;
 }
 
 checkHttp(api.Http o) {
   buildCounterHttp++;
   if (buildCounterHttp < 3) {
     unittest.expect(o.fullyDecodeReservedExpansion, unittest.isTrue);
-    checkUnnamed1175(o.rules);
+    checkUnnamed1177(o.rules);
   }
   buildCounterHttp--;
 }
 
-buildUnnamed1176() {
+buildUnnamed1178() {
   var o = new core.List<api.HttpRule>();
   o.add(buildHttpRule());
   o.add(buildHttpRule());
   return o;
 }
 
-checkUnnamed1176(core.List<api.HttpRule> o) {
+checkUnnamed1178(core.List<api.HttpRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkHttpRule(o[0]);
   checkHttpRule(o[1]);
 }
 
 core.int buildCounterHttpRule = 0;
 buildHttpRule() {
   var o = new api.HttpRule();
   buildCounterHttpRule++;
   if (buildCounterHttpRule < 3) {
-    o.additionalBindings = buildUnnamed1176();
+    o.additionalBindings = buildUnnamed1178();
     o.body = "foo";
     o.custom = buildCustomHttpPattern();
     o.delete = "foo";
     o.get = "foo";
     o.mediaDownload = buildMediaDownload();
     o.mediaUpload = buildMediaUpload();
     o.patch = "foo";
     o.post = "foo";
     o.put = "foo";
     o.responseBody = "foo";
     o.selector = "foo";
   }
   buildCounterHttpRule--;
   return o;
 }
 
 checkHttpRule(api.HttpRule o) {
   buildCounterHttpRule++;
   if (buildCounterHttpRule < 3) {
-    checkUnnamed1176(o.additionalBindings);
+    checkUnnamed1178(o.additionalBindings);
     unittest.expect(o.body, unittest.equals('foo'));
     checkCustomHttpPattern(o.custom);
     unittest.expect(o.delete, unittest.equals('foo'));
     unittest.expect(o.get, unittest.equals('foo'));
     checkMediaDownload(o.mediaDownload);
     checkMediaUpload(o.mediaUpload);
     unittest.expect(o.patch, unittest.equals('foo'));
     unittest.expect(o.post, unittest.equals('foo'));
     unittest.expect(o.put, unittest.equals('foo'));
     unittest.expect(o.responseBody, unittest.equals('foo'));
@@ skipping 18 matching lines @@
 checkLabelDescriptor(api.LabelDescriptor o) {
   buildCounterLabelDescriptor++;
   if (buildCounterLabelDescriptor < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.key, unittest.equals('foo'));
     unittest.expect(o.valueType, unittest.equals('foo'));
   }
   buildCounterLabelDescriptor--;
 }
 
-buildUnnamed1177() {
+buildUnnamed1179() {
   var o = new core.List<api.Operation>();
   o.add(buildOperation());
   o.add(buildOperation());
   return o;
 }
 
-checkUnnamed1177(core.List<api.Operation> o) {
+checkUnnamed1179(core.List<api.Operation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOperation(o[0]);
   checkOperation(o[1]);
 }
 
 core.int buildCounterListOperationsResponse = 0;
 buildListOperationsResponse() {
   var o = new api.ListOperationsResponse();
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     o.nextPageToken = "foo";
-    o.operations = buildUnnamed1177();
+    o.operations = buildUnnamed1179();
   }
   buildCounterListOperationsResponse--;
   return o;
 }
 
 checkListOperationsResponse(api.ListOperationsResponse o) {
   buildCounterListOperationsResponse++;
   if (buildCounterListOperationsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1177(o.operations);
+    checkUnnamed1179(o.operations);
   }
   buildCounterListOperationsResponse--;
 }
 
-buildUnnamed1178() {
+buildUnnamed1180() {
   var o = new core.List<api.Service>();
   o.add(buildService());
   o.add(buildService());
   return o;
 }
 
-checkUnnamed1178(core.List<api.Service> o) {
+checkUnnamed1180(core.List<api.Service> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkService(o[0]);
   checkService(o[1]);
 }
 
 core.int buildCounterListServiceConfigsResponse = 0;
 buildListServiceConfigsResponse() {
   var o = new api.ListServiceConfigsResponse();
   buildCounterListServiceConfigsResponse++;
   if (buildCounterListServiceConfigsResponse < 3) {
     o.nextPageToken = "foo";
-    o.serviceConfigs = buildUnnamed1178();
+    o.serviceConfigs = buildUnnamed1180();
   }
   buildCounterListServiceConfigsResponse--;
   return o;
 }
 
 checkListServiceConfigsResponse(api.ListServiceConfigsResponse o) {
   buildCounterListServiceConfigsResponse++;
   if (buildCounterListServiceConfigsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1178(o.serviceConfigs);
+    checkUnnamed1180(o.serviceConfigs);
   }
   buildCounterListServiceConfigsResponse--;
 }
 
-buildUnnamed1179() {
+buildUnnamed1181() {
   var o = new core.List<api.Rollout>();
   o.add(buildRollout());
   o.add(buildRollout());
   return o;
 }
 
-checkUnnamed1179(core.List<api.Rollout> o) {
+checkUnnamed1181(core.List<api.Rollout> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkRollout(o[0]);
   checkRollout(o[1]);
 }
 
 core.int buildCounterListServiceRolloutsResponse = 0;
 buildListServiceRolloutsResponse() {
   var o = new api.ListServiceRolloutsResponse();
   buildCounterListServiceRolloutsResponse++;
   if (buildCounterListServiceRolloutsResponse < 3) {
     o.nextPageToken = "foo";
-    o.rollouts = buildUnnamed1179();
+    o.rollouts = buildUnnamed1181();
   }
   buildCounterListServiceRolloutsResponse--;
   return o;
 }
 
 checkListServiceRolloutsResponse(api.ListServiceRolloutsResponse o) {
   buildCounterListServiceRolloutsResponse++;
   if (buildCounterListServiceRolloutsResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1179(o.rollouts);
+    checkUnnamed1181(o.rollouts);
   }
   buildCounterListServiceRolloutsResponse--;
 }
 
-buildUnnamed1180() {
+buildUnnamed1182() {
   var o = new core.List<api.ManagedService>();
   o.add(buildManagedService());
   o.add(buildManagedService());
   return o;
 }
 
-checkUnnamed1180(core.List<api.ManagedService> o) {
+checkUnnamed1182(core.List<api.ManagedService> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkManagedService(o[0]);
   checkManagedService(o[1]);
 }
 
 core.int buildCounterListServicesResponse = 0;
 buildListServicesResponse() {
   var o = new api.ListServicesResponse();
   buildCounterListServicesResponse++;
   if (buildCounterListServicesResponse < 3) {
     o.nextPageToken = "foo";
-    o.services = buildUnnamed1180();
+    o.services = buildUnnamed1182();
   }
   buildCounterListServicesResponse--;
   return o;
 }
 
 checkListServicesResponse(api.ListServicesResponse o) {
   buildCounterListServicesResponse++;
   if (buildCounterListServicesResponse < 3) {
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1180(o.services);
+    checkUnnamed1182(o.services);
   }
   buildCounterListServicesResponse--;
 }
 
-core.int buildCounterLogConfig = 0;
-buildLogConfig() {
-  var o = new api.LogConfig();
-  buildCounterLogConfig++;
-  if (buildCounterLogConfig < 3) {
-    o.cloudAudit = buildCloudAuditOptions();
-    o.counter = buildCounterOptions();
-    o.dataAccess = buildDataAccessOptions();
-  }
-  buildCounterLogConfig--;
-  return o;
-}
-
-checkLogConfig(api.LogConfig o) {
-  buildCounterLogConfig++;
-  if (buildCounterLogConfig < 3) {
-    checkCloudAuditOptions(o.cloudAudit);
-    checkCounterOptions(o.counter);
-    checkDataAccessOptions(o.dataAccess);
-  }
-  buildCounterLogConfig--;
-}
-
-buildUnnamed1181() {
+buildUnnamed1183() {
   var o = new core.List<api.LabelDescriptor>();
   o.add(buildLabelDescriptor());
   o.add(buildLabelDescriptor());
   return o;
 }
 
-checkUnnamed1181(core.List<api.LabelDescriptor> o) {
+checkUnnamed1183(core.List<api.LabelDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLabelDescriptor(o[0]);
   checkLabelDescriptor(o[1]);
 }
 
 core.int buildCounterLogDescriptor = 0;
 buildLogDescriptor() {
   var o = new api.LogDescriptor();
   buildCounterLogDescriptor++;
   if (buildCounterLogDescriptor < 3) {
     o.description = "foo";
     o.displayName = "foo";
-    o.labels = buildUnnamed1181();
+    o.labels = buildUnnamed1183();
     o.name = "foo";
   }
   buildCounterLogDescriptor--;
   return o;
 }
 
 checkLogDescriptor(api.LogDescriptor o) {
   buildCounterLogDescriptor++;
   if (buildCounterLogDescriptor < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
-    checkUnnamed1181(o.labels);
+    checkUnnamed1183(o.labels);
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterLogDescriptor--;
 }
 
-buildUnnamed1182() {
+buildUnnamed1184() {
   var o = new core.List<api.LoggingDestination>();
   o.add(buildLoggingDestination());
   o.add(buildLoggingDestination());
   return o;
 }
 
-checkUnnamed1182(core.List<api.LoggingDestination> o) {
+checkUnnamed1184(core.List<api.LoggingDestination> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLoggingDestination(o[0]);
   checkLoggingDestination(o[1]);
 }
 
-buildUnnamed1183() {
+buildUnnamed1185() {
   var o = new core.List<api.LoggingDestination>();
   o.add(buildLoggingDestination());
   o.add(buildLoggingDestination());
   return o;
 }
 
-checkUnnamed1183(core.List<api.LoggingDestination> o) {
+checkUnnamed1185(core.List<api.LoggingDestination> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLoggingDestination(o[0]);
   checkLoggingDestination(o[1]);
 }
 
 core.int buildCounterLogging = 0;
 buildLogging() {
   var o = new api.Logging();
   buildCounterLogging++;
   if (buildCounterLogging < 3) {
-    o.consumerDestinations = buildUnnamed1182();
-    o.producerDestinations = buildUnnamed1183();
+    o.consumerDestinations = buildUnnamed1184();
+    o.producerDestinations = buildUnnamed1185();
   }
   buildCounterLogging--;
   return o;
 }
 
 checkLogging(api.Logging o) {
   buildCounterLogging++;
   if (buildCounterLogging < 3) {
-    checkUnnamed1182(o.consumerDestinations);
-    checkUnnamed1183(o.producerDestinations);
+    checkUnnamed1184(o.consumerDestinations);
+    checkUnnamed1185(o.producerDestinations);
   }
   buildCounterLogging--;
 }
 
-buildUnnamed1184() {
+buildUnnamed1186() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1184(core.List<core.String> o) {
+checkUnnamed1186(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 buildCounterLoggingDestination = 0;
 buildLoggingDestination() {
   var o = new api.LoggingDestination();
   buildCounterLoggingDestination++;
   if (buildCounterLoggingDestination < 3) {
-    o.logs = buildUnnamed1184();
+    o.logs = buildUnnamed1186();
     o.monitoredResource = "foo";
   }
   buildCounterLoggingDestination--;
   return o;
 }
 
 checkLoggingDestination(api.LoggingDestination o) {
   buildCounterLoggingDestination++;
   if (buildCounterLoggingDestination < 3) {
-    checkUnnamed1184(o.logs);
+    checkUnnamed1186(o.logs);
     unittest.expect(o.monitoredResource, unittest.equals('foo'));
   }
   buildCounterLoggingDestination--;
 }
 
 core.int buildCounterManagedService = 0;
 buildManagedService() {
   var o = new api.ManagedService();
   buildCounterManagedService++;
   if (buildCounterManagedService < 3) {
@@ skipping 35 matching lines @@
     unittest.expect(o.completeNotification, unittest.isTrue);
     unittest.expect(o.downloadService, unittest.equals('foo'));
     unittest.expect(o.dropzone, unittest.equals('foo'));
     unittest.expect(o.enabled, unittest.isTrue);
     unittest.expect(o.maxDirectDownloadSize, unittest.equals('foo'));
     unittest.expect(o.useDirectDownload, unittest.isTrue);
   }
   buildCounterMediaDownload--;
 }
 
-buildUnnamed1185() {
+buildUnnamed1187() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1185(core.List<core.String> o) {
+checkUnnamed1187(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 buildCounterMediaUpload = 0;
 buildMediaUpload() {
   var o = new api.MediaUpload();
   buildCounterMediaUpload++;
   if (buildCounterMediaUpload < 3) {
     o.completeNotification = true;
     o.dropzone = "foo";
     o.enabled = true;
     o.maxSize = "foo";
-    o.mimeTypes = buildUnnamed1185();
+    o.mimeTypes = buildUnnamed1187();
     o.progressNotification = true;
     o.startNotification = true;
     o.uploadService = "foo";
   }
   buildCounterMediaUpload--;
   return o;
 }
 
 checkMediaUpload(api.MediaUpload o) {
   buildCounterMediaUpload++;
   if (buildCounterMediaUpload < 3) {
     unittest.expect(o.completeNotification, unittest.isTrue);
     unittest.expect(o.dropzone, unittest.equals('foo'));
     unittest.expect(o.enabled, unittest.isTrue);
     unittest.expect(o.maxSize, unittest.equals('foo'));
-    checkUnnamed1185(o.mimeTypes);
+    checkUnnamed1187(o.mimeTypes);
     unittest.expect(o.progressNotification, unittest.isTrue);
     unittest.expect(o.startNotification, unittest.isTrue);
     unittest.expect(o.uploadService, unittest.equals('foo'));
   }
   buildCounterMediaUpload--;
 }
 
-buildUnnamed1186() {
+buildUnnamed1188() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1186(core.List<api.Option> o) {
+checkUnnamed1188(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterMethod = 0;
 buildMethod() {
   var o = new api.Method();
   buildCounterMethod++;
   if (buildCounterMethod < 3) {
     o.name = "foo";
-    o.options = buildUnnamed1186();
+    o.options = buildUnnamed1188();
     o.requestStreaming = true;
     o.requestTypeUrl = "foo";
     o.responseStreaming = true;
     o.responseTypeUrl = "foo";
     o.syntax = "foo";
   }
   buildCounterMethod--;
   return o;
 }
 
 checkMethod(api.Method o) {
   buildCounterMethod++;
   if (buildCounterMethod < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1186(o.options);
+    checkUnnamed1188(o.options);
     unittest.expect(o.requestStreaming, unittest.isTrue);
     unittest.expect(o.requestTypeUrl, unittest.equals('foo'));
     unittest.expect(o.responseStreaming, unittest.isTrue);
     unittest.expect(o.responseTypeUrl, unittest.equals('foo'));
     unittest.expect(o.syntax, unittest.equals('foo'));
   }
   buildCounterMethod--;
 }
 
-buildUnnamed1187() {
+buildUnnamed1189() {
   var o = new core.List<api.LabelDescriptor>();
   o.add(buildLabelDescriptor());
   o.add(buildLabelDescriptor());
   return o;
 }
 
-checkUnnamed1187(core.List<api.LabelDescriptor> o) {
+checkUnnamed1189(core.List<api.LabelDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLabelDescriptor(o[0]);
   checkLabelDescriptor(o[1]);
 }
 
 core.int buildCounterMetricDescriptor = 0;
 buildMetricDescriptor() {
   var o = new api.MetricDescriptor();
   buildCounterMetricDescriptor++;
   if (buildCounterMetricDescriptor < 3) {
     o.description = "foo";
     o.displayName = "foo";
-    o.labels = buildUnnamed1187();
+    o.labels = buildUnnamed1189();
     o.metricKind = "foo";
     o.name = "foo";
     o.type = "foo";
     o.unit = "foo";
     o.valueType = "foo";
   }
   buildCounterMetricDescriptor--;
   return o;
 }
 
 checkMetricDescriptor(api.MetricDescriptor o) {
   buildCounterMetricDescriptor++;
   if (buildCounterMetricDescriptor < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
-    checkUnnamed1187(o.labels);
+    checkUnnamed1189(o.labels);
     unittest.expect(o.metricKind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
     unittest.expect(o.unit, unittest.equals('foo'));
     unittest.expect(o.valueType, unittest.equals('foo'));
   }
   buildCounterMetricDescriptor--;
 }
 
-buildUnnamed1188() {
+buildUnnamed1190() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed1188(core.Map<core.String, core.String> o) {
+checkUnnamed1190(core.Map<core.String, core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals('foo'));
   unittest.expect(o["y"], unittest.equals('foo'));
 }
 
 core.int buildCounterMetricRule = 0;
 buildMetricRule() {
   var o = new api.MetricRule();
   buildCounterMetricRule++;
   if (buildCounterMetricRule < 3) {
-    o.metricCosts = buildUnnamed1188();
+    o.metricCosts = buildUnnamed1190();
     o.selector = "foo";
   }
   buildCounterMetricRule--;
   return o;
 }
 
 checkMetricRule(api.MetricRule o) {
   buildCounterMetricRule++;
   if (buildCounterMetricRule < 3) {
-    checkUnnamed1188(o.metricCosts);
+    checkUnnamed1190(o.metricCosts);
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterMetricRule--;
 }
 
 core.int buildCounterMixin = 0;
 buildMixin() {
   var o = new api.Mixin();
   buildCounterMixin++;
   if (buildCounterMixin < 3) {
     o.name = "foo";
     o.root = "foo";
   }
   buildCounterMixin--;
   return o;
 }
 
 checkMixin(api.Mixin o) {
   buildCounterMixin++;
   if (buildCounterMixin < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.root, unittest.equals('foo'));
   }
   buildCounterMixin--;
 }
 
-buildUnnamed1189() {
+buildUnnamed1191() {
   var o = new core.List<api.LabelDescriptor>();
   o.add(buildLabelDescriptor());
   o.add(buildLabelDescriptor());
   return o;
 }
 
-checkUnnamed1189(core.List<api.LabelDescriptor> o) {
+checkUnnamed1191(core.List<api.LabelDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLabelDescriptor(o[0]);
   checkLabelDescriptor(o[1]);
 }
 
 core.int buildCounterMonitoredResourceDescriptor = 0;
 buildMonitoredResourceDescriptor() {
   var o = new api.MonitoredResourceDescriptor();
   buildCounterMonitoredResourceDescriptor++;
   if (buildCounterMonitoredResourceDescriptor < 3) {
     o.description = "foo";
     o.displayName = "foo";
-    o.labels = buildUnnamed1189();
+    o.labels = buildUnnamed1191();
     o.name = "foo";
     o.type = "foo";
   }
   buildCounterMonitoredResourceDescriptor--;
   return o;
 }
 
 checkMonitoredResourceDescriptor(api.MonitoredResourceDescriptor o) {
   buildCounterMonitoredResourceDescriptor++;
   if (buildCounterMonitoredResourceDescriptor < 3) {
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
-    checkUnnamed1189(o.labels);
+    checkUnnamed1191(o.labels);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterMonitoredResourceDescriptor--;
 }
 
-buildUnnamed1190() {
+buildUnnamed1192() {
   var o = new core.List<api.MonitoringDestination>();
   o.add(buildMonitoringDestination());
   o.add(buildMonitoringDestination());
   return o;
 }
 
-checkUnnamed1190(core.List<api.MonitoringDestination> o) {
+checkUnnamed1192(core.List<api.MonitoringDestination> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMonitoringDestination(o[0]);
   checkMonitoringDestination(o[1]);
 }
 
-buildUnnamed1191() {
+buildUnnamed1193() {
   var o = new core.List<api.MonitoringDestination>();
   o.add(buildMonitoringDestination());
   o.add(buildMonitoringDestination());
   return o;
 }
 
-checkUnnamed1191(core.List<api.MonitoringDestination> o) {
+checkUnnamed1193(core.List<api.MonitoringDestination> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMonitoringDestination(o[0]);
   checkMonitoringDestination(o[1]);
 }
 
 core.int buildCounterMonitoring = 0;
 buildMonitoring() {
   var o = new api.Monitoring();
   buildCounterMonitoring++;
   if (buildCounterMonitoring < 3) {
-    o.consumerDestinations = buildUnnamed1190();
-    o.producerDestinations = buildUnnamed1191();
+    o.consumerDestinations = buildUnnamed1192();
+    o.producerDestinations = buildUnnamed1193();
   }
   buildCounterMonitoring--;
   return o;
 }
 
 checkMonitoring(api.Monitoring o) {
   buildCounterMonitoring++;
   if (buildCounterMonitoring < 3) {
-    checkUnnamed1190(o.consumerDestinations);
-    checkUnnamed1191(o.producerDestinations);
+    checkUnnamed1192(o.consumerDestinations);
+    checkUnnamed1193(o.producerDestinations);
   }
   buildCounterMonitoring--;
 }
 
-buildUnnamed1192() {
+buildUnnamed1194() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1192(core.List<core.String> o) {
+checkUnnamed1194(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 buildCounterMonitoringDestination = 0;
 buildMonitoringDestination() {
   var o = new api.MonitoringDestination();
   buildCounterMonitoringDestination++;
   if (buildCounterMonitoringDestination < 3) {
-    o.metrics = buildUnnamed1192();
+    o.metrics = buildUnnamed1194();
     o.monitoredResource = "foo";
   }
   buildCounterMonitoringDestination--;
   return o;
 }
 
 checkMonitoringDestination(api.MonitoringDestination o) {
   buildCounterMonitoringDestination++;
   if (buildCounterMonitoringDestination < 3) {
-    checkUnnamed1192(o.metrics);
+    checkUnnamed1194(o.metrics);
     unittest.expect(o.monitoredResource, unittest.equals('foo'));
   }
   buildCounterMonitoringDestination--;
 }
 
 core.int buildCounterOAuthRequirements = 0;
 buildOAuthRequirements() {
   var o = new api.OAuthRequirements();
   buildCounterOAuthRequirements++;
   if (buildCounterOAuthRequirements < 3) {
     o.canonicalScopes = "foo";
   }
   buildCounterOAuthRequirements--;
   return o;
 }
 
 checkOAuthRequirements(api.OAuthRequirements o) {
   buildCounterOAuthRequirements++;
   if (buildCounterOAuthRequirements < 3) {
     unittest.expect(o.canonicalScopes, unittest.equals('foo'));
   }
   buildCounterOAuthRequirements--;
 }
 
-buildUnnamed1193() {
+buildUnnamed1195() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1193(core.Map<core.String, core.Object> o) {
+checkUnnamed1195(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted5 = (o["x"]) as core.Map; unittest.expect(casted5, unittest.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], unittest.equals('foo')); 
-  var casted6 = (o["y"]) as core.Map; unittest.expect(casted6, unittest.hasLength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittest.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["string"], unittest.equals('foo')); 
+  var casted5 = (o["x"]) as core.Map;
+  unittest.expect(casted5, unittest.hasLength(3));
+  unittest.expect(casted5["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted5["bool"], unittest.equals(true));
+  unittest.expect(casted5["string"], unittest.equals('foo'));
+  var casted6 = (o["y"]) as core.Map;
+  unittest.expect(casted6, unittest.hasLength(3));
+  unittest.expect(casted6["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted6["bool"], unittest.equals(true));
+  unittest.expect(casted6["string"], unittest.equals('foo'));
 }
 
-buildUnnamed1194() {
+buildUnnamed1196() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1194(core.Map<core.String, core.Object> o) {
+checkUnnamed1196(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted7 = (o["x"]) as core.Map; unittest.expect(casted7, unittest.hasLength(3)); unittest.expect(casted7["list"], unittest.equals([1, 2, 3])); unittest.expect(casted7["bool"], unittest.equals(true)); unittest.expect(casted7["string"], unittest.equals('foo')); 
-  var casted8 = (o["y"]) as core.Map; unittest.expect(casted8, unittest.hasLength(3)); unittest.expect(casted8["list"], unittest.equals([1, 2, 3])); unittest.expect(casted8["bool"], unittest.equals(true)); unittest.expect(casted8["string"], unittest.equals('foo')); 
+  var casted7 = (o["x"]) as core.Map;
+  unittest.expect(casted7, unittest.hasLength(3));
+  unittest.expect(casted7["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted7["bool"], unittest.equals(true));
+  unittest.expect(casted7["string"], unittest.equals('foo'));
+  var casted8 = (o["y"]) as core.Map;
+  unittest.expect(casted8, unittest.hasLength(3));
+  unittest.expect(casted8["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted8["bool"], unittest.equals(true));
+  unittest.expect(casted8["string"], unittest.equals('foo'));
 }
 
 core.int buildCounterOperation = 0;
 buildOperation() {
   var o = new api.Operation();
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     o.done = true;
     o.error = buildStatus();
-    o.metadata = buildUnnamed1193();
+    o.metadata = buildUnnamed1195();
     o.name = "foo";
-    o.response = buildUnnamed1194();
+    o.response = buildUnnamed1196();
   }
   buildCounterOperation--;
   return o;
 }
 
 checkOperation(api.Operation o) {
   buildCounterOperation++;
   if (buildCounterOperation < 3) {
     unittest.expect(o.done, unittest.isTrue);
     checkStatus(o.error);
-    checkUnnamed1193(o.metadata);
+    checkUnnamed1195(o.metadata);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1194(o.response);
+    checkUnnamed1196(o.response);
   }
   buildCounterOperation--;
 }
 
-buildUnnamed1195() {
+buildUnnamed1197() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1195(core.List<core.String> o) {
+checkUnnamed1197(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'));
 }
 
-buildUnnamed1196() {
+buildUnnamed1198() {
   var o = new core.List<api.Step>();
   o.add(buildStep());
   o.add(buildStep());
   return o;
 }
 
-checkUnnamed1196(core.List<api.Step> o) {
+checkUnnamed1198(core.List<api.Step> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStep(o[0]);
   checkStep(o[1]);
 }
 
 core.int buildCounterOperationMetadata = 0;
 buildOperationMetadata() {
   var o = new api.OperationMetadata();
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     o.progressPercentage = 42;
-    o.resourceNames = buildUnnamed1195();
+    o.resourceNames = buildUnnamed1197();
     o.startTime = "foo";
-    o.steps = buildUnnamed1196();
+    o.steps = buildUnnamed1198();
   }
   buildCounterOperationMetadata--;
   return o;
 }
 
 checkOperationMetadata(api.OperationMetadata o) {
   buildCounterOperationMetadata++;
   if (buildCounterOperationMetadata < 3) {
     unittest.expect(o.progressPercentage, unittest.equals(42));
-    checkUnnamed1195(o.resourceNames);
+    checkUnnamed1197(o.resourceNames);
     unittest.expect(o.startTime, unittest.equals('foo'));
-    checkUnnamed1196(o.steps);
+    checkUnnamed1198(o.steps);
   }
   buildCounterOperationMetadata--;
 }
 
-buildUnnamed1197() {
+buildUnnamed1199() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1197(core.Map<core.String, core.Object> o) {
+checkUnnamed1199(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted9 = (o["x"]) as core.Map; unittest.expect(casted9, unittest.hasLength(3)); unittest.expect(casted9["list"], unittest.equals([1, 2, 3])); unittest.expect(casted9["bool"], unittest.equals(true)); unittest.expect(casted9["string"], unittest.equals('foo')); 
-  var casted10 = (o["y"]) as core.Map; unittest.expect(casted10, unittest.hasLength(3)); unittest.expect(casted10["list"], unittest.equals([1, 2, 3])); unittest.expect(casted10["bool"], unittest.equals(true)); unittest.expect(casted10["string"], unittest.equals('foo')); 
+  var casted9 = (o["x"]) as core.Map;
+  unittest.expect(casted9, unittest.hasLength(3));
+  unittest.expect(casted9["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted9["bool"], unittest.equals(true));
+  unittest.expect(casted9["string"], unittest.equals('foo'));
+  var casted10 = (o["y"]) as core.Map;
+  unittest.expect(casted10, unittest.hasLength(3));
+  unittest.expect(casted10["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted10["bool"], unittest.equals(true));
+  unittest.expect(casted10["string"], unittest.equals('foo'));
 }
 
 core.int buildCounterOption = 0;
 buildOption() {
   var o = new api.Option();
   buildCounterOption++;
   if (buildCounterOption < 3) {
     o.name = "foo";
-    o.value = buildUnnamed1197();
+    o.value = buildUnnamed1199();
   }
   buildCounterOption--;
   return o;
 }
 
 checkOption(api.Option o) {
   buildCounterOption++;
   if (buildCounterOption < 3) {
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1197(o.value);
+    checkUnnamed1199(o.value);
   }
   buildCounterOption--;
 }
 
-buildUnnamed1198() {
+buildUnnamed1200() {
   var o = new core.List<api.Page>();
   o.add(buildPage());
   o.add(buildPage());
   return o;
 }
 
-checkUnnamed1198(core.List<api.Page> o) {
+checkUnnamed1200(core.List<api.Page> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPage(o[0]);
   checkPage(o[1]);
 }
 
 core.int buildCounterPage = 0;
 buildPage() {
   var o = new api.Page();
   buildCounterPage++;
   if (buildCounterPage < 3) {
     o.content = "foo";
     o.name = "foo";
-    o.subpages = buildUnnamed1198();
+    o.subpages = buildUnnamed1200();
   }
   buildCounterPage--;
   return o;
 }
 
 checkPage(api.Page o) {
   buildCounterPage++;
   if (buildCounterPage < 3) {
     unittest.expect(o.content, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1198(o.subpages);
+    checkUnnamed1200(o.subpages);
   }
   buildCounterPage--;
 }
 
-buildUnnamed1199() {
+buildUnnamed1201() {
   var o = new core.List<api.AuditConfig>();
   o.add(buildAuditConfig());
   o.add(buildAuditConfig());
   return o;
 }
 
-checkUnnamed1199(core.List<api.AuditConfig> o) {
+checkUnnamed1201(core.List<api.AuditConfig> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkAuditConfig(o[0]);
   checkAuditConfig(o[1]);
 }
 
-buildUnnamed1200() {
+buildUnnamed1202() {
   var o = new core.List<api.Binding>();
   o.add(buildBinding());
   o.add(buildBinding());
   return o;
 }
 
-checkUnnamed1200(core.List<api.Binding> o) {
+checkUnnamed1202(core.List<api.Binding> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkBinding(o[0]);
   checkBinding(o[1]);
 }
 
-buildUnnamed1201() {
-  var o = new core.List<api.Rule>();
-  o.add(buildRule());
-  o.add(buildRule());
-  return o;
-}
-
-checkUnnamed1201(core.List<api.Rule> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkRule(o[0]);
-  checkRule(o[1]);
-}
-
 core.int buildCounterPolicy = 0;
 buildPolicy() {
   var o = new api.Policy();
   buildCounterPolicy++;
   if (buildCounterPolicy < 3) {
-    o.auditConfigs = buildUnnamed1199();
-    o.bindings = buildUnnamed1200();
+    o.auditConfigs = buildUnnamed1201();
+    o.bindings = buildUnnamed1202();
     o.etag = "foo";
     o.iamOwned = true;
-    o.rules = buildUnnamed1201();
     o.version = 42;
   }
   buildCounterPolicy--;
   return o;
 }
 
 checkPolicy(api.Policy o) {
   buildCounterPolicy++;
   if (buildCounterPolicy < 3) {
-    checkUnnamed1199(o.auditConfigs);
-    checkUnnamed1200(o.bindings);
+    checkUnnamed1201(o.auditConfigs);
+    checkUnnamed1202(o.bindings);
     unittest.expect(o.etag, unittest.equals('foo'));
     unittest.expect(o.iamOwned, unittest.isTrue);
-    checkUnnamed1201(o.rules);
     unittest.expect(o.version, unittest.equals(42));
   }
   buildCounterPolicy--;
 }
 
-buildUnnamed1202() {
+buildUnnamed1203() {
   var o = new core.List<api.QuotaLimit>();
   o.add(buildQuotaLimit());
   o.add(buildQuotaLimit());
   return o;
 }
 
-checkUnnamed1202(core.List<api.QuotaLimit> o) {
+checkUnnamed1203(core.List<api.QuotaLimit> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkQuotaLimit(o[0]);
   checkQuotaLimit(o[1]);
 }
 
-buildUnnamed1203() {
+buildUnnamed1204() {
   var o = new core.List<api.MetricRule>();
   o.add(buildMetricRule());
   o.add(buildMetricRule());
   return o;
 }
 
-checkUnnamed1203(core.List<api.MetricRule> o) {
+checkUnnamed1204(core.List<api.MetricRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetricRule(o[0]);
   checkMetricRule(o[1]);
 }
 
 core.int buildCounterQuota = 0;
 buildQuota() {
   var o = new api.Quota();
   buildCounterQuota++;
   if (buildCounterQuota < 3) {
-    o.limits = buildUnnamed1202();
-    o.metricRules = buildUnnamed1203();
+    o.limits = buildUnnamed1203();
+    o.metricRules = buildUnnamed1204();
   }
   buildCounterQuota--;
   return o;
 }
 
 checkQuota(api.Quota o) {
   buildCounterQuota++;
   if (buildCounterQuota < 3) {
-    checkUnnamed1202(o.limits);
-    checkUnnamed1203(o.metricRules);
+    checkUnnamed1203(o.limits);
+    checkUnnamed1204(o.metricRules);
   }
   buildCounterQuota--;
 }
 
-buildUnnamed1204() {
+buildUnnamed1205() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed1204(core.Map<core.String, core.String> o) {
+checkUnnamed1205(core.Map<core.String, core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals('foo'));
   unittest.expect(o["y"], unittest.equals('foo'));
 }
 
 core.int buildCounterQuotaLimit = 0;
 buildQuotaLimit() {
   var o = new api.QuotaLimit();
   buildCounterQuotaLimit++;
   if (buildCounterQuotaLimit < 3) {
     o.defaultLimit = "foo";
     o.description = "foo";
     o.displayName = "foo";
     o.duration = "foo";
     o.freeTier = "foo";
     o.maxLimit = "foo";
     o.metric = "foo";
     o.name = "foo";
     o.unit = "foo";
-    o.values = buildUnnamed1204();
+    o.values = buildUnnamed1205();
   }
   buildCounterQuotaLimit--;
   return o;
 }
 
 checkQuotaLimit(api.QuotaLimit o) {
   buildCounterQuotaLimit++;
   if (buildCounterQuotaLimit < 3) {
     unittest.expect(o.defaultLimit, unittest.equals('foo'));
     unittest.expect(o.description, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.duration, unittest.equals('foo'));
     unittest.expect(o.freeTier, unittest.equals('foo'));
     unittest.expect(o.maxLimit, unittest.equals('foo'));
     unittest.expect(o.metric, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.unit, unittest.equals('foo'));
-    checkUnnamed1204(o.values);
+    checkUnnamed1205(o.values);
   }
   buildCounterQuotaLimit--;
 }
 
 core.int buildCounterRollout = 0;
 buildRollout() {
   var o = new api.Rollout();
   buildCounterRollout++;
   if (buildCounterRollout < 3) {
     o.createTime = "foo";
@@ skipping 15 matching lines @@
     unittest.expect(o.createdBy, unittest.equals('foo'));
     checkDeleteServiceStrategy(o.deleteServiceStrategy);
     unittest.expect(o.rolloutId, unittest.equals('foo'));
     unittest.expect(o.serviceName, unittest.equals('foo'));
     unittest.expect(o.status, unittest.equals('foo'));
     checkTrafficPercentStrategy(o.trafficPercentStrategy);
   }
   buildCounterRollout--;
 }
 
-buildUnnamed1205() {
-  var o = new core.List<api.Condition>();
-  o.add(buildCondition());
-  o.add(buildCondition());
-  return o;
-}
-
-checkUnnamed1205(core.List<api.Condition> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkCondition(o[0]);
-  checkCondition(o[1]);
-}
-
 buildUnnamed1206() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1206(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'));
-}
-
-buildUnnamed1207() {
-  var o = new core.List<api.LogConfig>();
-  o.add(buildLogConfig());
-  o.add(buildLogConfig());
-  return o;
-}
-
-checkUnnamed1207(core.List<api.LogConfig> o) {
-  unittest.expect(o, unittest.hasLength(2));
-  checkLogConfig(o[0]);
-  checkLogConfig(o[1]);
-}
-
-buildUnnamed1208() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1208(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'));
-}
-
-buildUnnamed1209() {
-  var o = new core.List<core.String>();
-  o.add("foo");
-  o.add("foo");
-  return o;
-}
-
-checkUnnamed1209(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 buildCounterRule = 0;
-buildRule() {
-  var o = new api.Rule();
-  buildCounterRule++;
-  if (buildCounterRule < 3) {
-    o.action = "foo";
-    o.conditions = buildUnnamed1205();
-    o.description = "foo";
-    o.in_ = buildUnnamed1206();
-    o.logConfig = buildUnnamed1207();
-    o.notIn = buildUnnamed1208();
-    o.permissions = buildUnnamed1209();
-  }
-  buildCounterRule--;
-  return o;
-}
-
-checkRule(api.Rule o) {
-  buildCounterRule++;
-  if (buildCounterRule < 3) {
-    unittest.expect(o.action, unittest.equals('foo'));
-    checkUnnamed1205(o.conditions);
-    unittest.expect(o.description, unittest.equals('foo'));
-    checkUnnamed1206(o.in_);
-    checkUnnamed1207(o.logConfig);
-    checkUnnamed1208(o.notIn);
-    checkUnnamed1209(o.permissions);
-  }
-  buildCounterRule--;
-}
-
-buildUnnamed1210() {
   var o = new core.List<api.Api>();
   o.add(buildApi());
   o.add(buildApi());
   return o;
 }
 
-checkUnnamed1210(core.List<api.Api> o) {
+checkUnnamed1206(core.List<api.Api> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkApi(o[0]);
   checkApi(o[1]);
 }
 
-buildUnnamed1211() {
+buildUnnamed1207() {
   var o = new core.List<api.Endpoint>();
   o.add(buildEndpoint());
   o.add(buildEndpoint());
   return o;
 }
 
-checkUnnamed1211(core.List<api.Endpoint> o) {
+checkUnnamed1207(core.List<api.Endpoint> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEndpoint(o[0]);
   checkEndpoint(o[1]);
 }
 
-buildUnnamed1212() {
+buildUnnamed1208() {
   var o = new core.List<api.Enum>();
   o.add(buildEnum());
   o.add(buildEnum());
   return o;
 }
 
-checkUnnamed1212(core.List<api.Enum> o) {
+checkUnnamed1208(core.List<api.Enum> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkEnum(o[0]);
   checkEnum(o[1]);
 }
 
-buildUnnamed1213() {
+buildUnnamed1209() {
   var o = new core.List<api.LogDescriptor>();
   o.add(buildLogDescriptor());
   o.add(buildLogDescriptor());
   return o;
 }
 
-checkUnnamed1213(core.List<api.LogDescriptor> o) {
+checkUnnamed1209(core.List<api.LogDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkLogDescriptor(o[0]);
   checkLogDescriptor(o[1]);
 }
 
-buildUnnamed1214() {
+buildUnnamed1210() {
   var o = new core.List<api.MetricDescriptor>();
   o.add(buildMetricDescriptor());
   o.add(buildMetricDescriptor());
   return o;
 }
 
-checkUnnamed1214(core.List<api.MetricDescriptor> o) {
+checkUnnamed1210(core.List<api.MetricDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetricDescriptor(o[0]);
   checkMetricDescriptor(o[1]);
 }
 
-buildUnnamed1215() {
+buildUnnamed1211() {
   var o = new core.List<api.MonitoredResourceDescriptor>();
   o.add(buildMonitoredResourceDescriptor());
   o.add(buildMonitoredResourceDescriptor());
   return o;
 }
 
-checkUnnamed1215(core.List<api.MonitoredResourceDescriptor> o) {
+checkUnnamed1211(core.List<api.MonitoredResourceDescriptor> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMonitoredResourceDescriptor(o[0]);
   checkMonitoredResourceDescriptor(o[1]);
 }
 
-buildUnnamed1216() {
+buildUnnamed1212() {
   var o = new core.List<api.Type>();
   o.add(buildType());
   o.add(buildType());
   return o;
 }
 
-checkUnnamed1216(core.List<api.Type> o) {
+checkUnnamed1212(core.List<api.Type> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkType(o[0]);
   checkType(o[1]);
 }
 
-buildUnnamed1217() {
+buildUnnamed1213() {
   var o = new core.List<api.Type>();
   o.add(buildType());
   o.add(buildType());
   return o;
 }
 
-checkUnnamed1217(core.List<api.Type> o) {
+checkUnnamed1213(core.List<api.Type> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkType(o[0]);
   checkType(o[1]);
 }
 
 core.int buildCounterService = 0;
 buildService() {
   var o = new api.Service();
   buildCounterService++;
   if (buildCounterService < 3) {
-    o.apis = buildUnnamed1210();
+    o.apis = buildUnnamed1206();
     o.authentication = buildAuthentication();
     o.backend = buildBackend();
     o.configVersion = 42;
     o.context = buildContext();
     o.control = buildControl();
     o.customError = buildCustomError();
     o.documentation = buildDocumentation();
-    o.endpoints = buildUnnamed1211();
-    o.enums = buildUnnamed1212();
+    o.endpoints = buildUnnamed1207();
+    o.enums = buildUnnamed1208();
     o.experimental = buildExperimental();
     o.http = buildHttp();
     o.id = "foo";
     o.logging = buildLogging();
-    o.logs = buildUnnamed1213();
-    o.metrics = buildUnnamed1214();
-    o.monitoredResources = buildUnnamed1215();
+    o.logs = buildUnnamed1209();
+    o.metrics = buildUnnamed1210();
+    o.monitoredResources = buildUnnamed1211();
     o.monitoring = buildMonitoring();
     o.name = "foo";
     o.producerProjectId = "foo";
     o.quota = buildQuota();
     o.sourceInfo = buildSourceInfo();
     o.systemParameters = buildSystemParameters();
-    o.systemTypes = buildUnnamed1216();
+    o.systemTypes = buildUnnamed1212();
     o.title = "foo";
-    o.types = buildUnnamed1217();
+    o.types = buildUnnamed1213();
     o.usage = buildUsage();
     o.visibility = buildVisibility();
   }
   buildCounterService--;
   return o;
 }
 
 checkService(api.Service o) {
   buildCounterService++;
   if (buildCounterService < 3) {
-    checkUnnamed1210(o.apis);
+    checkUnnamed1206(o.apis);
     checkAuthentication(o.authentication);
     checkBackend(o.backend);
     unittest.expect(o.configVersion, unittest.equals(42));
     checkContext(o.context);
     checkControl(o.control);
     checkCustomError(o.customError);
     checkDocumentation(o.documentation);
-    checkUnnamed1211(o.endpoints);
-    checkUnnamed1212(o.enums);
+    checkUnnamed1207(o.endpoints);
+    checkUnnamed1208(o.enums);
     checkExperimental(o.experimental);
     checkHttp(o.http);
     unittest.expect(o.id, unittest.equals('foo'));
     checkLogging(o.logging);
-    checkUnnamed1213(o.logs);
-    checkUnnamed1214(o.metrics);
-    checkUnnamed1215(o.monitoredResources);
+    checkUnnamed1209(o.logs);
+    checkUnnamed1210(o.metrics);
+    checkUnnamed1211(o.monitoredResources);
     checkMonitoring(o.monitoring);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.producerProjectId, unittest.equals('foo'));
     checkQuota(o.quota);
     checkSourceInfo(o.sourceInfo);
     checkSystemParameters(o.systemParameters);
-    checkUnnamed1216(o.systemTypes);
+    checkUnnamed1212(o.systemTypes);
     unittest.expect(o.title, unittest.equals('foo'));
-    checkUnnamed1217(o.types);
+    checkUnnamed1213(o.types);
     checkUsage(o.usage);
     checkVisibility(o.visibility);
   }
   buildCounterService--;
 }
 
 core.int buildCounterSetIamPolicyRequest = 0;
 buildSetIamPolicyRequest() {
   var o = new api.SetIamPolicyRequest();
   buildCounterSetIamPolicyRequest++;
@@ skipping 26 matching lines @@
 }
 
 checkSourceContext(api.SourceContext o) {
   buildCounterSourceContext++;
   if (buildCounterSourceContext < 3) {
     unittest.expect(o.fileName, unittest.equals('foo'));
   }
   buildCounterSourceContext--;
 }
 
-buildUnnamed1218() {
+buildUnnamed1214() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1218(core.Map<core.String, core.Object> o) {
+checkUnnamed1214(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted11 = (o["x"]) as core.Map; unittest.expect(casted11, unittest.hasLength(3)); unittest.expect(casted11["list"], unittest.equals([1, 2, 3])); unittest.expect(casted11["bool"], unittest.equals(true)); unittest.expect(casted11["string"], unittest.equals('foo')); 
-  var casted12 = (o["y"]) as core.Map; unittest.expect(casted12, unittest.hasLength(3)); unittest.expect(casted12["list"], unittest.equals([1, 2, 3])); unittest.expect(casted12["bool"], unittest.equals(true)); unittest.expect(casted12["string"], unittest.equals('foo')); 
+  var casted11 = (o["x"]) as core.Map;
+  unittest.expect(casted11, unittest.hasLength(3));
+  unittest.expect(casted11["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted11["bool"], unittest.equals(true));
+  unittest.expect(casted11["string"], unittest.equals('foo'));
+  var casted12 = (o["y"]) as core.Map;
+  unittest.expect(casted12, unittest.hasLength(3));
+  unittest.expect(casted12["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted12["bool"], unittest.equals(true));
+  unittest.expect(casted12["string"], unittest.equals('foo'));
 }
 
-buildUnnamed1219() {
+buildUnnamed1215() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed1218());
-  o.add(buildUnnamed1218());
+  o.add(buildUnnamed1214());
+  o.add(buildUnnamed1214());
   return o;
 }
 
-checkUnnamed1219(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed1215(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1218(o[0]);
-  checkUnnamed1218(o[1]);
+  checkUnnamed1214(o[0]);
+  checkUnnamed1214(o[1]);
 }
 
 core.int buildCounterSourceInfo = 0;
 buildSourceInfo() {
   var o = new api.SourceInfo();
   buildCounterSourceInfo++;
   if (buildCounterSourceInfo < 3) {
-    o.sourceFiles = buildUnnamed1219();
+    o.sourceFiles = buildUnnamed1215();
   }
   buildCounterSourceInfo--;
   return o;
 }
 
 checkSourceInfo(api.SourceInfo o) {
   buildCounterSourceInfo++;
   if (buildCounterSourceInfo < 3) {
-    checkUnnamed1219(o.sourceFiles);
+    checkUnnamed1215(o.sourceFiles);
   }
   buildCounterSourceInfo--;
 }
 
-buildUnnamed1220() {
+buildUnnamed1216() {
   var o = new core.Map<core.String, core.Object>();
-  o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
-  o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
+  o["x"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
+  o["y"] = {
+    'list': [1, 2, 3],
+    'bool': true,
+    'string': 'foo'
+  };
   return o;
 }
 
-checkUnnamed1220(core.Map<core.String, core.Object> o) {
+checkUnnamed1216(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted13 = (o["x"]) as core.Map; unittest.expect(casted13, unittest.hasLength(3)); unittest.expect(casted13["list"], unittest.equals([1, 2, 3])); unittest.expect(casted13["bool"], unittest.equals(true)); unittest.expect(casted13["string"], unittest.equals('foo')); 
-  var casted14 = (o["y"]) as core.Map; unittest.expect(casted14, unittest.hasLength(3)); unittest.expect(casted14["list"], unittest.equals([1, 2, 3])); unittest.expect(casted14["bool"], unittest.equals(true)); unittest.expect(casted14["string"], unittest.equals('foo')); 
+  var casted13 = (o["x"]) as core.Map;
+  unittest.expect(casted13, unittest.hasLength(3));
+  unittest.expect(casted13["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted13["bool"], unittest.equals(true));
+  unittest.expect(casted13["string"], unittest.equals('foo'));
+  var casted14 = (o["y"]) as core.Map;
+  unittest.expect(casted14, unittest.hasLength(3));
+  unittest.expect(casted14["list"], unittest.equals([1, 2, 3]));
+  unittest.expect(casted14["bool"], unittest.equals(true));
+  unittest.expect(casted14["string"], unittest.equals('foo'));
 }
 
-buildUnnamed1221() {
+buildUnnamed1217() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed1220());
-  o.add(buildUnnamed1220());
+  o.add(buildUnnamed1216());
+  o.add(buildUnnamed1216());
   return o;
 }
 
-checkUnnamed1221(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed1217(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1220(o[0]);
-  checkUnnamed1220(o[1]);
+  checkUnnamed1216(o[0]);
+  checkUnnamed1216(o[1]);
 }
 
 core.int buildCounterStatus = 0;
 buildStatus() {
   var o = new api.Status();
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     o.code = 42;
-    o.details = buildUnnamed1221();
+    o.details = buildUnnamed1217();
     o.message = "foo";
   }
   buildCounterStatus--;
   return o;
 }
 
 checkStatus(api.Status o) {
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     unittest.expect(o.code, unittest.equals(42));
-    checkUnnamed1221(o.details);
+    checkUnnamed1217(o.details);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterStatus--;
 }
 
 core.int buildCounterStep = 0;
 buildStep() {
   var o = new api.Step();
   buildCounterStep++;
   if (buildCounterStep < 3) {
@@ skipping 69 matching lines @@
 checkSystemParameter(api.SystemParameter o) {
   buildCounterSystemParameter++;
   if (buildCounterSystemParameter < 3) {
     unittest.expect(o.httpHeader, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.urlQueryParameter, unittest.equals('foo'));
   }
   buildCounterSystemParameter--;
 }
 
-buildUnnamed1222() {
+buildUnnamed1218() {
   var o = new core.List<api.SystemParameter>();
   o.add(buildSystemParameter());
   o.add(buildSystemParameter());
   return o;
 }
 
-checkUnnamed1222(core.List<api.SystemParameter> o) {
+checkUnnamed1218(core.List<api.SystemParameter> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSystemParameter(o[0]);
   checkSystemParameter(o[1]);
 }
 
 core.int buildCounterSystemParameterRule = 0;
 buildSystemParameterRule() {
   var o = new api.SystemParameterRule();
   buildCounterSystemParameterRule++;
   if (buildCounterSystemParameterRule < 3) {
-    o.parameters = buildUnnamed1222();
+    o.parameters = buildUnnamed1218();
     o.selector = "foo";
   }
   buildCounterSystemParameterRule--;
   return o;
 }
 
 checkSystemParameterRule(api.SystemParameterRule o) {
   buildCounterSystemParameterRule++;
   if (buildCounterSystemParameterRule < 3) {
-    checkUnnamed1222(o.parameters);
+    checkUnnamed1218(o.parameters);
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterSystemParameterRule--;
 }
 
-buildUnnamed1223() {
+buildUnnamed1219() {
   var o = new core.List<api.SystemParameterRule>();
   o.add(buildSystemParameterRule());
   o.add(buildSystemParameterRule());
   return o;
 }
 
-checkUnnamed1223(core.List<api.SystemParameterRule> o) {
+checkUnnamed1219(core.List<api.SystemParameterRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSystemParameterRule(o[0]);
   checkSystemParameterRule(o[1]);
 }
 
 core.int buildCounterSystemParameters = 0;
 buildSystemParameters() {
   var o = new api.SystemParameters();
   buildCounterSystemParameters++;
   if (buildCounterSystemParameters < 3) {
-    o.rules = buildUnnamed1223();
+    o.rules = buildUnnamed1219();
   }
   buildCounterSystemParameters--;
   return o;
 }
 
 checkSystemParameters(api.SystemParameters o) {
   buildCounterSystemParameters++;
   if (buildCounterSystemParameters < 3) {
-    checkUnnamed1223(o.rules);
+    checkUnnamed1219(o.rules);
   }
   buildCounterSystemParameters--;
 }
 
-buildUnnamed1224() {
+buildUnnamed1220() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1224(core.List<core.String> o) {
+checkUnnamed1220(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 buildCounterTestIamPermissionsRequest = 0;
 buildTestIamPermissionsRequest() {
   var o = new api.TestIamPermissionsRequest();
   buildCounterTestIamPermissionsRequest++;
   if (buildCounterTestIamPermissionsRequest < 3) {
-    o.permissions = buildUnnamed1224();
+    o.permissions = buildUnnamed1220();
   }
   buildCounterTestIamPermissionsRequest--;
   return o;
 }
 
 checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
   buildCounterTestIamPermissionsRequest++;
   if (buildCounterTestIamPermissionsRequest < 3) {
-    checkUnnamed1224(o.permissions);
+    checkUnnamed1220(o.permissions);
   }
   buildCounterTestIamPermissionsRequest--;
 }
 
-buildUnnamed1225() {
+buildUnnamed1221() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1225(core.List<core.String> o) {
+checkUnnamed1221(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 buildCounterTestIamPermissionsResponse = 0;
 buildTestIamPermissionsResponse() {
   var o = new api.TestIamPermissionsResponse();
   buildCounterTestIamPermissionsResponse++;
   if (buildCounterTestIamPermissionsResponse < 3) {
-    o.permissions = buildUnnamed1225();
+    o.permissions = buildUnnamed1221();
   }
   buildCounterTestIamPermissionsResponse--;
   return o;
 }
 
 checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
   buildCounterTestIamPermissionsResponse++;
   if (buildCounterTestIamPermissionsResponse < 3) {
-    checkUnnamed1225(o.permissions);
+    checkUnnamed1221(o.permissions);
   }
   buildCounterTestIamPermissionsResponse--;
 }
 
-buildUnnamed1226() {
+buildUnnamed1222() {
   var o = new core.Map<core.String, core.double>();
   o["x"] = 42.0;
   o["y"] = 42.0;
   return o;
 }
 
-checkUnnamed1226(core.Map<core.String, core.double> o) {
+checkUnnamed1222(core.Map<core.String, core.double> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o["x"], unittest.equals(42.0));
   unittest.expect(o["y"], unittest.equals(42.0));
 }
 
 core.int buildCounterTrafficPercentStrategy = 0;
 buildTrafficPercentStrategy() {
   var o = new api.TrafficPercentStrategy();
   buildCounterTrafficPercentStrategy++;
   if (buildCounterTrafficPercentStrategy < 3) {
-    o.percentages = buildUnnamed1226();
+    o.percentages = buildUnnamed1222();
   }
   buildCounterTrafficPercentStrategy--;
   return o;
 }
 
 checkTrafficPercentStrategy(api.TrafficPercentStrategy o) {
   buildCounterTrafficPercentStrategy++;
   if (buildCounterTrafficPercentStrategy < 3) {
-    checkUnnamed1226(o.percentages);
+    checkUnnamed1222(o.percentages);
   }
   buildCounterTrafficPercentStrategy--;
 }
 
-buildUnnamed1227() {
+buildUnnamed1223() {
   var o = new core.List<api.Field>();
   o.add(buildField());
   o.add(buildField());
   return o;
 }
 
-checkUnnamed1227(core.List<api.Field> o) {
+checkUnnamed1223(core.List<api.Field> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkField(o[0]);
   checkField(o[1]);
 }
 
-buildUnnamed1228() {
+buildUnnamed1224() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1228(core.List<core.String> o) {
+checkUnnamed1224(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'));
 }
 
-buildUnnamed1229() {
+buildUnnamed1225() {
   var o = new core.List<api.Option>();
   o.add(buildOption());
   o.add(buildOption());
   return o;
 }
 
-checkUnnamed1229(core.List<api.Option> o) {
+checkUnnamed1225(core.List<api.Option> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkOption(o[0]);
   checkOption(o[1]);
 }
 
 core.int buildCounterType = 0;
 buildType() {
   var o = new api.Type();
   buildCounterType++;
   if (buildCounterType < 3) {
-    o.fields = buildUnnamed1227();
+    o.fields = buildUnnamed1223();
     o.name = "foo";
-    o.oneofs = buildUnnamed1228();
-    o.options = buildUnnamed1229();
+    o.oneofs = buildUnnamed1224();
+    o.options = buildUnnamed1225();
     o.sourceContext = buildSourceContext();
     o.syntax = "foo";
   }
   buildCounterType--;
   return o;
 }
 
 checkType(api.Type o) {
   buildCounterType++;
   if (buildCounterType < 3) {
-    checkUnnamed1227(o.fields);
+    checkUnnamed1223(o.fields);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1228(o.oneofs);
-    checkUnnamed1229(o.options);
+    checkUnnamed1224(o.oneofs);
+    checkUnnamed1225(o.options);
     checkSourceContext(o.sourceContext);
     unittest.expect(o.syntax, unittest.equals('foo'));
   }
   buildCounterType--;
 }
 
 core.int buildCounterUndeleteServiceResponse = 0;
 buildUndeleteServiceResponse() {
   var o = new api.UndeleteServiceResponse();
   buildCounterUndeleteServiceResponse++;
   if (buildCounterUndeleteServiceResponse < 3) {
     o.service = buildManagedService();
   }
   buildCounterUndeleteServiceResponse--;
   return o;
 }
 
 checkUndeleteServiceResponse(api.UndeleteServiceResponse o) {
   buildCounterUndeleteServiceResponse++;
   if (buildCounterUndeleteServiceResponse < 3) {
     checkManagedService(o.service);
   }
   buildCounterUndeleteServiceResponse--;
 }
 
-buildUnnamed1230() {
+buildUnnamed1226() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1230(core.List<core.String> o) {
+checkUnnamed1226(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'));
 }
 
-buildUnnamed1231() {
+buildUnnamed1227() {
   var o = new core.List<api.UsageRule>();
   o.add(buildUsageRule());
   o.add(buildUsageRule());
   return o;
 }
 
-checkUnnamed1231(core.List<api.UsageRule> o) {
+checkUnnamed1227(core.List<api.UsageRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUsageRule(o[0]);
   checkUsageRule(o[1]);
 }
 
 core.int buildCounterUsage = 0;
 buildUsage() {
   var o = new api.Usage();
   buildCounterUsage++;
   if (buildCounterUsage < 3) {
     o.producerNotificationChannel = "foo";
-    o.requirements = buildUnnamed1230();
-    o.rules = buildUnnamed1231();
+    o.requirements = buildUnnamed1226();
+    o.rules = buildUnnamed1227();
   }
   buildCounterUsage--;
   return o;
 }
 
 checkUsage(api.Usage o) {
   buildCounterUsage++;
   if (buildCounterUsage < 3) {
     unittest.expect(o.producerNotificationChannel, unittest.equals('foo'));
-    checkUnnamed1230(o.requirements);
-    checkUnnamed1231(o.rules);
+    checkUnnamed1226(o.requirements);
+    checkUnnamed1227(o.rules);
   }
   buildCounterUsage--;
 }
 
 core.int buildCounterUsageRule = 0;
 buildUsageRule() {
   var o = new api.UsageRule();
   buildCounterUsageRule++;
   if (buildCounterUsageRule < 3) {
     o.allowUnregisteredCalls = true;
     o.selector = "foo";
     o.skipServiceControl = true;
   }
   buildCounterUsageRule--;
   return o;
 }
 
 checkUsageRule(api.UsageRule o) {
   buildCounterUsageRule++;
   if (buildCounterUsageRule < 3) {
     unittest.expect(o.allowUnregisteredCalls, unittest.isTrue);
     unittest.expect(o.selector, unittest.equals('foo'));
     unittest.expect(o.skipServiceControl, unittest.isTrue);
   }
   buildCounterUsageRule--;
 }
 
-buildUnnamed1232() {
+buildUnnamed1228() {
   var o = new core.List<api.VisibilityRule>();
   o.add(buildVisibilityRule());
   o.add(buildVisibilityRule());
   return o;
 }
 
-checkUnnamed1232(core.List<api.VisibilityRule> o) {
+checkUnnamed1228(core.List<api.VisibilityRule> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkVisibilityRule(o[0]);
   checkVisibilityRule(o[1]);
 }
 
 core.int buildCounterVisibility = 0;
 buildVisibility() {
   var o = new api.Visibility();
   buildCounterVisibility++;
   if (buildCounterVisibility < 3) {
-    o.rules = buildUnnamed1232();
+    o.rules = buildUnnamed1228();
   }
   buildCounterVisibility--;
   return o;
 }
 
 checkVisibility(api.Visibility o) {
   buildCounterVisibility++;
   if (buildCounterVisibility < 3) {
-    checkUnnamed1232(o.rules);
+    checkUnnamed1228(o.rules);
   }
   buildCounterVisibility--;
 }
 
 core.int buildCounterVisibilityRule = 0;
 buildVisibilityRule() {
   var o = new api.VisibilityRule();
   buildCounterVisibilityRule++;
   if (buildCounterVisibilityRule < 3) {
     o.restriction = "foo";
     o.selector = "foo";
   }
   buildCounterVisibilityRule--;
   return o;
 }
 
 checkVisibilityRule(api.VisibilityRule o) {
   buildCounterVisibilityRule++;
   if (buildCounterVisibilityRule < 3) {
     unittest.expect(o.restriction, unittest.equals('foo'));
     unittest.expect(o.selector, unittest.equals('foo'));
   }
   buildCounterVisibilityRule--;
 }
 
-
 main() {
   unittest.group("obj-schema-Advice", () {
     unittest.test("to-json--from-json", () {
       var o = buildAdvice();
       var od = new api.Advice.fromJson(o.toJson());
       checkAdvice(od);
     });
   });
 
-
   unittest.group("obj-schema-Api", () {
     unittest.test("to-json--from-json", () {
       var o = buildApi();
       var od = new api.Api.fromJson(o.toJson());
       checkApi(od);
     });
   });
 
-
   unittest.group("obj-schema-AuditConfig", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuditConfig();
       var od = new api.AuditConfig.fromJson(o.toJson());
       checkAuditConfig(od);
     });
   });
 
-
   unittest.group("obj-schema-AuditLogConfig", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuditLogConfig();
       var od = new api.AuditLogConfig.fromJson(o.toJson());
       checkAuditLogConfig(od);
     });
   });
 
-
   unittest.group("obj-schema-AuthProvider", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuthProvider();
       var od = new api.AuthProvider.fromJson(o.toJson());
       checkAuthProvider(od);
     });
   });
 
-
   unittest.group("obj-schema-AuthRequirement", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuthRequirement();
       var od = new api.AuthRequirement.fromJson(o.toJson());
       checkAuthRequirement(od);
     });
   });
 
-
   unittest.group("obj-schema-Authentication", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuthentication();
       var od = new api.Authentication.fromJson(o.toJson());
       checkAuthentication(od);
     });
   });
 
-
   unittest.group("obj-schema-AuthenticationRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuthenticationRule();
       var od = new api.AuthenticationRule.fromJson(o.toJson());
       checkAuthenticationRule(od);
     });
   });
 
-
   unittest.group("obj-schema-AuthorizationConfig", () {
     unittest.test("to-json--from-json", () {
       var o = buildAuthorizationConfig();
       var od = new api.AuthorizationConfig.fromJson(o.toJson());
       checkAuthorizationConfig(od);
     });
   });
 
-
   unittest.group("obj-schema-Backend", () {
     unittest.test("to-json--from-json", () {
       var o = buildBackend();
       var od = new api.Backend.fromJson(o.toJson());
       checkBackend(od);
     });
   });
 
-
   unittest.group("obj-schema-BackendRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildBackendRule();
       var od = new api.BackendRule.fromJson(o.toJson());
       checkBackendRule(od);
     });
   });
 
-
   unittest.group("obj-schema-Binding", () {
     unittest.test("to-json--from-json", () {
       var o = buildBinding();
       var od = new api.Binding.fromJson(o.toJson());
       checkBinding(od);
     });
   });
 
-
   unittest.group("obj-schema-ChangeReport", () {
     unittest.test("to-json--from-json", () {
       var o = buildChangeReport();
       var od = new api.ChangeReport.fromJson(o.toJson());
       checkChangeReport(od);
     });
   });
 
-
-  unittest.group("obj-schema-CloudAuditOptions", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildCloudAuditOptions();
-      var od = new api.CloudAuditOptions.fromJson(o.toJson());
-      checkCloudAuditOptions(od);
-    });
-  });
-
-
-  unittest.group("obj-schema-Condition", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildCondition();
-      var od = new api.Condition.fromJson(o.toJson());
-      checkCondition(od);
-    });
-  });
-
-
   unittest.group("obj-schema-ConfigChange", () {
     unittest.test("to-json--from-json", () {
       var o = buildConfigChange();
       var od = new api.ConfigChange.fromJson(o.toJson());
       checkConfigChange(od);
     });
   });
 
-
   unittest.group("obj-schema-ConfigFile", () {
     unittest.test("to-json--from-json", () {
       var o = buildConfigFile();
       var od = new api.ConfigFile.fromJson(o.toJson());
       checkConfigFile(od);
     });
   });
 
-
   unittest.group("obj-schema-ConfigRef", () {
     unittest.test("to-json--from-json", () {
       var o = buildConfigRef();
       var od = new api.ConfigRef.fromJson(o.toJson());
       checkConfigRef(od);
     });
   });
 
-
   unittest.group("obj-schema-ConfigSource", () {
     unittest.test("to-json--from-json", () {
       var o = buildConfigSource();
       var od = new api.ConfigSource.fromJson(o.toJson());
       checkConfigSource(od);
     });
   });
 
-
   unittest.group("obj-schema-Context", () {
     unittest.test("to-json--from-json", () {
       var o = buildContext();
       var od = new api.Context.fromJson(o.toJson());
       checkContext(od);
     });
   });
 
-
   unittest.group("obj-schema-ContextRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildContextRule();
       var od = new api.ContextRule.fromJson(o.toJson());
       checkContextRule(od);
     });
   });
 
-
   unittest.group("obj-schema-Control", () {
     unittest.test("to-json--from-json", () {
       var o = buildControl();
       var od = new api.Control.fromJson(o.toJson());
       checkControl(od);
     });
   });
 
-
-  unittest.group("obj-schema-CounterOptions", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildCounterOptions();
-      var od = new api.CounterOptions.fromJson(o.toJson());
-      checkCounterOptions(od);
-    });
-  });
-
-
   unittest.group("obj-schema-CustomAuthRequirements", () {
     unittest.test("to-json--from-json", () {
       var o = buildCustomAuthRequirements();
       var od = new api.CustomAuthRequirements.fromJson(o.toJson());
       checkCustomAuthRequirements(od);
     });
   });
 
-
   unittest.group("obj-schema-CustomError", () {
     unittest.test("to-json--from-json", () {
       var o = buildCustomError();
       var od = new api.CustomError.fromJson(o.toJson());
       checkCustomError(od);
     });
   });
 
-
   unittest.group("obj-schema-CustomErrorRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildCustomErrorRule();
       var od = new api.CustomErrorRule.fromJson(o.toJson());
       checkCustomErrorRule(od);
     });
   });
 
-
   unittest.group("obj-schema-CustomHttpPattern", () {
     unittest.test("to-json--from-json", () {
       var o = buildCustomHttpPattern();
       var od = new api.CustomHttpPattern.fromJson(o.toJson());
       checkCustomHttpPattern(od);
     });
   });
 
-
-  unittest.group("obj-schema-DataAccessOptions", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildDataAccessOptions();
-      var od = new api.DataAccessOptions.fromJson(o.toJson());
-      checkDataAccessOptions(od);
-    });
-  });
-
-
   unittest.group("obj-schema-DeleteServiceStrategy", () {
     unittest.test("to-json--from-json", () {
       var o = buildDeleteServiceStrategy();
       var od = new api.DeleteServiceStrategy.fromJson(o.toJson());
       checkDeleteServiceStrategy(od);
     });
   });
 
-
   unittest.group("obj-schema-Diagnostic", () {
     unittest.test("to-json--from-json", () {
       var o = buildDiagnostic();
       var od = new api.Diagnostic.fromJson(o.toJson());
       checkDiagnostic(od);
     });
   });
 
-
   unittest.group("obj-schema-DisableServiceRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildDisableServiceRequest();
       var od = new api.DisableServiceRequest.fromJson(o.toJson());
       checkDisableServiceRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-Documentation", () {
     unittest.test("to-json--from-json", () {
       var o = buildDocumentation();
       var od = new api.Documentation.fromJson(o.toJson());
       checkDocumentation(od);
     });
   });
 
-
   unittest.group("obj-schema-DocumentationRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildDocumentationRule();
       var od = new api.DocumentationRule.fromJson(o.toJson());
       checkDocumentationRule(od);
     });
   });
 
-
   unittest.group("obj-schema-EnableServiceRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildEnableServiceRequest();
       var od = new api.EnableServiceRequest.fromJson(o.toJson());
       checkEnableServiceRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-Endpoint", () {
     unittest.test("to-json--from-json", () {
       var o = buildEndpoint();
       var od = new api.Endpoint.fromJson(o.toJson());
       checkEndpoint(od);
     });
   });
 
-
   unittest.group("obj-schema-Enum", () {
     unittest.test("to-json--from-json", () {
       var o = buildEnum();
       var od = new api.Enum.fromJson(o.toJson());
       checkEnum(od);
     });
   });
 
-
   unittest.group("obj-schema-EnumValue", () {
     unittest.test("to-json--from-json", () {
       var o = buildEnumValue();
       var od = new api.EnumValue.fromJson(o.toJson());
       checkEnumValue(od);
     });
   });
 
-
   unittest.group("obj-schema-Experimental", () {
     unittest.test("to-json--from-json", () {
       var o = buildExperimental();
       var od = new api.Experimental.fromJson(o.toJson());
       checkExperimental(od);
     });
   });
 
-
   unittest.group("obj-schema-Expr", () {
     unittest.test("to-json--from-json", () {
       var o = buildExpr();
       var od = new api.Expr.fromJson(o.toJson());
       checkExpr(od);
     });
   });
 
-
   unittest.group("obj-schema-Field", () {
     unittest.test("to-json--from-json", () {
       var o = buildField();
       var od = new api.Field.fromJson(o.toJson());
       checkField(od);
     });
   });
 
-
   unittest.group("obj-schema-FlowOperationMetadata", () {
     unittest.test("to-json--from-json", () {
       var o = buildFlowOperationMetadata();
       var od = new api.FlowOperationMetadata.fromJson(o.toJson());
       checkFlowOperationMetadata(od);
     });
   });
 
-
   unittest.group("obj-schema-GenerateConfigReportRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildGenerateConfigReportRequest();
       var od = new api.GenerateConfigReportRequest.fromJson(o.toJson());
       checkGenerateConfigReportRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-GenerateConfigReportResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildGenerateConfigReportResponse();
       var od = new api.GenerateConfigReportResponse.fromJson(o.toJson());
       checkGenerateConfigReportResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-GetIamPolicyRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildGetIamPolicyRequest();
       var od = new api.GetIamPolicyRequest.fromJson(o.toJson());
       checkGetIamPolicyRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-Http", () {
     unittest.test("to-json--from-json", () {
       var o = buildHttp();
       var od = new api.Http.fromJson(o.toJson());
       checkHttp(od);
     });
   });
 
-
   unittest.group("obj-schema-HttpRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildHttpRule();
       var od = new api.HttpRule.fromJson(o.toJson());
       checkHttpRule(od);
     });
   });
 
-
   unittest.group("obj-schema-LabelDescriptor", () {
     unittest.test("to-json--from-json", () {
       var o = buildLabelDescriptor();
       var od = new api.LabelDescriptor.fromJson(o.toJson());
       checkLabelDescriptor(od);
     });
   });
 
-
   unittest.group("obj-schema-ListOperationsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListOperationsResponse();
       var od = new api.ListOperationsResponse.fromJson(o.toJson());
       checkListOperationsResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ListServiceConfigsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListServiceConfigsResponse();
       var od = new api.ListServiceConfigsResponse.fromJson(o.toJson());
       checkListServiceConfigsResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ListServiceRolloutsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListServiceRolloutsResponse();
       var od = new api.ListServiceRolloutsResponse.fromJson(o.toJson());
       checkListServiceRolloutsResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-ListServicesResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildListServicesResponse();
       var od = new api.ListServicesResponse.fromJson(o.toJson());
       checkListServicesResponse(od);
     });
   });
 
-
-  unittest.group("obj-schema-LogConfig", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildLogConfig();
-      var od = new api.LogConfig.fromJson(o.toJson());
-      checkLogConfig(od);
-    });
-  });
-
-
   unittest.group("obj-schema-LogDescriptor", () {
     unittest.test("to-json--from-json", () {
       var o = buildLogDescriptor();
       var od = new api.LogDescriptor.fromJson(o.toJson());
       checkLogDescriptor(od);
     });
   });
 
-
   unittest.group("obj-schema-Logging", () {
     unittest.test("to-json--from-json", () {
       var o = buildLogging();
       var od = new api.Logging.fromJson(o.toJson());
       checkLogging(od);
     });
   });
 
-
   unittest.group("obj-schema-LoggingDestination", () {
     unittest.test("to-json--from-json", () {
       var o = buildLoggingDestination();
       var od = new api.LoggingDestination.fromJson(o.toJson());
       checkLoggingDestination(od);
     });
   });
 
-
   unittest.group("obj-schema-ManagedService", () {
     unittest.test("to-json--from-json", () {
       var o = buildManagedService();
       var od = new api.ManagedService.fromJson(o.toJson());
       checkManagedService(od);
     });
   });
 
-
   unittest.group("obj-schema-MediaDownload", () {
     unittest.test("to-json--from-json", () {
       var o = buildMediaDownload();
       var od = new api.MediaDownload.fromJson(o.toJson());
       checkMediaDownload(od);
     });
   });
 
-
   unittest.group("obj-schema-MediaUpload", () {
     unittest.test("to-json--from-json", () {
       var o = buildMediaUpload();
       var od = new api.MediaUpload.fromJson(o.toJson());
       checkMediaUpload(od);
     });
   });
 
-
   unittest.group("obj-schema-Method", () {
     unittest.test("to-json--from-json", () {
       var o = buildMethod();
       var od = new api.Method.fromJson(o.toJson());
       checkMethod(od);
     });
   });
 
-
   unittest.group("obj-schema-MetricDescriptor", () {
     unittest.test("to-json--from-json", () {
       var o = buildMetricDescriptor();
       var od = new api.MetricDescriptor.fromJson(o.toJson());
       checkMetricDescriptor(od);
     });
   });
 
-
   unittest.group("obj-schema-MetricRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildMetricRule();
       var od = new api.MetricRule.fromJson(o.toJson());
       checkMetricRule(od);
     });
   });
 
-
   unittest.group("obj-schema-Mixin", () {
     unittest.test("to-json--from-json", () {
       var o = buildMixin();
       var od = new api.Mixin.fromJson(o.toJson());
       checkMixin(od);
     });
   });
 
-
   unittest.group("obj-schema-MonitoredResourceDescriptor", () {
     unittest.test("to-json--from-json", () {
       var o = buildMonitoredResourceDescriptor();
       var od = new api.MonitoredResourceDescriptor.fromJson(o.toJson());
       checkMonitoredResourceDescriptor(od);
     });
   });
 
-
   unittest.group("obj-schema-Monitoring", () {
     unittest.test("to-json--from-json", () {
       var o = buildMonitoring();
       var od = new api.Monitoring.fromJson(o.toJson());
       checkMonitoring(od);
     });
   });
 
-
   unittest.group("obj-schema-MonitoringDestination", () {
     unittest.test("to-json--from-json", () {
       var o = buildMonitoringDestination();
       var od = new api.MonitoringDestination.fromJson(o.toJson());
       checkMonitoringDestination(od);
     });
   });
 
-
   unittest.group("obj-schema-OAuthRequirements", () {
     unittest.test("to-json--from-json", () {
       var o = buildOAuthRequirements();
       var od = new api.OAuthRequirements.fromJson(o.toJson());
       checkOAuthRequirements(od);
     });
   });
 
-
   unittest.group("obj-schema-Operation", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperation();
       var od = new api.Operation.fromJson(o.toJson());
       checkOperation(od);
     });
   });
 
-
   unittest.group("obj-schema-OperationMetadata", () {
     unittest.test("to-json--from-json", () {
       var o = buildOperationMetadata();
       var od = new api.OperationMetadata.fromJson(o.toJson());
       checkOperationMetadata(od);
     });
   });
 
-
   unittest.group("obj-schema-Option", () {
     unittest.test("to-json--from-json", () {
       var o = buildOption();
       var od = new api.Option.fromJson(o.toJson());
       checkOption(od);
     });
   });
 
-
   unittest.group("obj-schema-Page", () {
     unittest.test("to-json--from-json", () {
       var o = buildPage();
       var od = new api.Page.fromJson(o.toJson());
       checkPage(od);
     });
   });
 
-
   unittest.group("obj-schema-Policy", () {
     unittest.test("to-json--from-json", () {
       var o = buildPolicy();
       var od = new api.Policy.fromJson(o.toJson());
       checkPolicy(od);
     });
   });
 
-
   unittest.group("obj-schema-Quota", () {
     unittest.test("to-json--from-json", () {
       var o = buildQuota();
       var od = new api.Quota.fromJson(o.toJson());
       checkQuota(od);
     });
   });
 
-
   unittest.group("obj-schema-QuotaLimit", () {
     unittest.test("to-json--from-json", () {
       var o = buildQuotaLimit();
       var od = new api.QuotaLimit.fromJson(o.toJson());
       checkQuotaLimit(od);
     });
   });
 
-
   unittest.group("obj-schema-Rollout", () {
     unittest.test("to-json--from-json", () {
       var o = buildRollout();
       var od = new api.Rollout.fromJson(o.toJson());
       checkRollout(od);
     });
   });
 
-
-  unittest.group("obj-schema-Rule", () {
-    unittest.test("to-json--from-json", () {
-      var o = buildRule();
-      var od = new api.Rule.fromJson(o.toJson());
-      checkRule(od);
-    });
-  });
-
-
   unittest.group("obj-schema-Service", () {
     unittest.test("to-json--from-json", () {
       var o = buildService();
       var od = new api.Service.fromJson(o.toJson());
       checkService(od);
     });
   });
 
-
   unittest.group("obj-schema-SetIamPolicyRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildSetIamPolicyRequest();
       var od = new api.SetIamPolicyRequest.fromJson(o.toJson());
       checkSetIamPolicyRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-SourceContext", () {
     unittest.test("to-json--from-json", () {
       var o = buildSourceContext();
       var od = new api.SourceContext.fromJson(o.toJson());
       checkSourceContext(od);
     });
   });
 
-
   unittest.group("obj-schema-SourceInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildSourceInfo();
       var od = new api.SourceInfo.fromJson(o.toJson());
       checkSourceInfo(od);
     });
   });
 
-
   unittest.group("obj-schema-Status", () {
     unittest.test("to-json--from-json", () {
       var o = buildStatus();
       var od = new api.Status.fromJson(o.toJson());
       checkStatus(od);
     });
   });
 
-
   unittest.group("obj-schema-Step", () {
     unittest.test("to-json--from-json", () {
       var o = buildStep();
       var od = new api.Step.fromJson(o.toJson());
       checkStep(od);
     });
   });
 
-
   unittest.group("obj-schema-SubmitConfigSourceRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubmitConfigSourceRequest();
       var od = new api.SubmitConfigSourceRequest.fromJson(o.toJson());
       checkSubmitConfigSourceRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-SubmitConfigSourceResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildSubmitConfigSourceResponse();
       var od = new api.SubmitConfigSourceResponse.fromJson(o.toJson());
       checkSubmitConfigSourceResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-SystemParameter", () {
     unittest.test("to-json--from-json", () {
       var o = buildSystemParameter();
       var od = new api.SystemParameter.fromJson(o.toJson());
       checkSystemParameter(od);
     });
   });
 
-
   unittest.group("obj-schema-SystemParameterRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildSystemParameterRule();
       var od = new api.SystemParameterRule.fromJson(o.toJson());
       checkSystemParameterRule(od);
     });
   });
 
-
   unittest.group("obj-schema-SystemParameters", () {
     unittest.test("to-json--from-json", () {
       var o = buildSystemParameters();
       var od = new api.SystemParameters.fromJson(o.toJson());
       checkSystemParameters(od);
     });
   });
 
-
   unittest.group("obj-schema-TestIamPermissionsRequest", () {
     unittest.test("to-json--from-json", () {
       var o = buildTestIamPermissionsRequest();
       var od = new api.TestIamPermissionsRequest.fromJson(o.toJson());
       checkTestIamPermissionsRequest(od);
     });
   });
 
-
   unittest.group("obj-schema-TestIamPermissionsResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildTestIamPermissionsResponse();
       var od = new api.TestIamPermissionsResponse.fromJson(o.toJson());
       checkTestIamPermissionsResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-TrafficPercentStrategy", () {
     unittest.test("to-json--from-json", () {
       var o = buildTrafficPercentStrategy();
       var od = new api.TrafficPercentStrategy.fromJson(o.toJson());
       checkTrafficPercentStrategy(od);
     });
   });
 
-
   unittest.group("obj-schema-Type", () {
     unittest.test("to-json--from-json", () {
       var o = buildType();
       var od = new api.Type.fromJson(o.toJson());
       checkType(od);
     });
   });
 
-
   unittest.group("obj-schema-UndeleteServiceResponse", () {
     unittest.test("to-json--from-json", () {
       var o = buildUndeleteServiceResponse();
       var od = new api.UndeleteServiceResponse.fromJson(o.toJson());
       checkUndeleteServiceResponse(od);
     });
   });
 
-
   unittest.group("obj-schema-Usage", () {
     unittest.test("to-json--from-json", () {
       var o = buildUsage();
       var od = new api.Usage.fromJson(o.toJson());
       checkUsage(od);
     });
   });
 
-
   unittest.group("obj-schema-UsageRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildUsageRule();
       var od = new api.UsageRule.fromJson(o.toJson());
       checkUsageRule(od);
     });
   });
 
-
   unittest.group("obj-schema-Visibility", () {
     unittest.test("to-json--from-json", () {
       var o = buildVisibility();
       var od = new api.Visibility.fromJson(o.toJson());
       checkVisibility(od);
     });
   });
 
-
   unittest.group("obj-schema-VisibilityRule", () {
     unittest.test("to-json--from-json", () {
       var o = buildVisibilityRule();
       var od = new api.VisibilityRule.fromJson(o.toJson());
       checkVisibilityRule(od);
     });
   });
 
-
   unittest.group("resource-OperationsResourceApi", () {
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
-      api.OperationsResourceApi res = new api.ServicemanagementApi(mock).operations;
+      api.OperationsResourceApi res =
+          new api.ServicemanagementApi(mock).operations;
       var arg_name = "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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_name).then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.OperationsResourceApi res = new api.ServicemanagementApi(mock).operations;
+      api.OperationsResourceApi res =
+          new api.ServicemanagementApi(mock).operations;
+      var arg_pageToken = "foo";
+      var arg_name = "foo";
       var arg_pageSize = 42;
       var arg_filter = "foo";
-      var arg_pageToken = "foo";
-      var arg_name = "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 + 13), unittest.equals("v1/operations"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13),
+            unittest.equals("v1/operations"));
         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(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["name"].first, unittest.equals(arg_name));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first),
+            unittest.equals(arg_pageSize));
         unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(queryMap["name"].first, unittest.equals(arg_name));
-
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListOperationsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(pageSize: arg_pageSize, filter: arg_filter, pageToken: arg_pageToken, name: arg_name).then(unittest.expectAsync1(((api.ListOperationsResponse response) {
+      res
+          .list(
+              pageToken: arg_pageToken,
+              name: arg_name,
+              pageSize: arg_pageSize,
+              filter: arg_filter)
+          .then(unittest.expectAsync1(((api.ListOperationsResponse response) {
         checkListOperationsResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ServicesResourceApi", () {
     unittest.test("method--create", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildManagedService();
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.ManagedService.fromJson(json);
         checkManagedService(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("v1/services"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("v1/services"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.create(arg_request).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .create(arg_request)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--delete", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_serviceName = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.delete(arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .delete(arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--disable", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildDisableServiceRequest();
       var arg_serviceName = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.DisableServiceRequest.fromJson(json);
         checkDisableServiceRequest(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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf(":disable", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals(":disable"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals(":disable"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.disable(arg_request, arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .disable(arg_request, arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--enable", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildEnableServiceRequest();
       var arg_serviceName = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.EnableServiceRequest.fromJson(json);
         checkEnableServiceRequest(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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf(":enable", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals(":enable"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7),
+            unittest.equals(":enable"));
         pathOffset += 7;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.enable(arg_request, arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .enable(arg_request, arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--generateConfigReport", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildGenerateConfigReportRequest();
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.GenerateConfigReportRequest.fromJson(json);
         checkGenerateConfigReportRequest(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 + 32), unittest.equals("v1/services:generateConfigReport"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 32),
+            unittest.equals("v1/services:generateConfigReport"));
         pathOffset += 32;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildGenerateConfigReportResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.generateConfigReport(arg_request).then(unittest.expectAsync1(((api.GenerateConfigReportResponse response) {
+      res.generateConfigReport(arg_request).then(
+          unittest.expectAsync1(((api.GenerateConfigReportResponse response) {
         checkGenerateConfigReportResponse(response);
       })));
     });
 
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_serviceName = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildManagedService());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.get(arg_serviceName).then(unittest.expectAsync1(((api.ManagedService response) {
+      res
+          .get(arg_serviceName)
+          .then(unittest.expectAsync1(((api.ManagedService response) {
         checkManagedService(response);
       })));
     });
 
     unittest.test("method--getConfig", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_serviceName = "foo";
+      var arg_view = "foo";
       var arg_configId = "foo";
-      var arg_view = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/config", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/config"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7),
+            unittest.equals("/config"));
         pathOffset += 7;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
-        unittest.expect(queryMap["configId"].first, unittest.equals(arg_configId));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
-
+        unittest.expect(
+            queryMap["configId"].first, unittest.equals(arg_configId));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildService());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.getConfig(arg_serviceName, configId: arg_configId, view: arg_view).then(unittest.expectAsync1(((api.Service response) {
+      res
+          .getConfig(arg_serviceName, view: arg_view, configId: arg_configId)
+          .then(unittest.expectAsync1(((api.Service response) {
         checkService(response);
       })));
     });
 
     unittest.test("method--getIamPolicy", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildGetIamPolicyRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.GetIamPolicyRequest.fromJson(json);
         checkGetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPolicy());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync1(((api.Policy response) {
+      res
+          .getIamPolicy(arg_request, arg_resource)
+          .then(unittest.expectAsync1(((api.Policy response) {
         checkPolicy(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
-      var arg_pageSize = 42;
       var arg_producerProjectId = "foo";
       var arg_consumerId = "foo";
       var arg_pageToken = "foo";
+      var arg_pageSize = 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("v1/services"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 11),
+            unittest.equals("v1/services"));
         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(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
-        unittest.expect(queryMap["producerProjectId"].first, unittest.equals(arg_producerProjectId));
-        unittest.expect(queryMap["consumerId"].first, unittest.equals(arg_consumerId));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-
+        unittest.expect(queryMap["producerProjectId"].first,
+            unittest.equals(arg_producerProjectId));
+        unittest.expect(
+            queryMap["consumerId"].first, unittest.equals(arg_consumerId));
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first),
+            unittest.equals(arg_pageSize));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListServicesResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(pageSize: arg_pageSize, producerProjectId: arg_producerProjectId, consumerId: arg_consumerId, pageToken: arg_pageToken).then(unittest.expectAsync1(((api.ListServicesResponse response) {
+      res
+          .list(
+              producerProjectId: arg_producerProjectId,
+              consumerId: arg_consumerId,
+              pageToken: arg_pageToken,
+              pageSize: arg_pageSize)
+          .then(unittest.expectAsync1(((api.ListServicesResponse response) {
         checkListServicesResponse(response);
       })));
     });
 
     unittest.test("method--setIamPolicy", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildSetIamPolicyRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.SetIamPolicyRequest.fromJson(json);
         checkSetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPolicy());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync1(((api.Policy response) {
+      res
+          .setIamPolicy(arg_request, arg_resource)
+          .then(unittest.expectAsync1(((api.Policy response) {
         checkPolicy(response);
       })));
     });
 
     unittest.test("method--testIamPermissions", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_request = buildTestIamPermissionsRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.TestIamPermissionsRequest.fromJson(json);
         checkTestIamPermissionsRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildTestIamPermissionsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync1(((api.TestIamPermissionsResponse response) {
+      res.testIamPermissions(arg_request, arg_resource).then(
+          unittest.expectAsync1(((api.TestIamPermissionsResponse response) {
         checkTestIamPermissionsResponse(response);
       })));
     });
 
     unittest.test("method--undelete", () {
-
       var mock = new HttpServerMock();
       api.ServicesResourceApi res = new api.ServicemanagementApi(mock).services;
       var arg_serviceName = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf(":undelete", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals(":undelete"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals(":undelete"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.undelete(arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .undelete(arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ServicesConfigsResourceApi", () {
     unittest.test("method--create", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConfigsResourceApi res = new api.ServicemanagementApi(mock).services.configs;
+      api.ServicesConfigsResourceApi res =
+          new api.ServicemanagementApi(mock).services.configs;
       var arg_request = buildService();
       var arg_serviceName = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Service.fromJson(json);
         checkService(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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/configs", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/configs"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("/configs"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildService());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.create(arg_request, arg_serviceName).then(unittest.expectAsync1(((api.Service response) {
+      res
+          .create(arg_request, arg_serviceName)
+          .then(unittest.expectAsync1(((api.Service response) {
         checkService(response);
       })));
     });
 
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConfigsResourceApi res = new api.ServicemanagementApi(mock).services.configs;
+      api.ServicesConfigsResourceApi res =
+          new api.ServicemanagementApi(mock).services.configs;
       var arg_serviceName = "foo";
       var arg_configId = "foo";
       var arg_view = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/configs/", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/configs/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("/configs/"));
         pathOffset += 9;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_configId"));
 
         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["view"].first, unittest.equals(arg_view));
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildService());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.get(arg_serviceName, arg_configId, view: arg_view).then(unittest.expectAsync1(((api.Service response) {
+      res
+          .get(arg_serviceName, arg_configId, view: arg_view)
+          .then(unittest.expectAsync1(((api.Service response) {
         checkService(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConfigsResourceApi res = new api.ServicemanagementApi(mock).services.configs;
+      api.ServicesConfigsResourceApi res =
+          new api.ServicemanagementApi(mock).services.configs;
       var arg_serviceName = "foo";
       var arg_pageToken = "foo";
       var arg_pageSize = 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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/configs", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/configs"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8),
+            unittest.equals("/configs"));
         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["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
-
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first),
+            unittest.equals(arg_pageSize));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListServiceConfigsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_serviceName, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync1(((api.ListServiceConfigsResponse response) {
+      res
+          .list(arg_serviceName,
+              pageToken: arg_pageToken, pageSize: arg_pageSize)
+          .then(
+              unittest.expectAsync1(((api.ListServiceConfigsResponse response) {
         checkListServiceConfigsResponse(response);
       })));
     });
 
     unittest.test("method--submit", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConfigsResourceApi res = new api.ServicemanagementApi(mock).services.configs;
+      api.ServicesConfigsResourceApi res =
+          new api.ServicemanagementApi(mock).services.configs;
       var arg_request = buildSubmitConfigSourceRequest();
       var arg_serviceName = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.SubmitConfigSourceRequest.fromJson(json);
         checkSubmitConfigSourceRequest(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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/configs:submit", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/configs:submit"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15),
+            unittest.equals("/configs:submit"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.submit(arg_request, arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .submit(arg_request, arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ServicesConsumersResourceApi", () {
     unittest.test("method--getIamPolicy", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConsumersResourceApi res = new api.ServicemanagementApi(mock).services.consumers;
+      api.ServicesConsumersResourceApi res =
+          new api.ServicemanagementApi(mock).services.consumers;
       var arg_request = buildGetIamPolicyRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.GetIamPolicyRequest.fromJson(json);
         checkGetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPolicy());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync1(((api.Policy response) {
+      res
+          .getIamPolicy(arg_request, arg_resource)
+          .then(unittest.expectAsync1(((api.Policy response) {
         checkPolicy(response);
       })));
     });
 
     unittest.test("method--setIamPolicy", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConsumersResourceApi res = new api.ServicemanagementApi(mock).services.consumers;
+      api.ServicesConsumersResourceApi res =
+          new api.ServicemanagementApi(mock).services.consumers;
       var arg_request = buildSetIamPolicyRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.SetIamPolicyRequest.fromJson(json);
         checkSetIamPolicyRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildPolicy());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync1(((api.Policy response) {
+      res
+          .setIamPolicy(arg_request, arg_resource)
+          .then(unittest.expectAsync1(((api.Policy response) {
         checkPolicy(response);
       })));
     });
 
     unittest.test("method--testIamPermissions", () {
-
       var mock = new HttpServerMock();
-      api.ServicesConsumersResourceApi res = new api.ServicemanagementApi(mock).services.consumers;
+      api.ServicesConsumersResourceApi res =
+          new api.ServicemanagementApi(mock).services.consumers;
       var arg_request = buildTestIamPermissionsRequest();
       var arg_resource = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.TestIamPermissionsRequest.fromJson(json);
         checkTestIamPermissionsRequest(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 + 3), unittest.equals("v1/"));
+        unittest.expect(
+            path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
         pathOffset += 3;
         // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildTestIamPermissionsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync1(((api.TestIamPermissionsResponse response) {
+      res.testIamPermissions(arg_request, arg_resource).then(
+          unittest.expectAsync1(((api.TestIamPermissionsResponse response) {
         checkTestIamPermissionsResponse(response);
       })));
     });
-
   });
 
-
   unittest.group("resource-ServicesRolloutsResourceApi", () {
     unittest.test("method--create", () {
-
       var mock = new HttpServerMock();
-      api.ServicesRolloutsResourceApi res = new api.ServicemanagementApi(mock).services.rollouts;
+      api.ServicesRolloutsResourceApi res =
+          new api.ServicemanagementApi(mock).services.rollouts;
       var arg_request = buildRollout();
       var arg_serviceName = "foo";
       mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
         var obj = new api.Rollout.fromJson(json);
         checkRollout(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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/rollouts", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/rollouts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("/rollouts"));
         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]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildOperation());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.create(arg_request, arg_serviceName).then(unittest.expectAsync1(((api.Operation response) {
+      res
+          .create(arg_request, arg_serviceName)
+          .then(unittest.expectAsync1(((api.Operation response) {
         checkOperation(response);
       })));
     });
 
     unittest.test("method--get", () {
-
       var mock = new HttpServerMock();
-      api.ServicesRolloutsResourceApi res = new api.ServicemanagementApi(mock).services.rollouts;
+      api.ServicesRolloutsResourceApi res =
+          new api.ServicemanagementApi(mock).services.rollouts;
       var arg_serviceName = "foo";
       var arg_rolloutId = "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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/rollouts/", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/rollouts/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10),
+            unittest.equals("/rollouts/"));
         pathOffset += 10;
         subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
         pathOffset = path.length;
         unittest.expect(subPart, unittest.equals("$arg_rolloutId"));
 
         var query = (req.url).query;
         var queryOffset = 0;
         var queryMap = {};
         addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
         parseBool(n) {
           if (n == "true") return true;
           if (n == "false") return false;
           if (n == null) return null;
           throw new core.ArgumentError("Invalid boolean: $n");
         }
+
         if (query.length > 0) {
           for (var part in query.split("&")) {
             var keyvalue = part.split("=");
-            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]),
+                core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
 
-
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildRollout());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.get(arg_serviceName, arg_rolloutId).then(unittest.expectAsync1(((api.Rollout response) {
+      res
+          .get(arg_serviceName, arg_rolloutId)
+          .then(unittest.expectAsync1(((api.Rollout response) {
         checkRollout(response);
       })));
     });
 
     unittest.test("method--list", () {
-
       var mock = new HttpServerMock();
-      api.ServicesRolloutsResourceApi res = new api.ServicemanagementApi(mock).services.rollouts;
+      api.ServicesRolloutsResourceApi res =
+          new api.ServicemanagementApi(mock).services.rollouts;
       var arg_serviceName = "foo";
       var arg_filter = "foo";
       var arg_pageToken = "foo";
       var arg_pageSize = 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 + 12), unittest.equals("v1/services/"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12),
+            unittest.equals("v1/services/"));
         pathOffset += 12;
         index = path.indexOf("/rollouts", pathOffset);
         unittest.expect(index >= 0, unittest.isTrue);
-        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        subPart =
+            core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
         pathOffset = index;
         unittest.expect(subPart, unittest.equals("$arg_serviceName"));
-        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/rollouts"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9),
+            unittest.equals("/rollouts"));
         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["filter"].first, unittest.equals(arg_filter));
-        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
-        unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
-
+        unittest.expect(
+            queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(core.int.parse(queryMap["pageSize"].first),
+            unittest.equals(arg_pageSize));
 
         var h = {
-          "content-type" : "application/json; charset=utf-8",
+          "content-type": "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListServiceRolloutsResponse());
         return new async.Future.value(stringResponse(200, h, resp));
       }), true);
-      res.list(arg_serviceName, filter: arg_filter, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync1(((api.ListServiceRolloutsResponse response) {
+      res
+          .list(arg_serviceName,
+              filter: arg_filter,
+              pageToken: arg_pageToken,
+              pageSize: arg_pageSize)
+          .then(unittest
+              .expectAsync1(((api.ListServiceRolloutsResponse response) {
         checkListServiceRolloutsResponse(response);
       })));
     });
-
   });
-
-
 }
-