Generate 0.1.0 version of googleapis/googleapis_beta

generated/googleapis/test/gmail/v1.dart

Index: generated/googleapis/test/gmail/v1.dart
diff --git a/generated/googleapis/test/gmail/v1.dart b/generated/googleapis/test/gmail/v1.dart
new file mode 100644
index 0000000000000000000000000000000000000000..fccf9032ba5ba93770ece06e2436dd1e3650b35a
--- /dev/null
+++ b/generated/googleapis/test/gmail/v1.dart
@@ -0,0 +1,2370 @@
+library googleapis.gmail.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/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/gmail/v1.dart' as api;
+
+
+
+core.int buildCounterDraft = 0;
+buildDraft() {
+  var o = new api.Draft();
+  buildCounterDraft++;
+  if (buildCounterDraft < 3) {
+    o.id = "foo";
+    o.message = buildMessage();
+  }
+  buildCounterDraft--;
+  return o;
+}
+
+checkDraft(api.Draft o) {
+  buildCounterDraft++;
+  if (buildCounterDraft < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkMessage(o.message);
+  }
+  buildCounterDraft--;
+}
+
+buildUnnamed187() {
+  var o = new core.List<api.Message>();
+  o.add(buildMessage());
+  o.add(buildMessage());
+  return o;
+}
+
+checkUnnamed187(core.List<api.Message> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMessage(o[0]);
+  checkMessage(o[1]);
+}
+
+core.int buildCounterHistory = 0;
+buildHistory() {
+  var o = new api.History();
+  buildCounterHistory++;
+  if (buildCounterHistory < 3) {
+    o.id = "foo";
+    o.messages = buildUnnamed187();
+  }
+  buildCounterHistory--;
+  return o;
+}
+
+checkHistory(api.History o) {
+  buildCounterHistory++;
+  if (buildCounterHistory < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed187(o.messages);
+  }
+  buildCounterHistory--;
+}
+
+core.int buildCounterLabel = 0;
+buildLabel() {
+  var o = new api.Label();
+  buildCounterLabel++;
+  if (buildCounterLabel < 3) {
+    o.id = "foo";
+    o.labelListVisibility = "foo";
+    o.messageListVisibility = "foo";
+    o.name = "foo";
+    o.type = "foo";
+  }
+  buildCounterLabel--;
+  return o;
+}
+
+checkLabel(api.Label o) {
+  buildCounterLabel++;
+  if (buildCounterLabel < 3) {
+    unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.labelListVisibility, unittest.equals('foo'));
+    unittest.expect(o.messageListVisibility, unittest.equals('foo'));
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.type, unittest.equals('foo'));
+  }
+  buildCounterLabel--;
+}
+
+buildUnnamed188() {
+  var o = new core.List<api.Draft>();
+  o.add(buildDraft());
+  o.add(buildDraft());
+  return o;
+}
+
+checkUnnamed188(core.List<api.Draft> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDraft(o[0]);
+  checkDraft(o[1]);
+}
+
+core.int buildCounterListDraftsResponse = 0;
+buildListDraftsResponse() {
+  var o = new api.ListDraftsResponse();
+  buildCounterListDraftsResponse++;
+  if (buildCounterListDraftsResponse < 3) {
+    o.drafts = buildUnnamed188();
+    o.nextPageToken = "foo";
+    o.resultSizeEstimate = 42;
+  }
+  buildCounterListDraftsResponse--;
+  return o;
+}
+
+checkListDraftsResponse(api.ListDraftsResponse o) {
+  buildCounterListDraftsResponse++;
+  if (buildCounterListDraftsResponse < 3) {
+    checkUnnamed188(o.drafts);
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.resultSizeEstimate, unittest.equals(42));
+  }
+  buildCounterListDraftsResponse--;
+}
+
+buildUnnamed189() {
+  var o = new core.List<api.History>();
+  o.add(buildHistory());
+  o.add(buildHistory());
+  return o;
+}
+
+checkUnnamed189(core.List<api.History> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkHistory(o[0]);
+  checkHistory(o[1]);
+}
+
+core.int buildCounterListHistoryResponse = 0;
+buildListHistoryResponse() {
+  var o = new api.ListHistoryResponse();
+  buildCounterListHistoryResponse++;
+  if (buildCounterListHistoryResponse < 3) {
+    o.history = buildUnnamed189();
+    o.historyId = "foo";
+    o.nextPageToken = "foo";
+  }
+  buildCounterListHistoryResponse--;
+  return o;
+}
+
+checkListHistoryResponse(api.ListHistoryResponse o) {
+  buildCounterListHistoryResponse++;
+  if (buildCounterListHistoryResponse < 3) {
+    checkUnnamed189(o.history);
+    unittest.expect(o.historyId, unittest.equals('foo'));
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+  }
+  buildCounterListHistoryResponse--;
+}
+
+buildUnnamed190() {
+  var o = new core.List<api.Label>();
+  o.add(buildLabel());
+  o.add(buildLabel());
+  return o;
+}
+
+checkUnnamed190(core.List<api.Label> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkLabel(o[0]);
+  checkLabel(o[1]);
+}
+
+core.int buildCounterListLabelsResponse = 0;
+buildListLabelsResponse() {
+  var o = new api.ListLabelsResponse();
+  buildCounterListLabelsResponse++;
+  if (buildCounterListLabelsResponse < 3) {
+    o.labels = buildUnnamed190();
+  }
+  buildCounterListLabelsResponse--;
+  return o;
+}
+
+checkListLabelsResponse(api.ListLabelsResponse o) {
+  buildCounterListLabelsResponse++;
+  if (buildCounterListLabelsResponse < 3) {
+    checkUnnamed190(o.labels);
+  }
+  buildCounterListLabelsResponse--;
+}
+
+buildUnnamed191() {
+  var o = new core.List<api.Message>();
+  o.add(buildMessage());
+  o.add(buildMessage());
+  return o;
+}
+
+checkUnnamed191(core.List<api.Message> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMessage(o[0]);
+  checkMessage(o[1]);
+}
+
+core.int buildCounterListMessagesResponse = 0;
+buildListMessagesResponse() {
+  var o = new api.ListMessagesResponse();
+  buildCounterListMessagesResponse++;
+  if (buildCounterListMessagesResponse < 3) {
+    o.messages = buildUnnamed191();
+    o.nextPageToken = "foo";
+    o.resultSizeEstimate = 42;
+  }
+  buildCounterListMessagesResponse--;
+  return o;
+}
+
+checkListMessagesResponse(api.ListMessagesResponse o) {
+  buildCounterListMessagesResponse++;
+  if (buildCounterListMessagesResponse < 3) {
+    checkUnnamed191(o.messages);
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.resultSizeEstimate, unittest.equals(42));
+  }
+  buildCounterListMessagesResponse--;
+}
+
+buildUnnamed192() {
+  var o = new core.List<api.Thread>();
+  o.add(buildThread());
+  o.add(buildThread());
+  return o;
+}
+
+checkUnnamed192(core.List<api.Thread> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkThread(o[0]);
+  checkThread(o[1]);
+}
+
+core.int buildCounterListThreadsResponse = 0;
+buildListThreadsResponse() {
+  var o = new api.ListThreadsResponse();
+  buildCounterListThreadsResponse++;
+  if (buildCounterListThreadsResponse < 3) {
+    o.nextPageToken = "foo";
+    o.resultSizeEstimate = 42;
+    o.threads = buildUnnamed192();
+  }
+  buildCounterListThreadsResponse--;
+  return o;
+}
+
+checkListThreadsResponse(api.ListThreadsResponse o) {
+  buildCounterListThreadsResponse++;
+  if (buildCounterListThreadsResponse < 3) {
+    unittest.expect(o.nextPageToken, unittest.equals('foo'));
+    unittest.expect(o.resultSizeEstimate, unittest.equals(42));
+    checkUnnamed192(o.threads);
+  }
+  buildCounterListThreadsResponse--;
+}
+
+buildUnnamed193() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed193(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 buildCounterMessage = 0;
+buildMessage() {
+  var o = new api.Message();
+  buildCounterMessage++;
+  if (buildCounterMessage < 3) {
+    o.historyId = "foo";
+    o.id = "foo";
+    o.labelIds = buildUnnamed193();
+    o.payload = buildMessagePart();
+    o.raw = "foo";
+    o.sizeEstimate = 42;
+    o.snippet = "foo";
+    o.threadId = "foo";
+  }
+  buildCounterMessage--;
+  return o;
+}
+
+checkMessage(api.Message o) {
+  buildCounterMessage++;
+  if (buildCounterMessage < 3) {
+    unittest.expect(o.historyId, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed193(o.labelIds);
+    checkMessagePart(o.payload);
+    unittest.expect(o.raw, unittest.equals('foo'));
+    unittest.expect(o.sizeEstimate, unittest.equals(42));
+    unittest.expect(o.snippet, unittest.equals('foo'));
+    unittest.expect(o.threadId, unittest.equals('foo'));
+  }
+  buildCounterMessage--;
+}
+
+buildUnnamed194() {
+  var o = new core.List<api.MessagePartHeader>();
+  o.add(buildMessagePartHeader());
+  o.add(buildMessagePartHeader());
+  return o;
+}
+
+checkUnnamed194(core.List<api.MessagePartHeader> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMessagePartHeader(o[0]);
+  checkMessagePartHeader(o[1]);
+}
+
+buildUnnamed195() {
+  var o = new core.List<api.MessagePart>();
+  o.add(buildMessagePart());
+  o.add(buildMessagePart());
+  return o;
+}
+
+checkUnnamed195(core.List<api.MessagePart> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMessagePart(o[0]);
+  checkMessagePart(o[1]);
+}
+
+core.int buildCounterMessagePart = 0;
+buildMessagePart() {
+  var o = new api.MessagePart();
+  buildCounterMessagePart++;
+  if (buildCounterMessagePart < 3) {
+    o.body = buildMessagePartBody();
+    o.filename = "foo";
+    o.headers = buildUnnamed194();
+    o.mimeType = "foo";
+    o.partId = "foo";
+    o.parts = buildUnnamed195();
+  }
+  buildCounterMessagePart--;
+  return o;
+}
+
+checkMessagePart(api.MessagePart o) {
+  buildCounterMessagePart++;
+  if (buildCounterMessagePart < 3) {
+    checkMessagePartBody(o.body);
+    unittest.expect(o.filename, unittest.equals('foo'));
+    checkUnnamed194(o.headers);
+    unittest.expect(o.mimeType, unittest.equals('foo'));
+    unittest.expect(o.partId, unittest.equals('foo'));
+    checkUnnamed195(o.parts);
+  }
+  buildCounterMessagePart--;
+}
+
+core.int buildCounterMessagePartBody = 0;
+buildMessagePartBody() {
+  var o = new api.MessagePartBody();
+  buildCounterMessagePartBody++;
+  if (buildCounterMessagePartBody < 3) {
+    o.attachmentId = "foo";
+    o.data = "foo";
+    o.size = 42;
+  }
+  buildCounterMessagePartBody--;
+  return o;
+}
+
+checkMessagePartBody(api.MessagePartBody o) {
+  buildCounterMessagePartBody++;
+  if (buildCounterMessagePartBody < 3) {
+    unittest.expect(o.attachmentId, unittest.equals('foo'));
+    unittest.expect(o.data, unittest.equals('foo'));
+    unittest.expect(o.size, unittest.equals(42));
+  }
+  buildCounterMessagePartBody--;
+}
+
+core.int buildCounterMessagePartHeader = 0;
+buildMessagePartHeader() {
+  var o = new api.MessagePartHeader();
+  buildCounterMessagePartHeader++;
+  if (buildCounterMessagePartHeader < 3) {
+    o.name = "foo";
+    o.value = "foo";
+  }
+  buildCounterMessagePartHeader--;
+  return o;
+}
+
+checkMessagePartHeader(api.MessagePartHeader o) {
+  buildCounterMessagePartHeader++;
+  if (buildCounterMessagePartHeader < 3) {
+    unittest.expect(o.name, unittest.equals('foo'));
+    unittest.expect(o.value, unittest.equals('foo'));
+  }
+  buildCounterMessagePartHeader--;
+}
+
+buildUnnamed196() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed196(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'));
+}
+
+buildUnnamed197() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed197(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 buildCounterModifyMessageRequest = 0;
+buildModifyMessageRequest() {
+  var o = new api.ModifyMessageRequest();
+  buildCounterModifyMessageRequest++;
+  if (buildCounterModifyMessageRequest < 3) {
+    o.addLabelIds = buildUnnamed196();
+    o.removeLabelIds = buildUnnamed197();
+  }
+  buildCounterModifyMessageRequest--;
+  return o;
+}
+
+checkModifyMessageRequest(api.ModifyMessageRequest o) {
+  buildCounterModifyMessageRequest++;
+  if (buildCounterModifyMessageRequest < 3) {
+    checkUnnamed196(o.addLabelIds);
+    checkUnnamed197(o.removeLabelIds);
+  }
+  buildCounterModifyMessageRequest--;
+}
+
+buildUnnamed198() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed198(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'));
+}
+
+buildUnnamed199() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed199(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 buildCounterModifyThreadRequest = 0;
+buildModifyThreadRequest() {
+  var o = new api.ModifyThreadRequest();
+  buildCounterModifyThreadRequest++;
+  if (buildCounterModifyThreadRequest < 3) {
+    o.addLabelIds = buildUnnamed198();
+    o.removeLabelIds = buildUnnamed199();
+  }
+  buildCounterModifyThreadRequest--;
+  return o;
+}
+
+checkModifyThreadRequest(api.ModifyThreadRequest o) {
+  buildCounterModifyThreadRequest++;
+  if (buildCounterModifyThreadRequest < 3) {
+    checkUnnamed198(o.addLabelIds);
+    checkUnnamed199(o.removeLabelIds);
+  }
+  buildCounterModifyThreadRequest--;
+}
+
+buildUnnamed200() {
+  var o = new core.List<api.Message>();
+  o.add(buildMessage());
+  o.add(buildMessage());
+  return o;
+}
+
+checkUnnamed200(core.List<api.Message> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMessage(o[0]);
+  checkMessage(o[1]);
+}
+
+core.int buildCounterThread = 0;
+buildThread() {
+  var o = new api.Thread();
+  buildCounterThread++;
+  if (buildCounterThread < 3) {
+    o.historyId = "foo";
+    o.id = "foo";
+    o.messages = buildUnnamed200();
+    o.snippet = "foo";
+  }
+  buildCounterThread--;
+  return o;
+}
+
+checkThread(api.Thread o) {
+  buildCounterThread++;
+  if (buildCounterThread < 3) {
+    unittest.expect(o.historyId, unittest.equals('foo'));
+    unittest.expect(o.id, unittest.equals('foo'));
+    checkUnnamed200(o.messages);
+    unittest.expect(o.snippet, unittest.equals('foo'));
+  }
+  buildCounterThread--;
+}
+
+buildUnnamed201() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed201(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'));
+}
+
+buildUnnamed202() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed202(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'));
+}
+
+buildUnnamed203() {
+  var o = new core.List<core.String>();
+  o.add("foo");
+  o.add("foo");
+  return o;
+}
+
+checkUnnamed203(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'));
+}
+
+
+main() {
+  unittest.group("obj-schema-Draft", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDraft();
+      var od = new api.Draft.fromJson(o.toJson());
+      checkDraft(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-History", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildHistory();
+      var od = new api.History.fromJson(o.toJson());
+      checkHistory(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Label", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildLabel();
+      var od = new api.Label.fromJson(o.toJson());
+      checkLabel(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListDraftsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListDraftsResponse();
+      var od = new api.ListDraftsResponse.fromJson(o.toJson());
+      checkListDraftsResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListHistoryResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListHistoryResponse();
+      var od = new api.ListHistoryResponse.fromJson(o.toJson());
+      checkListHistoryResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListLabelsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListLabelsResponse();
+      var od = new api.ListLabelsResponse.fromJson(o.toJson());
+      checkListLabelsResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListMessagesResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListMessagesResponse();
+      var od = new api.ListMessagesResponse.fromJson(o.toJson());
+      checkListMessagesResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ListThreadsResponse", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildListThreadsResponse();
+      var od = new api.ListThreadsResponse.fromJson(o.toJson());
+      checkListThreadsResponse(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Message", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMessage();
+      var od = new api.Message.fromJson(o.toJson());
+      checkMessage(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MessagePart", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMessagePart();
+      var od = new api.MessagePart.fromJson(o.toJson());
+      checkMessagePart(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MessagePartBody", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMessagePartBody();
+      var od = new api.MessagePartBody.fromJson(o.toJson());
+      checkMessagePartBody(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-MessagePartHeader", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMessagePartHeader();
+      var od = new api.MessagePartHeader.fromJson(o.toJson());
+      checkMessagePartHeader(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ModifyMessageRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildModifyMessageRequest();
+      var od = new api.ModifyMessageRequest.fromJson(o.toJson());
+      checkModifyMessageRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-ModifyThreadRequest", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildModifyThreadRequest();
+      var od = new api.ModifyThreadRequest.fromJson(o.toJson());
+      checkModifyThreadRequest(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-Thread", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildThread();
+      var od = new api.Thread.fromJson(o.toJson());
+      checkThread(od);
+    });
+  });
+
+
+  unittest.group("resource-UsersDraftsResourceApi", () {
+    unittest.test("method--create", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_request = buildDraft();
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Draft.fromJson(json);
+        checkDraft(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts", 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 + 7), unittest.equals("/drafts"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDraft());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.create(arg_request, arg_userId).then(unittest.expectAsync(((api.Draft response) {
+        checkDraft(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts/", 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("/drafts/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      var arg_format = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts/", 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("/drafts/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["format"].first, unittest.equals(arg_format));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDraft());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_userId, arg_id, format: arg_format).then(unittest.expectAsync(((api.Draft response) {
+        checkDraft(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_userId = "foo";
+      var arg_maxResults = 42;
+      var arg_pageToken = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts", 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 + 7), unittest.equals("/drafts"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListDraftsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_userId, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.ListDraftsResponse response) {
+        checkListDraftsResponse(response);
+      })));
+    });
+
+    unittest.test("method--send", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_request = buildDraft();
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Draft.fromJson(json);
+        checkDraft(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts/send", 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 + 12), unittest.equals("/drafts/send"));
+        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(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.send(arg_request, arg_userId).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersDraftsResourceApi res = new api.GmailApi(mock).users.drafts;
+      var arg_request = buildDraft();
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Draft.fromJson(json);
+        checkDraft(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/drafts/", 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("/drafts/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildDraft());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api.Draft response) {
+        checkDraft(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersHistoryResourceApi", () {
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersHistoryResourceApi res = new api.GmailApi(mock).users.history;
+      var arg_userId = "foo";
+      var arg_labelId = "foo";
+      var arg_maxResults = 42;
+      var arg_pageToken = "foo";
+      var arg_startHistoryId = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/history", 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("/history"));
+        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]));
+          }
+        }
+        unittest.expect(queryMap["labelId"].first, unittest.equals(arg_labelId));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["startHistoryId"].first, unittest.equals(arg_startHistoryId));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListHistoryResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_userId, labelId: arg_labelId, maxResults: arg_maxResults, pageToken: arg_pageToken, startHistoryId: arg_startHistoryId).then(unittest.expectAsync(((api.ListHistoryResponse response) {
+        checkListHistoryResponse(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersLabelsResourceApi", () {
+    unittest.test("method--create", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      var arg_request = buildLabel();
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Label.fromJson(json);
+        checkLabel(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels", 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 + 7), unittest.equals("/labels"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildLabel());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.create(arg_request, arg_userId).then(unittest.expectAsync(((api.Label response) {
+        checkLabel(response);
+      })));
+    });
+
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels/", 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("/labels/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels/", 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("/labels/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildLabel());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_userId, arg_id).then(unittest.expectAsync(((api.Label response) {
+        checkLabel(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels", 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 + 7), unittest.equals("/labels"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListLabelsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_userId).then(unittest.expectAsync(((api.ListLabelsResponse response) {
+        checkListLabelsResponse(response);
+      })));
+    });
+
+    unittest.test("method--patch", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      var arg_request = buildLabel();
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Label.fromJson(json);
+        checkLabel(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels/", 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("/labels/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildLabel());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.patch(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api.Label response) {
+        checkLabel(response);
+      })));
+    });
+
+    unittest.test("method--update", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersLabelsResourceApi res = new api.GmailApi(mock).users.labels;
+      var arg_request = buildLabel();
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Label.fromJson(json);
+        checkLabel(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/labels/", 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("/labels/"));
+        pathOffset += 8;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildLabel());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.update(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api.Label response) {
+        checkLabel(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersMessagesResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      var arg_format = "foo";
+      var arg_metadataHeaders = buildUnnamed201();
+      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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["format"].first, unittest.equals(arg_format));
+        unittest.expect(queryMap["metadataHeaders"], unittest.equals(arg_metadataHeaders));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_userId, arg_id, format: arg_format, metadataHeaders: arg_metadataHeaders).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--import", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_request = buildMessage();
+      var arg_userId = "foo";
+      var arg_internalDateSource = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Message.fromJson(json);
+        checkMessage(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/import", 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 + 16), unittest.equals("/messages/import"));
+        pathOffset += 16;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+        unittest.expect(queryMap["internalDateSource"].first, unittest.equals(arg_internalDateSource));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.import(arg_request, arg_userId, internalDateSource: arg_internalDateSource).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--insert", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_request = buildMessage();
+      var arg_userId = "foo";
+      var arg_internalDateSource = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Message.fromJson(json);
+        checkMessage(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages", 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("/messages"));
+        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]));
+          }
+        }
+        unittest.expect(queryMap["internalDateSource"].first, unittest.equals(arg_internalDateSource));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.insert(arg_request, arg_userId, internalDateSource: arg_internalDateSource).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_userId = "foo";
+      var arg_includeSpamTrash = true;
+      var arg_labelIds = buildUnnamed202();
+      var arg_maxResults = 42;
+      var arg_pageToken = "foo";
+      var arg_q = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages", 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("/messages"));
+        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]));
+          }
+        }
+        unittest.expect(queryMap["includeSpamTrash"].first, unittest.equals("$arg_includeSpamTrash"));
+        unittest.expect(queryMap["labelIds"], unittest.equals(arg_labelIds));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["q"].first, unittest.equals(arg_q));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListMessagesResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_userId, includeSpamTrash: arg_includeSpamTrash, labelIds: arg_labelIds, maxResults: arg_maxResults, pageToken: arg_pageToken, q: arg_q).then(unittest.expectAsync(((api.ListMessagesResponse response) {
+        checkListMessagesResponse(response);
+      })));
+    });
+
+    unittest.test("method--modify", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_request = buildModifyMessageRequest();
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ModifyMessageRequest.fromJson(json);
+        checkModifyMessageRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        index = path.indexOf("/modify", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/modify"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.modify(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--send", () {
+      // TODO: Implement tests for media upload;
+      // TODO: Implement tests for media download;
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_request = buildMessage();
+      var arg_userId = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.Message.fromJson(json);
+        checkMessage(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/send", 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("/messages/send"));
+        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(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.send(arg_request, arg_userId).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--trash", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        index = path.indexOf("/trash", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/trash"));
+        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(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.trash(arg_userId, arg_id).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+    unittest.test("method--untrash", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesResourceApi res = new api.GmailApi(mock).users.messages;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        index = path.indexOf("/untrash", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/untrash"));
+        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(buildMessage());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.untrash(arg_userId, arg_id).then(unittest.expectAsync(((api.Message response) {
+        checkMessage(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersMessagesAttachmentsResourceApi", () {
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersMessagesAttachmentsResourceApi res = new api.GmailApi(mock).users.messages.attachments;
+      var arg_userId = "foo";
+      var arg_messageId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/messages/", 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 + 10), unittest.equals("/messages/"));
+        pathOffset += 10;
+        index = path.indexOf("/attachments/", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_messageId"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.equals("/attachments/"));
+        pathOffset += 13;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildMessagePartBody());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_userId, arg_messageId, arg_id).then(unittest.expectAsync(((api.MessagePartBody response) {
+        checkMessagePartBody(response);
+      })));
+    });
+
+  });
+
+
+  unittest.group("resource-UsersThreadsResourceApi", () {
+    unittest.test("method--delete", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads/", 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("/threads/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = "";
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.delete(arg_userId, arg_id).then(unittest.expectAsync((_) {}));
+    });
+
+    unittest.test("method--get", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads/", 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("/threads/"));
+        pathOffset += 9;
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
+        pathOffset = path.length;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildThread());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.get(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread response) {
+        checkThread(response);
+      })));
+    });
+
+    unittest.test("method--list", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_userId = "foo";
+      var arg_includeSpamTrash = true;
+      var arg_labelIds = buildUnnamed203();
+      var arg_maxResults = 42;
+      var arg_pageToken = "foo";
+      var arg_q = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads", 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("/threads"));
+        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]));
+          }
+        }
+        unittest.expect(queryMap["includeSpamTrash"].first, unittest.equals("$arg_includeSpamTrash"));
+        unittest.expect(queryMap["labelIds"], unittest.equals(arg_labelIds));
+        unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.equals(arg_maxResults));
+        unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
+        unittest.expect(queryMap["q"].first, unittest.equals(arg_q));
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildListThreadsResponse());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.list(arg_userId, includeSpamTrash: arg_includeSpamTrash, labelIds: arg_labelIds, maxResults: arg_maxResults, pageToken: arg_pageToken, q: arg_q).then(unittest.expectAsync(((api.ListThreadsResponse response) {
+        checkListThreadsResponse(response);
+      })));
+    });
+
+    unittest.test("method--modify", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_request = buildModifyThreadRequest();
+      var arg_userId = "foo";
+      var arg_id = "foo";
+      mock.register(unittest.expectAsync((http.BaseRequest req, json) {
+        var obj = new api.ModifyThreadRequest.fromJson(json);
+        checkModifyThreadRequest(obj);
+
+        var path = (req.url).path;
+        var pathOffset = 0;
+        var index;
+        var subPart;
+        unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads/", 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("/threads/"));
+        pathOffset += 9;
+        index = path.indexOf("/modify", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equals("/modify"));
+        pathOffset += 7;
+
+        var query = (req.url).query;
+        var queryOffset = 0;
+        var queryMap = {};
+        addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
+        parseBool(n) {
+          if (n == "true") return true;
+          if (n == "false") return false;
+          if (n == null) return null;
+          throw new core.ArgumentError("Invalid boolean: $n");
+        }
+        if (query.length > 0) {
+          for (var part in query.split("&")) {
+            var keyvalue = part.split("=");
+            addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
+          }
+        }
+
+
+        var h = {
+          "content-type" : "application/json; charset=utf-8",
+        };
+        var resp = convert.JSON.encode(buildThread());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.modify(arg_request, arg_userId, arg_id).then(unittest.expectAsync(((api.Thread response) {
+        checkThread(response);
+      })));
+    });
+
+    unittest.test("method--trash", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads/", 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("/threads/"));
+        pathOffset += 9;
+        index = path.indexOf("/trash", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equals("/trash"));
+        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(buildThread());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.trash(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread response) {
+        checkThread(response);
+      })));
+    });
+
+    unittest.test("method--untrash", () {
+
+      var mock = new common_test.HttpServerMock();
+      api.UsersThreadsResourceApi res = new api.GmailApi(mock).users.threads;
+      var arg_userId = "foo";
+      var arg_id = "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 + 16), unittest.equals("/gmail/v1/users/"));
+        pathOffset += 16;
+        index = path.indexOf("/threads/", 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("/threads/"));
+        pathOffset += 9;
+        index = path.indexOf("/untrash", pathOffset);
+        unittest.expect(index >= 0, unittest.isTrue);
+        subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
+        pathOffset = index;
+        unittest.expect(subPart, unittest.equals("$arg_id"));
+        unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equals("/untrash"));
+        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(buildThread());
+        return new async.Future.value(common_test.stringResponse(200, h, resp));
+      }), true);
+      res.untrash(arg_userId, arg_id).then(unittest.expectAsync(((api.Thread response) {
+        checkThread(response);
+      })));
+    });
+
+  });
+
+
+}
+