generated/googleapis/test/tasks/v1_test.dart

// Copyright 2014 Google LLC
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: doc_directive_unknown
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unintended_html_in_doc_comment
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable

import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;

import 'package:googleapis/tasks/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;

import '../test_shared.dart';

core.int buildCounterAssignmentInfo = 0;
api.AssignmentInfo buildAssignmentInfo() {
  final o = api.AssignmentInfo();
  buildCounterAssignmentInfo++;
  if (buildCounterAssignmentInfo < 3) {
    o.driveResourceInfo = buildDriveResourceInfo();
    o.linkToTask = 'foo';
    o.spaceInfo = buildSpaceInfo();
    o.surfaceType = 'foo';
  }
  buildCounterAssignmentInfo--;
  return o;
}

void checkAssignmentInfo(api.AssignmentInfo o) {
  buildCounterAssignmentInfo++;
  if (buildCounterAssignmentInfo < 3) {
    checkDriveResourceInfo(o.driveResourceInfo!);
    unittest.expect(o.linkToTask!, unittest.equals('foo'));
    checkSpaceInfo(o.spaceInfo!);
    unittest.expect(o.surfaceType!, unittest.equals('foo'));
  }
  buildCounterAssignmentInfo--;
}

core.int buildCounterDriveResourceInfo = 0;
api.DriveResourceInfo buildDriveResourceInfo() {
  final o = api.DriveResourceInfo();
  buildCounterDriveResourceInfo++;
  if (buildCounterDriveResourceInfo < 3) {
    o.driveFileId = 'foo';
    o.resourceKey = 'foo';
  }
  buildCounterDriveResourceInfo--;
  return o;
}

void checkDriveResourceInfo(api.DriveResourceInfo o) {
  buildCounterDriveResourceInfo++;
  if (buildCounterDriveResourceInfo < 3) {
    unittest.expect(o.driveFileId!, unittest.equals('foo'));
    unittest.expect(o.resourceKey!, unittest.equals('foo'));
  }
  buildCounterDriveResourceInfo--;
}

core.int buildCounterSpaceInfo = 0;
api.SpaceInfo buildSpaceInfo() {
  final o = api.SpaceInfo();
  buildCounterSpaceInfo++;
  if (buildCounterSpaceInfo < 3) {
    o.space = 'foo';
  }
  buildCounterSpaceInfo--;
  return o;
}

void checkSpaceInfo(api.SpaceInfo o) {
  buildCounterSpaceInfo++;
  if (buildCounterSpaceInfo < 3) {
    unittest.expect(o.space!, unittest.equals('foo'));
  }
  buildCounterSpaceInfo--;
}

core.int buildCounterTaskLinks = 0;
api.TaskLinks buildTaskLinks() {
  final o = api.TaskLinks();
  buildCounterTaskLinks++;
  if (buildCounterTaskLinks < 3) {
    o.description = 'foo';
    o.link = 'foo';
    o.type = 'foo';
  }
  buildCounterTaskLinks--;
  return o;
}

void checkTaskLinks(api.TaskLinks o) {
  buildCounterTaskLinks++;
  if (buildCounterTaskLinks < 3) {
    unittest.expect(o.description!, unittest.equals('foo'));
    unittest.expect(o.link!, unittest.equals('foo'));
    unittest.expect(o.type!, unittest.equals('foo'));
  }
  buildCounterTaskLinks--;
}

core.List<api.TaskLinks> buildUnnamed0() => [
  buildTaskLinks(),
  buildTaskLinks(),
];

void checkUnnamed0(core.List<api.TaskLinks> o) {
  unittest.expect(o, unittest.hasLength(2));
  checkTaskLinks(o[0]);
  checkTaskLinks(o[1]);
}

core.int buildCounterTask = 0;
api.Task buildTask() {
  final o = api.Task();
  buildCounterTask++;
  if (buildCounterTask < 3) {
    o.assignmentInfo = buildAssignmentInfo();
    o.completed = 'foo';
    o.deleted = true;
    o.due = 'foo';
    o.etag = 'foo';
    o.hidden = true;
    o.id = 'foo';
    o.kind = 'foo';
    o.links = buildUnnamed0();
    o.notes = 'foo';
    o.parent = 'foo';
    o.position = 'foo';
    o.selfLink = 'foo';
    o.status = 'foo';
    o.title = 'foo';
    o.updated = 'foo';
    o.webViewLink = 'foo';
  }
  buildCounterTask--;
  return o;
}

void checkTask(api.Task o) {
  buildCounterTask++;
  if (buildCounterTask < 3) {
    checkAssignmentInfo(o.assignmentInfo!);
    unittest.expect(o.completed!, unittest.equals('foo'));
    unittest.expect(o.deleted!, unittest.isTrue);
    unittest.expect(o.due!, unittest.equals('foo'));
    unittest.expect(o.etag!, unittest.equals('foo'));
    unittest.expect(o.hidden!, unittest.isTrue);
    unittest.expect(o.id!, unittest.equals('foo'));
    unittest.expect(o.kind!, unittest.equals('foo'));
    checkUnnamed0(o.links!);
    unittest.expect(o.notes!, unittest.equals('foo'));
    unittest.expect(o.parent!, unittest.equals('foo'));
    unittest.expect(o.position!, unittest.equals('foo'));
    unittest.expect(o.selfLink!, unittest.equals('foo'));
    unittest.expect(o.status!, unittest.equals('foo'));
    unittest.expect(o.title!, unittest.equals('foo'));
    unittest.expect(o.updated!, unittest.equals('foo'));
    unittest.expect(o.webViewLink!, unittest.equals('foo'));
  }
  buildCounterTask--;
}

core.int buildCounterTaskList = 0;
api.TaskList buildTaskList() {
  final o = api.TaskList();
  buildCounterTaskList++;
  if (buildCounterTaskList < 3) {
    o.etag = 'foo';
    o.id = 'foo';
    o.kind = 'foo';
    o.selfLink = 'foo';
    o.title = 'foo';
    o.updated = 'foo';
  }
  buildCounterTaskList--;
  return o;
}

void checkTaskList(api.TaskList o) {
  buildCounterTaskList++;
  if (buildCounterTaskList < 3) {
    unittest.expect(o.etag!, unittest.equals('foo'));
    unittest.expect(o.id!, unittest.equals('foo'));
    unittest.expect(o.kind!, unittest.equals('foo'));
    unittest.expect(o.selfLink!, unittest.equals('foo'));
    unittest.expect(o.title!, unittest.equals('foo'));
    unittest.expect(o.updated!, unittest.equals('foo'));
  }
  buildCounterTaskList--;
}

core.List<api.TaskList> buildUnnamed1() => [buildTaskList(), buildTaskList()];

void checkUnnamed1(core.List<api.TaskList> o) {
  unittest.expect(o, unittest.hasLength(2));
  checkTaskList(o[0]);
  checkTaskList(o[1]);
}

core.int buildCounterTaskLists = 0;
api.TaskLists buildTaskLists() {
  final o = api.TaskLists();
  buildCounterTaskLists++;
  if (buildCounterTaskLists < 3) {
    o.etag = 'foo';
    o.items = buildUnnamed1();
    o.kind = 'foo';
    o.nextPageToken = 'foo';
  }
  buildCounterTaskLists--;
  return o;
}

void checkTaskLists(api.TaskLists o) {
  buildCounterTaskLists++;
  if (buildCounterTaskLists < 3) {
    unittest.expect(o.etag!, unittest.equals('foo'));
    checkUnnamed1(o.items!);
    unittest.expect(o.kind!, unittest.equals('foo'));
    unittest.expect(o.nextPageToken!, unittest.equals('foo'));
  }
  buildCounterTaskLists--;
}

core.List<api.Task> buildUnnamed2() => [buildTask(), buildTask()];

void checkUnnamed2(core.List<api.Task> o) {
  unittest.expect(o, unittest.hasLength(2));
  checkTask(o[0]);
  checkTask(o[1]);
}

core.int buildCounterTasks = 0;
api.Tasks buildTasks() {
  final o = api.Tasks();
  buildCounterTasks++;
  if (buildCounterTasks < 3) {
    o.etag = 'foo';
    o.items = buildUnnamed2();
    o.kind = 'foo';
    o.nextPageToken = 'foo';
  }
  buildCounterTasks--;
  return o;
}

void checkTasks(api.Tasks o) {
  buildCounterTasks++;
  if (buildCounterTasks < 3) {
    unittest.expect(o.etag!, unittest.equals('foo'));
    checkUnnamed2(o.items!);
    unittest.expect(o.kind!, unittest.equals('foo'));
    unittest.expect(o.nextPageToken!, unittest.equals('foo'));
  }
  buildCounterTasks--;
}

void main() {
  unittest.group('obj-schema-AssignmentInfo', () {
    unittest.test('to-json--from-json', () async {
      final o = buildAssignmentInfo();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.AssignmentInfo.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkAssignmentInfo(od);
    });
  });

  unittest.group('obj-schema-DriveResourceInfo', () {
    unittest.test('to-json--from-json', () async {
      final o = buildDriveResourceInfo();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.DriveResourceInfo.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkDriveResourceInfo(od);
    });
  });

  unittest.group('obj-schema-SpaceInfo', () {
    unittest.test('to-json--from-json', () async {
      final o = buildSpaceInfo();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.SpaceInfo.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkSpaceInfo(od);
    });
  });

  unittest.group('obj-schema-TaskLinks', () {
    unittest.test('to-json--from-json', () async {
      final o = buildTaskLinks();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.TaskLinks.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkTaskLinks(od);
    });
  });

  unittest.group('obj-schema-Task', () {
    unittest.test('to-json--from-json', () async {
      final o = buildTask();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.Task.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkTask(od);
    });
  });

  unittest.group('obj-schema-TaskList', () {
    unittest.test('to-json--from-json', () async {
      final o = buildTaskList();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.TaskList.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkTaskList(od);
    });
  });

  unittest.group('obj-schema-TaskLists', () {
    unittest.test('to-json--from-json', () async {
      final o = buildTaskLists();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.TaskLists.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkTaskLists(od);
    });
  });

  unittest.group('obj-schema-Tasks', () {
    unittest.test('to-json--from-json', () async {
      final o = buildTasks();
      final oJson = convert.jsonDecode(convert.jsonEncode(o));
      final od = api.Tasks.fromJson(
        oJson as core.Map<core.String, core.dynamic>,
      );
      checkTasks(od);
    });
  });

  unittest.group('resource-TasklistsResource', () {
    unittest.test('method--delete', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_tasklist = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 25),
            unittest.equals('tasks/v1/users/@me/lists/'),
          );
          pathOffset += 25;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = '';
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      await res.delete(arg_tasklist, $fields: arg_$fields);
    });

    unittest.test('method--get', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_tasklist = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 25),
            unittest.equals('tasks/v1/users/@me/lists/'),
          );
          pathOffset += 25;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTaskList());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.get(arg_tasklist, $fields: arg_$fields);
      checkTaskList(response as api.TaskList);
    });

    unittest.test('method--insert', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_request = buildTaskList();
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.TaskList.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTaskList(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 24),
            unittest.equals('tasks/v1/users/@me/lists'),
          );
          pathOffset += 24;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTaskList());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.insert(arg_request, $fields: arg_$fields);
      checkTaskList(response as api.TaskList);
    });

    unittest.test('method--list', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_maxResults = 42;
      final arg_pageToken = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 24),
            unittest.equals('tasks/v1/users/@me/lists'),
          );
          pathOffset += 24;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final 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),
          );
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTaskLists());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.list(
        maxResults: arg_maxResults,
        pageToken: arg_pageToken,
        $fields: arg_$fields,
      );
      checkTaskLists(response as api.TaskLists);
    });

    unittest.test('method--patch', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_request = buildTaskList();
      final arg_tasklist = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.TaskList.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTaskList(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 25),
            unittest.equals('tasks/v1/users/@me/lists/'),
          );
          pathOffset += 25;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTaskList());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.patch(
        arg_request,
        arg_tasklist,
        $fields: arg_$fields,
      );
      checkTaskList(response as api.TaskList);
    });

    unittest.test('method--update', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasklists;
      final arg_request = buildTaskList();
      final arg_tasklist = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.TaskList.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTaskList(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 25),
            unittest.equals('tasks/v1/users/@me/lists/'),
          );
          pathOffset += 25;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTaskList());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.update(
        arg_request,
        arg_tasklist,
        $fields: arg_$fields,
      );
      checkTaskList(response as api.TaskList);
    });
  });

  unittest.group('resource-TasksResource', () {
    unittest.test('method--clear', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_tasklist = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/clear', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 6),
            unittest.equals('/clear'),
          );
          pathOffset += 6;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = '';
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      await res.clear(arg_tasklist, $fields: arg_$fields);
    });

    unittest.test('method--delete', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_tasklist = 'foo';
      final arg_task = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks/', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 7),
            unittest.equals('/tasks/'),
          );
          pathOffset += 7;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_task'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = '';
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      await res.delete(arg_tasklist, arg_task, $fields: arg_$fields);
    });

    unittest.test('method--get', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_tasklist = 'foo';
      final arg_task = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks/', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 7),
            unittest.equals('/tasks/'),
          );
          pathOffset += 7;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_task'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTask());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.get(
        arg_tasklist,
        arg_task,
        $fields: arg_$fields,
      );
      checkTask(response as api.Task);
    });

    unittest.test('method--insert', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_request = buildTask();
      final arg_tasklist = 'foo';
      final arg_parent = 'foo';
      final arg_previous = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.Task.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTask(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 6),
            unittest.equals('/tasks'),
          );
          pathOffset += 6;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['parent']!.first,
            unittest.equals(arg_parent),
          );
          unittest.expect(
            queryMap['previous']!.first,
            unittest.equals(arg_previous),
          );
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTask());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.insert(
        arg_request,
        arg_tasklist,
        parent: arg_parent,
        previous: arg_previous,
        $fields: arg_$fields,
      );
      checkTask(response as api.Task);
    });

    unittest.test('method--list', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_tasklist = 'foo';
      final arg_completedMax = 'foo';
      final arg_completedMin = 'foo';
      final arg_dueMax = 'foo';
      final arg_dueMin = 'foo';
      final arg_maxResults = 42;
      final arg_pageToken = 'foo';
      final arg_showAssigned = true;
      final arg_showCompleted = true;
      final arg_showDeleted = true;
      final arg_showHidden = true;
      final arg_updatedMin = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 6),
            unittest.equals('/tasks'),
          );
          pathOffset += 6;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['completedMax']!.first,
            unittest.equals(arg_completedMax),
          );
          unittest.expect(
            queryMap['completedMin']!.first,
            unittest.equals(arg_completedMin),
          );
          unittest.expect(
            queryMap['dueMax']!.first,
            unittest.equals(arg_dueMax),
          );
          unittest.expect(
            queryMap['dueMin']!.first,
            unittest.equals(arg_dueMin),
          );
          unittest.expect(
            core.int.parse(queryMap['maxResults']!.first),
            unittest.equals(arg_maxResults),
          );
          unittest.expect(
            queryMap['pageToken']!.first,
            unittest.equals(arg_pageToken),
          );
          unittest.expect(
            queryMap['showAssigned']!.first,
            unittest.equals('$arg_showAssigned'),
          );
          unittest.expect(
            queryMap['showCompleted']!.first,
            unittest.equals('$arg_showCompleted'),
          );
          unittest.expect(
            queryMap['showDeleted']!.first,
            unittest.equals('$arg_showDeleted'),
          );
          unittest.expect(
            queryMap['showHidden']!.first,
            unittest.equals('$arg_showHidden'),
          );
          unittest.expect(
            queryMap['updatedMin']!.first,
            unittest.equals(arg_updatedMin),
          );
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTasks());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.list(
        arg_tasklist,
        completedMax: arg_completedMax,
        completedMin: arg_completedMin,
        dueMax: arg_dueMax,
        dueMin: arg_dueMin,
        maxResults: arg_maxResults,
        pageToken: arg_pageToken,
        showAssigned: arg_showAssigned,
        showCompleted: arg_showCompleted,
        showDeleted: arg_showDeleted,
        showHidden: arg_showHidden,
        updatedMin: arg_updatedMin,
        $fields: arg_$fields,
      );
      checkTasks(response as api.Tasks);
    });

    unittest.test('method--move', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_tasklist = 'foo';
      final arg_task = 'foo';
      final arg_destinationTasklist = 'foo';
      final arg_parent = 'foo';
      final arg_previous = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks/', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 7),
            unittest.equals('/tasks/'),
          );
          pathOffset += 7;
          index = path.indexOf('/move', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_task'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 5),
            unittest.equals('/move'),
          );
          pathOffset += 5;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['destinationTasklist']!.first,
            unittest.equals(arg_destinationTasklist),
          );
          unittest.expect(
            queryMap['parent']!.first,
            unittest.equals(arg_parent),
          );
          unittest.expect(
            queryMap['previous']!.first,
            unittest.equals(arg_previous),
          );
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTask());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.move(
        arg_tasklist,
        arg_task,
        destinationTasklist: arg_destinationTasklist,
        parent: arg_parent,
        previous: arg_previous,
        $fields: arg_$fields,
      );
      checkTask(response as api.Task);
    });

    unittest.test('method--patch', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_request = buildTask();
      final arg_tasklist = 'foo';
      final arg_task = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.Task.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTask(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks/', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 7),
            unittest.equals('/tasks/'),
          );
          pathOffset += 7;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_task'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTask());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.patch(
        arg_request,
        arg_tasklist,
        arg_task,
        $fields: arg_$fields,
      );
      checkTask(response as api.Task);
    });

    unittest.test('method--update', () async {
      final mock = HttpServerMock();
      final res = api.TasksApi(mock).tasks;
      final arg_request = buildTask();
      final arg_tasklist = 'foo';
      final arg_task = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.Task.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkTask(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 15),
            unittest.equals('tasks/v1/lists/'),
          );
          pathOffset += 15;
          index = path.indexOf('/tasks/', pathOffset);
          unittest.expect(index >= 0, unittest.isTrue);
          subPart = core.Uri.decodeQueryComponent(
            path.substring(pathOffset, index),
          );
          pathOffset = index;
          unittest.expect(subPart, unittest.equals('$arg_tasklist'));
          unittest.expect(
            path.substring(pathOffset, pathOffset + 7),
            unittest.equals('/tasks/'),
          );
          pathOffset += 7;
          subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
          pathOffset = path.length;
          unittest.expect(subPart, unittest.equals('$arg_task'));

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildTask());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.update(
        arg_request,
        arg_tasklist,
        arg_task,
        $fields: arg_$fields,
      );
      checkTask(response as api.Task);
    });
  });
}