Roll of googleapis as of 4/7/2015.

generated/googleapis/test/androidenterprise/v1_test.dart

Index: generated/googleapis/test/androidenterprise/v1_test.dart
diff --git a/generated/googleapis/test/androidenterprise/v1_test.dart b/generated/googleapis/test/androidenterprise/v1_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..e387c2b824c81cfd3e6c0c13485454ffc39f1247
--- /dev/null
+++ b/generated/googleapis/test/androidenterprise/v1_test.dart
@@ -0,0 +1,3826 @@
+library googleapis.androidenterprise.v1.test;
+
+import "dart:core" as core;
+import "dart:collection" as collection;
+import "dart:async" as async;
+import "dart:convert" as convert;
+
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart' as http_testing;
+import 'package:unittest/unittest.dart' as unittest;
+
+import 'package:googleapis/androidenterprise/v1.dart' as api;
+
+class HttpServerMock extends http.BaseClient {
+  core.Function _callback;
+  core.bool _expectJson;
+
+  void register(core.Function callback, core.bool expectJson) {
+    _callback = callback;
+    _expectJson = expectJson;
+  }
+
+  async.Future<http.StreamedResponse> send(http.BaseRequest request) {
+    if (_expectJson) {
+      return request.finalize()
+          .transform(convert.UTF8.decoder)
+          .join('')
+          .then((core.String jsonString) {
+        if (jsonString.isEmpty) {
+          return _callback(request, null);
+        } else {
+          return _callback(request, convert.JSON.decode(jsonString));
+        }
+      });
+    } else {
+      var stream = request.finalize();
+      if (stream == null) {
+        return _callback(request, []);
+      } else {
+        return stream.toBytes().then((data) {
+          return _callback(request, data);
+        });
+      }
+    }
+  }
+}
+
+http.StreamedResponse stringResponse(
+    core.int status, core.Map headers, core.String body) {
+  var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
+  return new http.StreamedResponse(stream, status, headers: headers);
+}
+
+buildUnnamed243() {
+  var o = new core.List<api.AppRestrictionsSchemaRestriction>();
+  o.add(buildAppRestrictionsSchemaRestriction());
+  o.add(buildAppRestrictionsSchemaRestriction());
+  return o;
+}
+
+checkUnnamed243(core.List<api.AppRestrictionsSchemaRestriction> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkAppRestrictionsSchemaRestriction(o[0]);
+  checkAppRestrictionsSchemaRestriction(o[1]);
+}
+
+core.int buildCounterAppRestrictionsSchema = 0;
+buildAppRestrictionsSchema() {
+  var o = new api.AppRestrictionsSchema();
+  buildCounterAppRestrictionsSchema++;
+  if (buildCounterAppRestrictionsSchema < 3) {
+    o.restrictions = buildUnnamed243();
+  }
+  buildCounterAppRestrictionsSchema--;
+  return o;
+}
+
+checkAppRestrictionsSchema(api.AppRestrictionsSchema o) {
+  buildCounterAppRestrictionsSchema++;
+  if (buildCounterAppRestrictionsSchema < 3) {
+    checkUnnamed243(o.restrictions);
+  }
+  buildCounterAppRestrictionsSchema--;
+}
+
+buildUnnamed244() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed244(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'));
+}
+
+buildUnnamed245() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed245(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 buildCounterAppRestrictionsSchemaRestriction = 0;
+buildAppRestrictionsSchemaRestriction() {
+  var o = new api.AppRestrictionsSchemaRestriction();
+  buildCounterAppRestrictionsSchemaRestriction++;
+  if (buildCounterAppRestrictionsSchemaRestriction < 3) {
+    o.defaultValue = buildAppRestrictionsSchemaRestrictionRestrictionValue();
+    o.description = "foo";
+    o.entry = buildUnnamed244();
+    o.entryValue = buildUnnamed245();
+    o.key = "foo";
+    o.restrictionType = "foo";
+    o.title = "foo";
+  }
+  buildCounterAppRestrictionsSchemaRestriction--;
+  return o;
+}
+
+checkAppRestrictionsSchemaRestriction(api.AppRestrictionsSchemaRestriction o) {
+  buildCounterAppRestrictionsSchemaRestriction++;
+  if (buildCounterAppRestrictionsSchemaRestriction < 3) {
+    checkAppRestrictionsSchemaRestrictionRestrictionValue(o.defaultValue);
+    unittest.expect(o.description, unittest.equals('foo'));
+    checkUnnamed244(o.entry);
+    checkUnnamed245(o.entryValue);
+    unittest.expect(o.key, unittest.equals('foo'));
+    unittest.expect(o.restrictionType, unittest.equals('foo'));
+    unittest.expect(o.title, unittest.equals('foo'));
+  }
+  buildCounterAppRestrictionsSchemaRestriction--;
+}
+
+buildUnnamed246() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed246(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 buildCounterAppRestrictionsSchemaRestrictionRestrictionValue = 0;
+buildAppRestrictionsSchemaRestrictionRestrictionValue() {
+  var o = new api.AppRestrictionsSchemaRestrictionRestrictionValue();
+  buildCounterAppRestrictionsSchemaRestrictionRestrictionValue++;
+  if (buildCounterAppRestrictionsSchemaRestrictionRestrictionValue < 3) {
+    o.type = "foo";
+    o.valueBool = true;
+    o.valueInteger = 42;
+    o.valueMultiselect = buildUnnamed246();
+    o.valueString = "foo";
+  }
+  buildCounterAppRestrictionsSchemaRestrictionRestrictionValue--;
+  return o;
+}
+
+checkAppRestrictionsSchemaRestrictionRestrictionValue(api.AppRestrictionsSchemaRestrictionRestrictionValue o) {
+  buildCounterAppRestrictionsSchemaRestrictionRestrictionValue++;
+  if (buildCounterAppRestrictionsSchemaRestrictionRestrictionValue < 3) {
+    unittest.expect(o.type, unittest.equals('foo'));
+    unittest.expect(o.valueBool, unittest.isTrue);
+    unittest.expect(o.valueInteger, unittest.equals(42));
+    checkUnnamed246(o.valueMultiselect);
+    unittest.expect(o.valueString, unittest.equals('foo'));
+  }
+  buildCounterAppRestrictionsSchemaRestrictionRestrictionValue--;
+}
+
+buildUnnamed247() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed247(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 buildCounterCollection = 0;
+buildCollection() {
+  var o = new api.Collection();
+  buildCounterCollection++;
+  if (buildCounterCollection < 3) {
+    o.collectionId = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.productId = buildUnnamed247();
+    o.visibility = "foo";
+  }
+  buildCounterCollection--;
+  return o;
+}
+
+checkCollection(api.Collection o) {
+  buildCounterCollection++;
+  if (buildCounterCollection < 3) {
+    unittest.expect(o.collectionId, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    checkUnnamed247(o.productId);
+    unittest.expect(o.visibility, unittest.equals('foo'));
+  }
+  buildCounterCollection--;
+}
+
+buildUnnamed248() {
+  var o = new core.List<api.User>();
+  o.add(buildUser());
+  o.add(buildUser());
+  return o;
+}
+
+checkUnnamed248(core.List<api.User> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUser(o[0]);
+  checkUser(o[1]);
+}
+
+core.int buildCounterCollectionViewersListResponse = 0;
+buildCollectionViewersListResponse() {
+  var o = new api.CollectionViewersListResponse();
+  buildCounterCollectionViewersListResponse++;
+  if (buildCounterCollectionViewersListResponse < 3) {
+    o.kind = "foo";
+    o.user = buildUnnamed248();
+  }
+  buildCounterCollectionViewersListResponse--;
+  return o;
+}
+
+checkCollectionViewersListResponse(api.CollectionViewersListResponse o) {
+  buildCounterCollectionViewersListResponse++;
+  if (buildCounterCollectionViewersListResponse < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed248(o.user);
+  }
+  buildCounterCollectionViewersListResponse--;
+}
+
+buildUnnamed249() {
+  var o = new core.List<api.Collection>();
+  o.add(buildCollection());
+  o.add(buildCollection());
+  return o;
+}
+
+checkUnnamed249(core.List<api.Collection> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkCollection(o[0]);
+  checkCollection(o[1]);
+}
+
+core.int buildCounterCollectionsListResponse = 0;
+buildCollectionsListResponse() {
+  var o = new api.CollectionsListResponse();
+  buildCounterCollectionsListResponse++;
+  if (buildCounterCollectionsListResponse < 3) {
+    o.collection = buildUnnamed249();
+    o.kind = "foo";
+  }
+  buildCounterCollectionsListResponse--;
+  return o;
+}
+
+checkCollectionsListResponse(api.CollectionsListResponse o) {
+  buildCounterCollectionsListResponse++;
+  if (buildCounterCollectionsListResponse < 3) {
+    checkUnnamed249(o.collection);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterCollectionsListResponse--;
+}
+
+core.int buildCounterDevice = 0;
+buildDevice() {
+  var o = new api.Device();
+  buildCounterDevice++;
+  if (buildCounterDevice < 3) {
+    o.androidId = "foo";
+    o.kind = "foo";
+  }
+  buildCounterDevice--;
+  return o;
+}
+
+checkDevice(api.Device o) {
+  buildCounterDevice++;
+  if (buildCounterDevice < 3) {
+    unittest.expect(o.androidId, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterDevice--;
+}
+
+core.int buildCounterDeviceState = 0;
+buildDeviceState() {
+  var o = new api.DeviceState();
+  buildCounterDeviceState++;
+  if (buildCounterDeviceState < 3) {
+    o.accountState = "foo";
+    o.kind = "foo";
+  }
+  buildCounterDeviceState--;
+  return o;
+}
+
+checkDeviceState(api.DeviceState o) {
+  buildCounterDeviceState++;
+  if (buildCounterDeviceState < 3) {
+    unittest.expect(o.accountState, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterDeviceState--;
+}
+
+buildUnnamed250() {
+  var o = new core.List<api.Device>();
+  o.add(buildDevice());
+  o.add(buildDevice());
+  return o;
+}
+
+checkUnnamed250(core.List<api.Device> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDevice(o[0]);
+  checkDevice(o[1]);
+}
+
+core.int buildCounterDevicesListResponse = 0;
+buildDevicesListResponse() {
+  var o = new api.DevicesListResponse();
+  buildCounterDevicesListResponse++;
+  if (buildCounterDevicesListResponse < 3) {
+    o.device = buildUnnamed250();
+    o.kind = "foo";
+  }
+  buildCounterDevicesListResponse--;
+  return o;
+}
+
+checkDevicesListResponse(api.DevicesListResponse o) {
+  buildCounterDevicesListResponse++;
+  if (buildCounterDevicesListResponse < 3) {
+    checkUnnamed250(o.device);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterDevicesListResponse--;
+}
+
+core.int buildCounterEnterprise = 0;
+buildEnterprise() {
+  var o = new api.Enterprise();
+  buildCounterEnterprise++;
+  if (buildCounterEnterprise < 3) {
+    o.id = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.primaryDomain = "foo";
+  }
+  buildCounterEnterprise--;
+  return o;
+}
+
+checkEnterprise(api.Enterprise o) {
+  buildCounterEnterprise++;
+  if (buildCounterEnterprise < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.primaryDomain, unittest.equals('foo'));
+  }
+  buildCounterEnterprise--;
+}
+
+core.int buildCounterEnterpriseAccount = 0;
+buildEnterpriseAccount() {
+  var o = new api.EnterpriseAccount();
+  buildCounterEnterpriseAccount++;
+  if (buildCounterEnterpriseAccount < 3) {
+    o.accountEmail = "foo";
+    o.kind = "foo";
+  }
+  buildCounterEnterpriseAccount--;
+  return o;
+}
+
+checkEnterpriseAccount(api.EnterpriseAccount o) {
+  buildCounterEnterpriseAccount++;
+  if (buildCounterEnterpriseAccount < 3) {
+    unittest.expect(o.accountEmail, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterEnterpriseAccount--;
+}
+
+buildUnnamed251() {
+  var o = new core.List<api.Enterprise>();
+  o.add(buildEnterprise());
+  o.add(buildEnterprise());
+  return o;
+}
+
+checkUnnamed251(core.List<api.Enterprise> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkEnterprise(o[0]);
+  checkEnterprise(o[1]);
+}
+
+core.int buildCounterEnterprisesListResponse = 0;
+buildEnterprisesListResponse() {
+  var o = new api.EnterprisesListResponse();
+  buildCounterEnterprisesListResponse++;
+  if (buildCounterEnterprisesListResponse < 3) {
+    o.enterprise = buildUnnamed251();
+    o.kind = "foo";
+  }
+  buildCounterEnterprisesListResponse--;
+  return o;
+}
+
+checkEnterprisesListResponse(api.EnterprisesListResponse o) {
+  buildCounterEnterprisesListResponse++;
+  if (buildCounterEnterprisesListResponse < 3) {
+    checkUnnamed251(o.enterprise);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterEnterprisesListResponse--;
+}
+
+core.int buildCounterEntitlement = 0;
+buildEntitlement() {
+  var o = new api.Entitlement();
+  buildCounterEntitlement++;
+  if (buildCounterEntitlement < 3) {
+    o.kind = "foo";
+    o.productId = "foo";
+    o.reason = "foo";
+  }
+  buildCounterEntitlement--;
+  return o;
+}
+
+checkEntitlement(api.Entitlement o) {
+  buildCounterEntitlement++;
+  if (buildCounterEntitlement < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+    unittest.expect(o.reason, unittest.equals('foo'));
+  }
+  buildCounterEntitlement--;
+}
+
+buildUnnamed252() {
+  var o = new core.List<api.Entitlement>();
+  o.add(buildEntitlement());
+  o.add(buildEntitlement());
+  return o;
+}
+
+checkUnnamed252(core.List<api.Entitlement> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkEntitlement(o[0]);
+  checkEntitlement(o[1]);
+}
+
+core.int buildCounterEntitlementsListResponse = 0;
+buildEntitlementsListResponse() {
+  var o = new api.EntitlementsListResponse();
+  buildCounterEntitlementsListResponse++;
+  if (buildCounterEntitlementsListResponse < 3) {
+    o.entitlement = buildUnnamed252();
+    o.kind = "foo";
+  }
+  buildCounterEntitlementsListResponse--;
+  return o;
+}
+
+checkEntitlementsListResponse(api.EntitlementsListResponse o) {
+  buildCounterEntitlementsListResponse++;
+  if (buildCounterEntitlementsListResponse < 3) {
+    checkUnnamed252(o.entitlement);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterEntitlementsListResponse--;
+}
+
+core.int buildCounterGroupLicense = 0;
+buildGroupLicense() {
+  var o = new api.GroupLicense();
+  buildCounterGroupLicense++;
+  if (buildCounterGroupLicense < 3) {
+    o.acquisitionKind = "foo";
+    o.approval = "foo";
+    o.kind = "foo";
+    o.numProvisioned = 42;
+    o.numPurchased = 42;
+    o.productId = "foo";
+  }
+  buildCounterGroupLicense--;
+  return o;
+}
+
+checkGroupLicense(api.GroupLicense o) {
+  buildCounterGroupLicense++;
+  if (buildCounterGroupLicense < 3) {
+    unittest.expect(o.acquisitionKind, unittest.equals('foo'));
+    unittest.expect(o.approval, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.numProvisioned, unittest.equals(42));
+    unittest.expect(o.numPurchased, unittest.equals(42));
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterGroupLicense--;
+}
+
+buildUnnamed253() {
+  var o = new core.List<api.User>();
+  o.add(buildUser());
+  o.add(buildUser());
+  return o;
+}
+
+checkUnnamed253(core.List<api.User> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUser(o[0]);
+  checkUser(o[1]);
+}
+
+core.int buildCounterGroupLicenseUsersListResponse = 0;
+buildGroupLicenseUsersListResponse() {
+  var o = new api.GroupLicenseUsersListResponse();
+  buildCounterGroupLicenseUsersListResponse++;
+  if (buildCounterGroupLicenseUsersListResponse < 3) {
+    o.kind = "foo";
+    o.user = buildUnnamed253();
+  }
+  buildCounterGroupLicenseUsersListResponse--;
+  return o;
+}
+
+checkGroupLicenseUsersListResponse(api.GroupLicenseUsersListResponse o) {
+  buildCounterGroupLicenseUsersListResponse++;
+  if (buildCounterGroupLicenseUsersListResponse < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed253(o.user);
+  }
+  buildCounterGroupLicenseUsersListResponse--;
+}
+
+buildUnnamed254() {
+  var o = new core.List<api.GroupLicense>();
+  o.add(buildGroupLicense());
+  o.add(buildGroupLicense());
+  return o;
+}
+
+checkUnnamed254(core.List<api.GroupLicense> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkGroupLicense(o[0]);
+  checkGroupLicense(o[1]);
+}
+
+core.int buildCounterGroupLicensesListResponse = 0;
+buildGroupLicensesListResponse() {
+  var o = new api.GroupLicensesListResponse();
+  buildCounterGroupLicensesListResponse++;
+  if (buildCounterGroupLicensesListResponse < 3) {
+    o.groupLicense = buildUnnamed254();
+    o.kind = "foo";
+  }
+  buildCounterGroupLicensesListResponse--;
+  return o;
+}
+
+checkGroupLicensesListResponse(api.GroupLicensesListResponse o) {
+  buildCounterGroupLicensesListResponse++;
+  if (buildCounterGroupLicensesListResponse < 3) {
+    checkUnnamed254(o.groupLicense);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterGroupLicensesListResponse--;
+}
+
+core.int buildCounterInstall = 0;
+buildInstall() {
+  var o = new api.Install();
+  buildCounterInstall++;
+  if (buildCounterInstall < 3) {
+    o.installState = "foo";
+    o.kind = "foo";
+    o.productId = "foo";
+    o.versionCode = 42;
+  }
+  buildCounterInstall--;
+  return o;
+}
+
+checkInstall(api.Install o) {
+  buildCounterInstall++;
+  if (buildCounterInstall < 3) {
+    unittest.expect(o.installState, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+    unittest.expect(o.versionCode, unittest.equals(42));
+  }
+  buildCounterInstall--;
+}
+
+buildUnnamed255() {
+  var o = new core.List<api.Install>();
+  o.add(buildInstall());
+  o.add(buildInstall());
+  return o;
+}
+
+checkUnnamed255(core.List<api.Install> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkInstall(o[0]);
+  checkInstall(o[1]);
+}
+
+core.int buildCounterInstallsListResponse = 0;
+buildInstallsListResponse() {
+  var o = new api.InstallsListResponse();
+  buildCounterInstallsListResponse++;
+  if (buildCounterInstallsListResponse < 3) {
+    o.install = buildUnnamed255();
+    o.kind = "foo";
+  }
+  buildCounterInstallsListResponse--;
+  return o;
+}
+
+checkInstallsListResponse(api.InstallsListResponse o) {
+  buildCounterInstallsListResponse++;
+  if (buildCounterInstallsListResponse < 3) {
+    checkUnnamed255(o.install);
+    unittest.expect(o.kind, unittest.equals('foo'));
+  }
+  buildCounterInstallsListResponse--;
+}
+
+core.int buildCounterPermission = 0;
+buildPermission() {
+  var o = new api.Permission();
+  buildCounterPermission++;
+  if (buildCounterPermission < 3) {
+    o.description = "foo";
+    o.kind = "foo";
+    o.name = "foo";
+    o.permissionId = "foo";
+  }
+  buildCounterPermission--;
+  return o;
+}
+
+checkPermission(api.Permission o) {
+  buildCounterPermission++;
+  if (buildCounterPermission < 3) {
+    unittest.expect(o.description, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.permissionId, unittest.equals('foo'));
+  }
+  buildCounterPermission--;
+}
+
+core.int buildCounterProduct = 0;
+buildProduct() {
+  var o = new api.Product();
+  buildCounterProduct++;
+  if (buildCounterProduct < 3) {
+    o.authorName = "foo";
+    o.detailsUrl = "foo";
+    o.iconUrl = "foo";
+    o.kind = "foo";
+    o.productId = "foo";
+    o.title = "foo";
+    o.workDetailsUrl = "foo";
+  }
+  buildCounterProduct--;
+  return o;
+}
+
+checkProduct(api.Product o) {
+  buildCounterProduct++;
+  if (buildCounterProduct < 3) {
+    unittest.expect(o.authorName, unittest.equals('foo'));
+    unittest.expect(o.detailsUrl, unittest.equals('foo'));
+    unittest.expect(o.iconUrl, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.productId, unittest.equals('foo'));
+    unittest.expect(o.title, unittest.equals('foo'));
+    unittest.expect(o.workDetailsUrl, unittest.equals('foo'));
+  }
+  buildCounterProduct--;
+}
+
+core.int buildCounterProductPermission = 0;
+buildProductPermission() {
+  var o = new api.ProductPermission();
+  buildCounterProductPermission++;
+  if (buildCounterProductPermission < 3) {
+    o.permissionId = "foo";
+    o.state = "foo";
+  }
+  buildCounterProductPermission--;
+  return o;
+}
+
+checkProductPermission(api.ProductPermission o) {
+  buildCounterProductPermission++;
+  if (buildCounterProductPermission < 3) {
+    unittest.expect(o.permissionId, unittest.equals('foo'));
+    unittest.expect(o.state, unittest.equals('foo'));
+  }
+  buildCounterProductPermission--;
+}
+
+buildUnnamed256() {
+  var o = new core.List<api.ProductPermission>();
+  o.add(buildProductPermission());
+  o.add(buildProductPermission());
+  return o;
+}
+
+checkUnnamed256(core.List<api.ProductPermission> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkProductPermission(o[0]);
+  checkProductPermission(o[1]);
+}
+
+core.int buildCounterProductPermissions = 0;
+buildProductPermissions() {
+  var o = new api.ProductPermissions();
+  buildCounterProductPermissions++;
+  if (buildCounterProductPermissions < 3) {
+    o.kind = "foo";
+    o.permission = buildUnnamed256();
+    o.productId = "foo";
+  }
+  buildCounterProductPermissions--;
+  return o;
+}
+
+checkProductPermissions(api.ProductPermissions o) {
+  buildCounterProductPermissions++;
+  if (buildCounterProductPermissions < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed256(o.permission);
+    unittest.expect(o.productId, unittest.equals('foo'));
+  }
+  buildCounterProductPermissions--;
+}
+
+core.int buildCounterUser = 0;
+buildUser() {
+  var o = new api.User();
+  buildCounterUser++;
+  if (buildCounterUser < 3) {
+    o.id = "foo";
+    o.kind = "foo";
+    o.primaryEmail = "foo";
+  }
+  buildCounterUser--;
+  return o;
+}
+
+checkUser(api.User o) {
+  buildCounterUser++;
+  if (buildCounterUser < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.primaryEmail, unittest.equals('foo'));
+  }
+  buildCounterUser--;
+}
+
+core.int buildCounterUserToken = 0;
+buildUserToken() {
+  var o = new api.UserToken();
+  buildCounterUserToken++;
+  if (buildCounterUserToken < 3) {
+    o.kind = "foo";
+    o.token = "foo";
+    o.userId = "foo";
+  }
+  buildCounterUserToken--;
+  return o;
+}
+
+checkUserToken(api.UserToken o) {
+  buildCounterUserToken++;
+  if (buildCounterUserToken < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    unittest.expect(o.token, unittest.equals('foo'));
+    unittest.expect(o.userId, unittest.equals('foo'));
+  }
+  buildCounterUserToken--;
+}
+
+buildUnnamed257() {
+  var o = new core.List<api.User>();
+  o.add(buildUser());
+  o.add(buildUser());
+  return o;
+}
+
+checkUnnamed257(core.List<api.User> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkUser(o[0]);
+  checkUser(o[1]);
+}
+
+core.int buildCounterUsersListResponse = 0;
+buildUsersListResponse() {
+  var o = new api.UsersListResponse();
+  buildCounterUsersListResponse++;
+  if (buildCounterUsersListResponse < 3) {
+    o.kind = "foo";
+    o.user = buildUnnamed257();
+  }
+  buildCounterUsersListResponse--;
+  return o;
+}
+
+checkUsersListResponse(api.UsersListResponse o) {
+  buildCounterUsersListResponse++;
+  if (buildCounterUsersListResponse < 3) {
+    unittest.expect(o.kind, unittest.equals('foo'));
+    checkUnnamed257(o.user);
+  }
+  buildCounterUsersListResponse--;
+}
+
+
+main() {
+  unittest.group("obj-schema-AppRestrictionsSchema", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAppRestrictionsSchema();
+      var od = new api.AppRestrictionsSchema.fromJson(o.toJson());
+      checkAppRestrictionsSchema(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AppRestrictionsSchemaRestriction", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAppRestrictionsSchemaRestriction();
+      var od = new api.AppRestrictionsSchemaRestriction.fromJson(o.toJson());
+      checkAppRestrictionsSchemaRestriction(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-AppRestrictionsSchemaRestrictionRestrictionValue", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildAppRestrictionsSchemaRestrictionRestrictionValue();
+      var od = new api.AppRestrictionsSchemaRestrictionRestrictionValue.fromJson(o.toJson());
+      checkAppRestrictionsSchemaRestrictionRestrictionValue(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Collection", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCollection();
+      var od = new api.Collection.fromJson(o.toJson());
+      checkCollection(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-CollectionViewersListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCollectionViewersListResponse();
+      var od = new api.CollectionViewersListResponse.fromJson(o.toJson());
+      checkCollectionViewersListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-CollectionsListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildCollectionsListResponse();
+      var od = new api.CollectionsListResponse.fromJson(o.toJson());
+      checkCollectionsListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Device", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDevice();
+      var od = new api.Device.fromJson(o.toJson());
+      checkDevice(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DeviceState", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDeviceState();
+      var od = new api.DeviceState.fromJson(o.toJson());
+      checkDeviceState(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-DevicesListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDevicesListResponse();
+      var od = new api.DevicesListResponse.fromJson(o.toJson());
+      checkDevicesListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Enterprise", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildEnterprise();
+      var od = new api.Enterprise.fromJson(o.toJson());
+      checkEnterprise(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-EnterpriseAccount", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildEnterpriseAccount();
+      var od = new api.EnterpriseAccount.fromJson(o.toJson());
+      checkEnterpriseAccount(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-EnterprisesListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildEnterprisesListResponse();
+      var od = new api.EnterprisesListResponse.fromJson(o.toJson());
+      checkEnterprisesListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Entitlement", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildEntitlement();
+      var od = new api.Entitlement.fromJson(o.toJson());
+      checkEntitlement(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-EntitlementsListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildEntitlementsListResponse();
+      var od = new api.EntitlementsListResponse.fromJson(o.toJson());
+      checkEntitlementsListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-GroupLicense", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGroupLicense();
+      var od = new api.GroupLicense.fromJson(o.toJson());
+      checkGroupLicense(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-GroupLicenseUsersListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGroupLicenseUsersListResponse();
+      var od = new api.GroupLicenseUsersListResponse.fromJson(o.toJson());
+      checkGroupLicenseUsersListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-GroupLicensesListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildGroupLicensesListResponse();
+      var od = new api.GroupLicensesListResponse.fromJson(o.toJson());
+      checkGroupLicensesListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Install", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstall();
+      var od = new api.Install.fromJson(o.toJson());
+      checkInstall(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-InstallsListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildInstallsListResponse();
+      var od = new api.InstallsListResponse.fromJson(o.toJson());
+      checkInstallsListResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Permission", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildPermission();
+      var od = new api.Permission.fromJson(o.toJson());
+      checkPermission(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Product", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProduct();
+      var od = new api.Product.fromJson(o.toJson());
+      checkProduct(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ProductPermission", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProductPermission();
+      var od = new api.ProductPermission.fromJson(o.toJson());
+      checkProductPermission(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ProductPermissions", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildProductPermissions();
+      var od = new api.ProductPermissions.fromJson(o.toJson());
+      checkProductPermissions(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-User", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUser();
+      var od = new api.User.fromJson(o.toJson());
+      checkUser(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UserToken", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUserToken();
+      var od = new api.UserToken.fromJson(o.toJson());
+      checkUserToken(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-UsersListResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildUsersListResponse();
+      var od = new api.UsersListResponse.fromJson(o.toJson());
+      checkUsersListResponse(od);
+    });
+  });
+
+
+  unittest.group("resource-CollectionsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_collectionId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollection());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_collectionId).then(unittest.expectAsync(((api.Collection response) {
+        checkCollection(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_request = buildCollection();
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Collection.fromJson(json);
+        checkCollection(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/collections"));
+        pathOffset += 12;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollection());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.insert(arg_request, arg_enterpriseId).then(unittest.expectAsync(((api.Collection response) {
+        checkCollection(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/collections"));
+        pathOffset += 12;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollectionsListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId).then(unittest.expectAsync(((api.CollectionsListResponse response) {
+        checkCollectionsListResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_request = buildCollection();
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Collection.fromJson(json);
+        checkCollection(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollection());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_enterpriseId, arg_collectionId).then(unittest.expectAsync(((api.Collection response) {
+        checkCollection(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionsResourceApi res = new api.AndroidenterpriseApi(mock).collections;
+      var arg_request = buildCollection();
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Collection.fromJson(json);
+        checkCollection(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollection());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_enterpriseId, arg_collectionId).then(unittest.expectAsync(((api.Collection response) {
+        checkCollection(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-CollectionviewersResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionviewersResourceApi res = new api.AndroidenterpriseApi(mock).collectionviewers;
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_collectionId, arg_userId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionviewersResourceApi res = new api.AndroidenterpriseApi(mock).collectionviewers;
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_collectionId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionviewersResourceApi res = new api.AndroidenterpriseApi(mock).collectionviewers;
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        index = path.indexOf("/users", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/users"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildCollectionViewersListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_collectionId).then(unittest.expectAsync(((api.CollectionViewersListResponse response) {
+        checkCollectionViewersListResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionviewersResourceApi res = new api.AndroidenterpriseApi(mock).collectionviewers;
+      var arg_request = buildUser();
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.User.fromJson(json);
+        checkUser(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_enterpriseId, arg_collectionId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.CollectionviewersResourceApi res = new api.AndroidenterpriseApi(mock).collectionviewers;
+      var arg_request = buildUser();
+      var arg_enterpriseId = "foo";
+      var arg_collectionId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.User.fromJson(json);
+        checkUser(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/collections/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/collections/"));
+        pathOffset += 13;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_collectionId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_enterpriseId, arg_collectionId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-DevicesResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.DevicesResourceApi res = new api.AndroidenterpriseApi(mock).devices;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDevice());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_userId, arg_deviceId).then(unittest.expectAsync(((api.Device response) {
+        checkDevice(response);
+      })));
+    });
+
+    unittest.test("method--getState", () {
+
+      var mock = new HttpServerMock();
+      api.DevicesResourceApi res = new api.AndroidenterpriseApi(mock).devices;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/state", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/state"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDeviceState());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.getState(arg_enterpriseId, arg_userId, arg_deviceId).then(unittest.expectAsync(((api.DeviceState response) {
+        checkDeviceState(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.DevicesResourceApi res = new api.AndroidenterpriseApi(mock).devices;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/devices"));
+        pathOffset += 8;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDevicesListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.DevicesListResponse response) {
+        checkDevicesListResponse(response);
+      })));
+    });
+
+    unittest.test("method--setState", () {
+
+      var mock = new HttpServerMock();
+      api.DevicesResourceApi res = new api.AndroidenterpriseApi(mock).devices;
+      var arg_request = buildDeviceState();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.DeviceState.fromJson(json);
+        checkDeviceState(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/state", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/state"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDeviceState());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.setState(arg_request, arg_enterpriseId, arg_userId, arg_deviceId).then(unittest.expectAsync(((api.DeviceState response) {
+        checkDeviceState(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-EnterprisesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--enroll", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_request = buildEnterprise();
+      var arg_token = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Enterprise.fromJson(json);
+        checkEnterprise(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 18), unittest.equals("enterprises/enroll"));
+        pathOffset += 18;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["token"].first, unittest.equals(arg_token));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterprise());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.enroll(arg_request, arg_token).then(unittest.expectAsync(((api.Enterprise response) {
+        checkEnterprise(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterprise());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId).then(unittest.expectAsync(((api.Enterprise response) {
+        checkEnterprise(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_request = buildEnterprise();
+      var arg_token = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Enterprise.fromJson(json);
+        checkEnterprise(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("enterprises"));
+        pathOffset += 11;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["token"].first, unittest.equals(arg_token));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterprise());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.insert(arg_request, arg_token).then(unittest.expectAsync(((api.Enterprise response) {
+        checkEnterprise(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_domain = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.equals("enterprises"));
+        pathOffset += 11;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["domain"].first, unittest.equals(arg_domain));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterprisesListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_domain).then(unittest.expectAsync(((api.EnterprisesListResponse response) {
+        checkEnterprisesListResponse(response);
+      })));
+    });
+
+    unittest.test("method--setAccount", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_request = buildEnterpriseAccount();
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.EnterpriseAccount.fromJson(json);
+        checkEnterpriseAccount(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/account", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/account"));
+        pathOffset += 8;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEnterpriseAccount());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.setAccount(arg_request, arg_enterpriseId).then(unittest.expectAsync(((api.EnterpriseAccount response) {
+        checkEnterpriseAccount(response);
+      })));
+    });
+
+    unittest.test("method--unenroll", () {
+
+      var mock = new HttpServerMock();
+      api.EnterprisesResourceApi res = new api.AndroidenterpriseApi(mock).enterprises;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/unenroll", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/unenroll"));
+        pathOffset += 9;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.unenroll(arg_enterpriseId).then(unittest.expectAsync((_) {}));
+    });
+
+  });
+
+
+  unittest.group("resource-EntitlementsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.EntitlementsResourceApi res = new api.AndroidenterpriseApi(mock).entitlements;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_entitlementId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/entitlements/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/entitlements/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_entitlementId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_userId, arg_entitlementId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.EntitlementsResourceApi res = new api.AndroidenterpriseApi(mock).entitlements;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_entitlementId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/entitlements/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/entitlements/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_entitlementId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEntitlement());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_userId, arg_entitlementId).then(unittest.expectAsync(((api.Entitlement response) {
+        checkEntitlement(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.EntitlementsResourceApi res = new api.AndroidenterpriseApi(mock).entitlements;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/entitlements", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/entitlements"));
+        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]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEntitlementsListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.EntitlementsListResponse response) {
+        checkEntitlementsListResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.EntitlementsResourceApi res = new api.AndroidenterpriseApi(mock).entitlements;
+      var arg_request = buildEntitlement();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_entitlementId = "foo";
+      var arg_install = true;
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Entitlement.fromJson(json);
+        checkEntitlement(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/entitlements/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/entitlements/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_entitlementId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["install"].first, unittest.equals("$arg_install"));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEntitlement());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_enterpriseId, arg_userId, arg_entitlementId, install: arg_install).then(unittest.expectAsync(((api.Entitlement response) {
+        checkEntitlement(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.EntitlementsResourceApi res = new api.AndroidenterpriseApi(mock).entitlements;
+      var arg_request = buildEntitlement();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_entitlementId = "foo";
+      var arg_install = true;
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Entitlement.fromJson(json);
+        checkEntitlement(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/entitlements/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/entitlements/"));
+        pathOffset += 14;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_entitlementId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["install"].first, unittest.equals("$arg_install"));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildEntitlement());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_enterpriseId, arg_userId, arg_entitlementId, install: arg_install).then(unittest.expectAsync(((api.Entitlement response) {
+        checkEntitlement(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-GrouplicensesResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.GrouplicensesResourceApi res = new api.AndroidenterpriseApi(mock).grouplicenses;
+      var arg_enterpriseId = "foo";
+      var arg_groupLicenseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/groupLicenses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/groupLicenses/"));
+        pathOffset += 15;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_groupLicenseId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildGroupLicense());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_groupLicenseId).then(unittest.expectAsync(((api.GroupLicense response) {
+        checkGroupLicense(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.GrouplicensesResourceApi res = new api.AndroidenterpriseApi(mock).grouplicenses;
+      var arg_enterpriseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/groupLicenses", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.equals("/groupLicenses"));
+        pathOffset += 14;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildGroupLicensesListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId).then(unittest.expectAsync(((api.GroupLicensesListResponse response) {
+        checkGroupLicensesListResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-GrouplicenseusersResourceApi", () {
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.GrouplicenseusersResourceApi res = new api.AndroidenterpriseApi(mock).grouplicenseusers;
+      var arg_enterpriseId = "foo";
+      var arg_groupLicenseId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/groupLicenses/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.equals("/groupLicenses/"));
+        pathOffset += 15;
+        index = path.indexOf("/users", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_groupLicenseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/users"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildGroupLicenseUsersListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_groupLicenseId).then(unittest.expectAsync(((api.GroupLicenseUsersListResponse response) {
+        checkGroupLicenseUsersListResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-InstallsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new HttpServerMock();
+      api.InstallsResourceApi res = new api.AndroidenterpriseApi(mock).installs;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      var arg_installId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/installs/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/installs/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_installId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_enterpriseId, arg_userId, arg_deviceId, arg_installId).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.InstallsResourceApi res = new api.AndroidenterpriseApi(mock).installs;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      var arg_installId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/installs/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/installs/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_installId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildInstall());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_userId, arg_deviceId, arg_installId).then(unittest.expectAsync(((api.Install response) {
+        checkInstall(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.InstallsResourceApi res = new api.AndroidenterpriseApi(mock).installs;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/installs", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/installs"));
+        pathOffset += 9;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildInstallsListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_userId, arg_deviceId).then(unittest.expectAsync(((api.InstallsListResponse response) {
+        checkInstallsListResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new HttpServerMock();
+      api.InstallsResourceApi res = new api.AndroidenterpriseApi(mock).installs;
+      var arg_request = buildInstall();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      var arg_installId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Install.fromJson(json);
+        checkInstall(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/installs/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/installs/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_installId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildInstall());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_enterpriseId, arg_userId, arg_deviceId, arg_installId).then(unittest.expectAsync(((api.Install response) {
+        checkInstall(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new HttpServerMock();
+      api.InstallsResourceApi res = new api.AndroidenterpriseApi(mock).installs;
+      var arg_request = buildInstall();
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      var arg_deviceId = "foo";
+      var arg_installId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Install.fromJson(json);
+        checkInstall(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/devices/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equals("/devices/"));
+        pathOffset += 9;
+        index = path.indexOf("/installs/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_deviceId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/installs/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_installId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildInstall());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_enterpriseId, arg_userId, arg_deviceId, arg_installId).then(unittest.expectAsync(((api.Install response) {
+        checkInstall(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-PermissionsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.PermissionsResourceApi res = new api.AndroidenterpriseApi(mock).permissions;
+      var arg_permissionId = "foo";
+      var arg_language = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("permissions/"));
+        pathOffset += 12;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_permissionId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["language"].first, unittest.equals(arg_language));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildPermission());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_permissionId, language: arg_language).then(unittest.expectAsync(((api.Permission response) {
+        checkPermission(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-ProductsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
+      var arg_enterpriseId = "foo";
+      var arg_productId = "foo";
+      var arg_language = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/products/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_productId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["language"].first, unittest.equals(arg_language));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildProduct());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_productId, language: arg_language).then(unittest.expectAsync(((api.Product response) {
+        checkProduct(response);
+      })));
+    });
+
+    unittest.test("method--getAppRestrictionsSchema", () {
+
+      var mock = new HttpServerMock();
+      api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
+      var arg_enterpriseId = "foo";
+      var arg_productId = "foo";
+      var arg_language = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/products/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
+        pathOffset += 10;
+        index = path.indexOf("/appRestrictionsSchema", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_productId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 22), unittest.equals("/appRestrictionsSchema"));
+        pathOffset += 22;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["language"].first, unittest.equals(arg_language));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildAppRestrictionsSchema());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.getAppRestrictionsSchema(arg_enterpriseId, arg_productId, language: arg_language).then(unittest.expectAsync(((api.AppRestrictionsSchema response) {
+        checkAppRestrictionsSchema(response);
+      })));
+    });
+
+    unittest.test("method--getPermissions", () {
+
+      var mock = new HttpServerMock();
+      api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
+      var arg_enterpriseId = "foo";
+      var arg_productId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/products/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
+        pathOffset += 10;
+        index = path.indexOf("/permissions", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_productId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/permissions"));
+        pathOffset += 12;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildProductPermissions());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.getPermissions(arg_enterpriseId, arg_productId).then(unittest.expectAsync(((api.ProductPermissions response) {
+        checkProductPermissions(response);
+      })));
+    });
+
+    unittest.test("method--updatePermissions", () {
+
+      var mock = new HttpServerMock();
+      api.ProductsResourceApi res = new api.AndroidenterpriseApi(mock).products;
+      var arg_request = buildProductPermissions();
+      var arg_enterpriseId = "foo";
+      var arg_productId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ProductPermissions.fromJson(json);
+        checkProductPermissions(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/products/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.equals("/products/"));
+        pathOffset += 10;
+        index = path.indexOf("/permissions", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_productId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("/permissions"));
+        pathOffset += 12;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildProductPermissions());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.updatePermissions(arg_request, arg_enterpriseId, arg_productId).then(unittest.expectAsync(((api.ProductPermissions response) {
+        checkProductPermissions(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersResourceApi", () {
+    unittest.test("method--generateToken", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/token", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/token"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUserToken());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.generateToken(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.UserToken response) {
+        checkUserToken(response);
+      })));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUser());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_enterpriseId, arg_userId).then(unittest.expectAsync(((api.User response) {
+        checkUser(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_email = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/users"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["email"].first, unittest.equals(arg_email));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildUsersListResponse());
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_enterpriseId, arg_email).then(unittest.expectAsync(((api.UsersListResponse response) {
+        checkUsersListResponse(response);
+      })));
+    });
+
+    unittest.test("method--revokeToken", () {
+
+      var mock = new HttpServerMock();
+      api.UsersResourceApi res = new api.AndroidenterpriseApi(mock).users;
+      var arg_enterpriseId = "foo";
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
+        pathOffset += 1;
+        unittest.expect(path.substring(pathOffset, pathOffset + 21), unittest.equals("androidenterprise/v1/"));
+        pathOffset += 21;
+        unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.equals("enterprises/"));
+        pathOffset += 12;
+        index = path.indexOf("/users/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_enterpriseId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/users/"));
+        pathOffset += 7;
+        index = path.indexOf("/token", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_userId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/token"));
+        pathOffset += 6;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(stringResponse(200, h, resp));
+      }), true);
+      res.revokeToken(arg_enterpriseId, arg_userId).then(unittest.expectAsync((_) {}));
+    });
+
+  });
+
+
+}
+