Roll of googleapis as of 4/7/2015.

generated/googleapis/test/identitytoolkit/v3_test.dart

 library googleapis.identitytoolkit.v3.test;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import 'package:http/http.dart' as http;
 import 'package:http/testing.dart' as http_testing;
 import 'package:unittest/unittest.dart' as unittest;
-import 'package:googleapis/common/common.dart' as common;
-import 'package:googleapis/src/common_internal.dart' as common_internal;
-import '../common/common_internal_test.dart' as common_test;
 
 import 'package:googleapis/identitytoolkit/v3.dart' as api;
 
+class HttpServerMock extends http.BaseClient {
+  core.Function _callback;
+  core.bool _expectJson;
 
+  void register(core.Function callback, core.bool expectJson) {
+    _callback = callback;
+    _expectJson = expectJson;
+  }
+
+  async.Future<http.StreamedResponse> send(http.BaseRequest request) {
+    if (_expectJson) {
+      return request.finalize()
+          .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);
+}
 
 core.int buildCounterCreateAuthUriResponse = 0;
 buildCreateAuthUriResponse() {
   var o = new api.CreateAuthUriResponse();
   buildCounterCreateAuthUriResponse++;
   if (buildCounterCreateAuthUriResponse < 3) {
     o.authUri = "foo";
     o.captchaRequired = true;
     o.forExistingProvider = true;
     o.kind = "foo";
@@ skipping 29 matching lines @@
 }
 
 checkDeleteAccountResponse(api.DeleteAccountResponse o) {
   buildCounterDeleteAccountResponse++;
   if (buildCounterDeleteAccountResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterDeleteAccountResponse--;
 }
 
-buildUnnamed1333() {
+buildUnnamed1152() {
   var o = new core.List<api.UserInfo>();
   o.add(buildUserInfo());
   o.add(buildUserInfo());
   return o;
 }
 
-checkUnnamed1333(core.List<api.UserInfo> o) {
+checkUnnamed1152(core.List<api.UserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUserInfo(o[0]);
   checkUserInfo(o[1]);
 }
 
 core.int buildCounterDownloadAccountResponse = 0;
 buildDownloadAccountResponse() {
   var o = new api.DownloadAccountResponse();
   buildCounterDownloadAccountResponse++;
   if (buildCounterDownloadAccountResponse < 3) {
     o.kind = "foo";
     o.nextPageToken = "foo";
-    o.users = buildUnnamed1333();
+    o.users = buildUnnamed1152();
   }
   buildCounterDownloadAccountResponse--;
   return o;
 }
 
 checkDownloadAccountResponse(api.DownloadAccountResponse o) {
   buildCounterDownloadAccountResponse++;
   if (buildCounterDownloadAccountResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
-    checkUnnamed1333(o.users);
+    checkUnnamed1152(o.users);
   }
   buildCounterDownloadAccountResponse--;
 }
 
-buildUnnamed1334() {
+buildUnnamed1153() {
   var o = new core.List<api.UserInfo>();
   o.add(buildUserInfo());
   o.add(buildUserInfo());
   return o;
 }
 
-checkUnnamed1334(core.List<api.UserInfo> o) {
+checkUnnamed1153(core.List<api.UserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUserInfo(o[0]);
   checkUserInfo(o[1]);
 }
 
 core.int buildCounterGetAccountInfoResponse = 0;
 buildGetAccountInfoResponse() {
   var o = new api.GetAccountInfoResponse();
   buildCounterGetAccountInfoResponse++;
   if (buildCounterGetAccountInfoResponse < 3) {
     o.kind = "foo";
-    o.users = buildUnnamed1334();
+    o.users = buildUnnamed1153();
   }
   buildCounterGetAccountInfoResponse--;
   return o;
 }
 
 checkGetAccountInfoResponse(api.GetAccountInfoResponse o) {
   buildCounterGetAccountInfoResponse++;
   if (buildCounterGetAccountInfoResponse < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed1334(o.users);
+    checkUnnamed1153(o.users);
   }
   buildCounterGetAccountInfoResponse--;
 }
 
 core.int buildCounterGetOobConfirmationCodeResponse = 0;
 buildGetOobConfirmationCodeResponse() {
   var o = new api.GetOobConfirmationCodeResponse();
   buildCounterGetOobConfirmationCodeResponse++;
   if (buildCounterGetOobConfirmationCodeResponse < 3) {
     o.kind = "foo";
@@ skipping 78 matching lines @@
 
 checkIdentitytoolkitRelyingpartyDownloadAccountRequest(api.IdentitytoolkitRelyingpartyDownloadAccountRequest o) {
   buildCounterIdentitytoolkitRelyingpartyDownloadAccountRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyDownloadAccountRequest < 3) {
     unittest.expect(o.maxResults, unittest.equals(42));
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterIdentitytoolkitRelyingpartyDownloadAccountRequest--;
 }
 
-buildUnnamed1335() {
+buildUnnamed1154() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1335(core.List<core.String> o) {
+checkUnnamed1154(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1336() {
+buildUnnamed1155() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1336(core.List<core.String> o) {
+checkUnnamed1155(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 buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest = 0;
 buildIdentitytoolkitRelyingpartyGetAccountInfoRequest() {
   var o = new api.IdentitytoolkitRelyingpartyGetAccountInfoRequest();
   buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest < 3) {
-    o.email = buildUnnamed1335();
+    o.email = buildUnnamed1154();
     o.idToken = "foo";
-    o.localId = buildUnnamed1336();
+    o.localId = buildUnnamed1155();
   }
   buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest--;
   return o;
 }
 
 checkIdentitytoolkitRelyingpartyGetAccountInfoRequest(api.IdentitytoolkitRelyingpartyGetAccountInfoRequest o) {
   buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest < 3) {
-    checkUnnamed1335(o.email);
+    checkUnnamed1154(o.email);
     unittest.expect(o.idToken, unittest.equals('foo'));
-    checkUnnamed1336(o.localId);
+    checkUnnamed1155(o.localId);
   }
   buildCounterIdentitytoolkitRelyingpartyGetAccountInfoRequest--;
 }
 
 buildIdentitytoolkitRelyingpartyGetPublicKeysResponse() {
   var o = new api.IdentitytoolkitRelyingpartyGetPublicKeysResponse();
   o["a"] = "foo";
   o["b"] = "foo";
   return o;
 }
@@ skipping 22 matching lines @@
   buildCounterIdentitytoolkitRelyingpartyResetPasswordRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyResetPasswordRequest < 3) {
     unittest.expect(o.email, unittest.equals('foo'));
     unittest.expect(o.newPassword, unittest.equals('foo'));
     unittest.expect(o.oldPassword, unittest.equals('foo'));
     unittest.expect(o.oobCode, unittest.equals('foo'));
   }
   buildCounterIdentitytoolkitRelyingpartyResetPasswordRequest--;
 }
 
-buildUnnamed1337() {
+buildUnnamed1156() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1337(core.List<core.String> o) {
+checkUnnamed1156(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 buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest = 0;
 buildIdentitytoolkitRelyingpartySetAccountInfoRequest() {
   var o = new api.IdentitytoolkitRelyingpartySetAccountInfoRequest();
   buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest++;
   if (buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest < 3) {
     o.captchaChallenge = "foo";
     o.captchaResponse = "foo";
     o.displayName = "foo";
     o.email = "foo";
     o.emailVerified = true;
     o.idToken = "foo";
     o.localId = "foo";
     o.oobCode = "foo";
     o.password = "foo";
-    o.provider = buildUnnamed1337();
+    o.provider = buildUnnamed1156();
     o.upgradeToFederatedLogin = true;
   }
   buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest--;
   return o;
 }
 
 checkIdentitytoolkitRelyingpartySetAccountInfoRequest(api.IdentitytoolkitRelyingpartySetAccountInfoRequest o) {
   buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest++;
   if (buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest < 3) {
     unittest.expect(o.captchaChallenge, unittest.equals('foo'));
     unittest.expect(o.captchaResponse, unittest.equals('foo'));
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.email, unittest.equals('foo'));
     unittest.expect(o.emailVerified, unittest.isTrue);
     unittest.expect(o.idToken, unittest.equals('foo'));
     unittest.expect(o.localId, unittest.equals('foo'));
     unittest.expect(o.oobCode, unittest.equals('foo'));
     unittest.expect(o.password, unittest.equals('foo'));
-    checkUnnamed1337(o.provider);
+    checkUnnamed1156(o.provider);
     unittest.expect(o.upgradeToFederatedLogin, unittest.isTrue);
   }
   buildCounterIdentitytoolkitRelyingpartySetAccountInfoRequest--;
 }
 
-buildUnnamed1338() {
+buildUnnamed1157() {
   var o = new core.List<api.UserInfo>();
   o.add(buildUserInfo());
   o.add(buildUserInfo());
   return o;
 }
 
-checkUnnamed1338(core.List<api.UserInfo> o) {
+checkUnnamed1157(core.List<api.UserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUserInfo(o[0]);
   checkUserInfo(o[1]);
 }
 
 core.int buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest = 0;
 buildIdentitytoolkitRelyingpartyUploadAccountRequest() {
   var o = new api.IdentitytoolkitRelyingpartyUploadAccountRequest();
   buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest < 3) {
     o.hashAlgorithm = "foo";
     o.memoryCost = 42;
     o.rounds = 42;
     o.saltSeparator = "foo";
     o.signerKey = "foo";
-    o.users = buildUnnamed1338();
+    o.users = buildUnnamed1157();
   }
   buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest--;
   return o;
 }
 
 checkIdentitytoolkitRelyingpartyUploadAccountRequest(api.IdentitytoolkitRelyingpartyUploadAccountRequest o) {
   buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest < 3) {
     unittest.expect(o.hashAlgorithm, unittest.equals('foo'));
     unittest.expect(o.memoryCost, unittest.equals(42));
     unittest.expect(o.rounds, unittest.equals(42));
     unittest.expect(o.saltSeparator, unittest.equals('foo'));
     unittest.expect(o.signerKey, unittest.equals('foo'));
-    checkUnnamed1338(o.users);
+    checkUnnamed1157(o.users);
   }
   buildCounterIdentitytoolkitRelyingpartyUploadAccountRequest--;
 }
 
 core.int buildCounterIdentitytoolkitRelyingpartyVerifyAssertionRequest = 0;
 buildIdentitytoolkitRelyingpartyVerifyAssertionRequest() {
   var o = new api.IdentitytoolkitRelyingpartyVerifyAssertionRequest();
   buildCounterIdentitytoolkitRelyingpartyVerifyAssertionRequest++;
   if (buildCounterIdentitytoolkitRelyingpartyVerifyAssertionRequest < 3) {
     o.pendingIdToken = "foo";
@@ skipping 111 matching lines @@
 checkSetAccountInfoResponseProviderUserInfo(api.SetAccountInfoResponseProviderUserInfo o) {
   buildCounterSetAccountInfoResponseProviderUserInfo++;
   if (buildCounterSetAccountInfoResponseProviderUserInfo < 3) {
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.photoUrl, unittest.equals('foo'));
     unittest.expect(o.providerId, unittest.equals('foo'));
   }
   buildCounterSetAccountInfoResponseProviderUserInfo--;
 }
 
-buildUnnamed1339() {
+buildUnnamed1158() {
   var o = new core.List<api.SetAccountInfoResponseProviderUserInfo>();
   o.add(buildSetAccountInfoResponseProviderUserInfo());
   o.add(buildSetAccountInfoResponseProviderUserInfo());
   return o;
 }
 
-checkUnnamed1339(core.List<api.SetAccountInfoResponseProviderUserInfo> o) {
+checkUnnamed1158(core.List<api.SetAccountInfoResponseProviderUserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSetAccountInfoResponseProviderUserInfo(o[0]);
   checkSetAccountInfoResponseProviderUserInfo(o[1]);
 }
 
 core.int buildCounterSetAccountInfoResponse = 0;
 buildSetAccountInfoResponse() {
   var o = new api.SetAccountInfoResponse();
   buildCounterSetAccountInfoResponse++;
   if (buildCounterSetAccountInfoResponse < 3) {
     o.displayName = "foo";
     o.email = "foo";
     o.idToken = "foo";
     o.kind = "foo";
-    o.providerUserInfo = buildUnnamed1339();
+    o.providerUserInfo = buildUnnamed1158();
   }
   buildCounterSetAccountInfoResponse--;
   return o;
 }
 
 checkSetAccountInfoResponse(api.SetAccountInfoResponse o) {
   buildCounterSetAccountInfoResponse++;
   if (buildCounterSetAccountInfoResponse < 3) {
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.email, unittest.equals('foo'));
     unittest.expect(o.idToken, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
-    checkUnnamed1339(o.providerUserInfo);
+    checkUnnamed1158(o.providerUserInfo);
   }
   buildCounterSetAccountInfoResponse--;
 }
 
 core.int buildCounterUploadAccountResponseError = 0;
 buildUploadAccountResponseError() {
   var o = new api.UploadAccountResponseError();
   buildCounterUploadAccountResponseError++;
   if (buildCounterUploadAccountResponseError < 3) {
     o.index = 42;
     o.message = "foo";
   }
   buildCounterUploadAccountResponseError--;
   return o;
 }
 
 checkUploadAccountResponseError(api.UploadAccountResponseError o) {
   buildCounterUploadAccountResponseError++;
   if (buildCounterUploadAccountResponseError < 3) {
     unittest.expect(o.index, unittest.equals(42));
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterUploadAccountResponseError--;
 }
 
-buildUnnamed1340() {
+buildUnnamed1159() {
   var o = new core.List<api.UploadAccountResponseError>();
   o.add(buildUploadAccountResponseError());
   o.add(buildUploadAccountResponseError());
   return o;
 }
 
-checkUnnamed1340(core.List<api.UploadAccountResponseError> o) {
+checkUnnamed1159(core.List<api.UploadAccountResponseError> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUploadAccountResponseError(o[0]);
   checkUploadAccountResponseError(o[1]);
 }
 
 core.int buildCounterUploadAccountResponse = 0;
 buildUploadAccountResponse() {
   var o = new api.UploadAccountResponse();
   buildCounterUploadAccountResponse++;
   if (buildCounterUploadAccountResponse < 3) {
-    o.error = buildUnnamed1340();
+    o.error = buildUnnamed1159();
     o.kind = "foo";
   }
   buildCounterUploadAccountResponse--;
   return o;
 }
 
 checkUploadAccountResponse(api.UploadAccountResponse o) {
   buildCounterUploadAccountResponse++;
   if (buildCounterUploadAccountResponse < 3) {
-    checkUnnamed1340(o.error);
+    checkUnnamed1159(o.error);
     unittest.expect(o.kind, unittest.equals('foo'));
   }
   buildCounterUploadAccountResponse--;
 }
 
 core.int buildCounterUserInfoProviderUserInfo = 0;
 buildUserInfoProviderUserInfo() {
   var o = new api.UserInfoProviderUserInfo();
   buildCounterUserInfoProviderUserInfo++;
   if (buildCounterUserInfoProviderUserInfo < 3) {
@@ skipping 10 matching lines @@
   buildCounterUserInfoProviderUserInfo++;
   if (buildCounterUserInfoProviderUserInfo < 3) {
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.federatedId, unittest.equals('foo'));
     unittest.expect(o.photoUrl, unittest.equals('foo'));
     unittest.expect(o.providerId, unittest.equals('foo'));
   }
   buildCounterUserInfoProviderUserInfo--;
 }
 
-buildUnnamed1341() {
+buildUnnamed1160() {
   var o = new core.List<api.UserInfoProviderUserInfo>();
   o.add(buildUserInfoProviderUserInfo());
   o.add(buildUserInfoProviderUserInfo());
   return o;
 }
 
-checkUnnamed1341(core.List<api.UserInfoProviderUserInfo> o) {
+checkUnnamed1160(core.List<api.UserInfoProviderUserInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkUserInfoProviderUserInfo(o[0]);
   checkUserInfoProviderUserInfo(o[1]);
 }
 
 core.int buildCounterUserInfo = 0;
 buildUserInfo() {
   var o = new api.UserInfo();
   buildCounterUserInfo++;
   if (buildCounterUserInfo < 3) {
     o.displayName = "foo";
     o.email = "foo";
     o.emailVerified = true;
     o.localId = "foo";
     o.passwordHash = "foo";
     o.passwordUpdatedAt = 42.0;
     o.photoUrl = "foo";
-    o.providerUserInfo = buildUnnamed1341();
+    o.providerUserInfo = buildUnnamed1160();
     o.salt = "foo";
     o.version = 42;
   }
   buildCounterUserInfo--;
   return o;
 }
 
 checkUserInfo(api.UserInfo o) {
   buildCounterUserInfo++;
   if (buildCounterUserInfo < 3) {
     unittest.expect(o.displayName, unittest.equals('foo'));
     unittest.expect(o.email, unittest.equals('foo'));
     unittest.expect(o.emailVerified, unittest.isTrue);
     unittest.expect(o.localId, unittest.equals('foo'));
     unittest.expect(o.passwordHash, unittest.equals('foo'));
     unittest.expect(o.passwordUpdatedAt, unittest.equals(42.0));
     unittest.expect(o.photoUrl, unittest.equals('foo'));
-    checkUnnamed1341(o.providerUserInfo);
+    checkUnnamed1160(o.providerUserInfo);
     unittest.expect(o.salt, unittest.equals('foo'));
     unittest.expect(o.version, unittest.equals(42));
   }
   buildCounterUserInfo--;
 }
 
-buildUnnamed1342() {
+buildUnnamed1161() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1342(core.List<core.String> o) {
+checkUnnamed1161(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 buildCounterVerifyAssertionResponse = 0;
 buildVerifyAssertionResponse() {
   var o = new api.VerifyAssertionResponse();
   buildCounterVerifyAssertionResponse++;
   if (buildCounterVerifyAssertionResponse < 3) {
@@ skipping 16 matching lines @@
     o.lastName = "foo";
     o.localId = "foo";
     o.needConfirmation = true;
     o.nickName = "foo";
     o.oauthRequestToken = "foo";
     o.oauthScope = "foo";
     o.originalEmail = "foo";
     o.photoUrl = "foo";
     o.providerId = "foo";
     o.timeZone = "foo";
-    o.verifiedProvider = buildUnnamed1342();
+    o.verifiedProvider = buildUnnamed1161();
   }
   buildCounterVerifyAssertionResponse--;
   return o;
 }
 
 checkVerifyAssertionResponse(api.VerifyAssertionResponse o) {
   buildCounterVerifyAssertionResponse++;
   if (buildCounterVerifyAssertionResponse < 3) {
     unittest.expect(o.action, unittest.equals('foo'));
     unittest.expect(o.appInstallationUrl, unittest.equals('foo'));
@@ skipping 14 matching lines @@
     unittest.expect(o.lastName, unittest.equals('foo'));
     unittest.expect(o.localId, unittest.equals('foo'));
     unittest.expect(o.needConfirmation, unittest.isTrue);
     unittest.expect(o.nickName, unittest.equals('foo'));
     unittest.expect(o.oauthRequestToken, unittest.equals('foo'));
     unittest.expect(o.oauthScope, unittest.equals('foo'));
     unittest.expect(o.originalEmail, unittest.equals('foo'));
     unittest.expect(o.photoUrl, unittest.equals('foo'));
     unittest.expect(o.providerId, unittest.equals('foo'));
     unittest.expect(o.timeZone, unittest.equals('foo'));
-    checkUnnamed1342(o.verifiedProvider);
+    checkUnnamed1161(o.verifiedProvider);
   }
   buildCounterVerifyAssertionResponse--;
 }
 
 core.int buildCounterVerifyPasswordResponse = 0;
 buildVerifyPasswordResponse() {
   var o = new api.VerifyPasswordResponse();
   buildCounterVerifyPasswordResponse++;
   if (buildCounterVerifyPasswordResponse < 3) {
     o.displayName = "foo";
@@ skipping 245 matching lines @@
       var o = buildVerifyPasswordResponse();
       var od = new api.VerifyPasswordResponse.fromJson(o.toJson());
       checkVerifyPasswordResponse(od);
     });
   });
 
 
   unittest.group("resource-RelyingpartyResourceApi", () {
     unittest.test("method--createAuthUri", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyCreateAuthUriRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyCreateAuthUriRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyCreateAuthUriRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildCreateAuthUriResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.createAuthUri(arg_request).then(unittest.expectAsync(((api.CreateAuthUriResponse response) {
         checkCreateAuthUriResponse(response);
       })));
     });
 
     unittest.test("method--deleteAccount", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyDeleteAccountRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyDeleteAccountRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyDeleteAccountRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildDeleteAccountResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.deleteAccount(arg_request).then(unittest.expectAsync(((api.DeleteAccountResponse response) {
         checkDeleteAccountResponse(response);
       })));
     });
 
     unittest.test("method--downloadAccount", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyDownloadAccountRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyDownloadAccountRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyDownloadAccountRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildDownloadAccountResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.downloadAccount(arg_request).then(unittest.expectAsync(((api.DownloadAccountResponse response) {
         checkDownloadAccountResponse(response);
       })));
     });
 
     unittest.test("method--getAccountInfo", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyGetAccountInfoRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyGetAccountInfoRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyGetAccountInfoRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildGetAccountInfoResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getAccountInfo(arg_request).then(unittest.expectAsync(((api.GetAccountInfoResponse response) {
         checkGetAccountInfoResponse(response);
       })));
     });
 
     unittest.test("method--getOobConfirmationCode", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildRelyingparty();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Relyingparty.fromJson(json);
         checkRelyingparty(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildGetOobConfirmationCodeResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getOobConfirmationCode(arg_request).then(unittest.expectAsync(((api.GetOobConfirmationCodeResponse response) {
         checkGetOobConfirmationCodeResponse(response);
       })));
     });
 
     unittest.test("method--getPublicKeys", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       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 + 32), unittest.equals("identitytoolkit/v3/relyingparty/"));
         pathOffset += 32;
@@ skipping 15 matching lines @@
             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(buildIdentitytoolkitRelyingpartyGetPublicKeysResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getPublicKeys().then(unittest.expectAsync(((api.IdentitytoolkitRelyingpartyGetPublicKeysResponse response) {
         checkIdentitytoolkitRelyingpartyGetPublicKeysResponse(response);
       })));
     });
 
     unittest.test("method--resetPassword", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyResetPasswordRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyResetPasswordRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyResetPasswordRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildResetPasswordResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.resetPassword(arg_request).then(unittest.expectAsync(((api.ResetPasswordResponse response) {
         checkResetPasswordResponse(response);
       })));
     });
 
     unittest.test("method--setAccountInfo", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartySetAccountInfoRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartySetAccountInfoRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartySetAccountInfoRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildSetAccountInfoResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.setAccountInfo(arg_request).then(unittest.expectAsync(((api.SetAccountInfoResponse response) {
         checkSetAccountInfoResponse(response);
       })));
     });
 
     unittest.test("method--uploadAccount", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyUploadAccountRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyUploadAccountRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyUploadAccountRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildUploadAccountResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.uploadAccount(arg_request).then(unittest.expectAsync(((api.UploadAccountResponse response) {
         checkUploadAccountResponse(response);
       })));
     });
 
     unittest.test("method--verifyAssertion", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyVerifyAssertionRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyVerifyAssertionRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyVerifyAssertionRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildVerifyAssertionResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.verifyAssertion(arg_request).then(unittest.expectAsync(((api.VerifyAssertionResponse response) {
         checkVerifyAssertionResponse(response);
       })));
     });
 
     unittest.test("method--verifyPassword", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.RelyingpartyResourceApi res = new api.IdentitytoolkitApi(mock).relyingparty;
       var arg_request = buildIdentitytoolkitRelyingpartyVerifyPasswordRequest();
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.IdentitytoolkitRelyingpartyVerifyPasswordRequest.fromJson(json);
         checkIdentitytoolkitRelyingpartyVerifyPasswordRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 19 matching lines @@
             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(buildVerifyPasswordResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.verifyPassword(arg_request).then(unittest.expectAsync(((api.VerifyPasswordResponse response) {
         checkVerifyPasswordResponse(response);
       })));
     });
 
   });
 
 
 }