generated/googleapis/test/adsense/v1_4.dart - Issue 560323003: Add discovery service to stable APIs

Side by Side Diff: generated/googleapis/test/adsense/v1_4.dart

Issue 560323003: Add discovery service to stable APIs (Closed) Base URL: git@github.com:dart-lang/googleapis.git@master

Patch Set: New generator hash in pubspec.yaml, test files renamed ot have _test.dart postfix Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 library googleapis.adsense.v1_4.test;

2

3 import "dart:core" as core;

4 import "dart:collection" as collection;

5 import "dart:async" as async;

6 import "dart:convert" as convert;

7

8 import 'package:http/http.dart' as http;

9 import 'package:http/testing.dart' as http_testing;

10 import 'package:unittest/unittest.dart' as unittest;

11 import 'package:googleapis/common/common.dart' as common;

12 import 'package:googleapis/src/common_internal.dart' as common_internal;

13 import '../common/common_internal_test.dart' as common_test;

14

15 import 'package:googleapis/adsense/v1_4.dart' as api;

16

17

18

19 buildUnnamed807() {

20 var o = new core.List<api.Account>();

21 o.add(buildAccount());

22 o.add(buildAccount());

23 return o;

24 }

25

26 checkUnnamed807(core.List<api.Account> o) {

27 unittest.expect(o, unittest.hasLength(2));

28 checkAccount(o[0]);

29 checkAccount(o[1]);

30 }

31

32 core.int buildCounterAccount = 0;

33 buildAccount() {

34 var o = new api.Account();

35 buildCounterAccount++;

36 if (buildCounterAccount < 3) {

37 o.id = "foo";

38 o.kind = "foo";

39 o.name = "foo";

40 o.premium = true;

41 o.subAccounts = buildUnnamed807();

42 o.timezone = "foo";

43 }

44 buildCounterAccount--;

45 return o;

46 }

47

48 checkAccount(api.Account o) {

49 buildCounterAccount++;

50 if (buildCounterAccount < 3) {

51 unittest.expect(o.id, unittest.equals('foo'));

52 unittest.expect(o.kind, unittest.equals('foo'));

53 unittest.expect(o.name, unittest.equals('foo'));

54 unittest.expect(o.premium, unittest.isTrue);

55 checkUnnamed807(o.subAccounts);

56 unittest.expect(o.timezone, unittest.equals('foo'));

57 }

58 buildCounterAccount--;

59 }

60

61 buildUnnamed808() {

62 var o = new core.List<api.Account>();

63 o.add(buildAccount());

64 o.add(buildAccount());

65 return o;

66 }

67

68 checkUnnamed808(core.List<api.Account> o) {

69 unittest.expect(o, unittest.hasLength(2));

70 checkAccount(o[0]);

71 checkAccount(o[1]);

72 }

73

74 core.int buildCounterAccounts = 0;

75 buildAccounts() {

76 var o = new api.Accounts();

77 buildCounterAccounts++;

78 if (buildCounterAccounts < 3) {

79 o.etag = "foo";

80 o.items = buildUnnamed808();

81 o.kind = "foo";

82 o.nextPageToken = "foo";

83 }

84 buildCounterAccounts--;

85 return o;

86 }

87

88 checkAccounts(api.Accounts o) {

89 buildCounterAccounts++;

90 if (buildCounterAccounts < 3) {

91 unittest.expect(o.etag, unittest.equals('foo'));

92 checkUnnamed808(o.items);

93 unittest.expect(o.kind, unittest.equals('foo'));

94 unittest.expect(o.nextPageToken, unittest.equals('foo'));

95 }

96 buildCounterAccounts--;

97 }

98

99 core.int buildCounterAdClient = 0;

100 buildAdClient() {

101 var o = new api.AdClient();

102 buildCounterAdClient++;

103 if (buildCounterAdClient < 3) {

104 o.arcOptIn = true;

105 o.arcReviewMode = "foo";

106 o.id = "foo";

107 o.kind = "foo";

108 o.productCode = "foo";

109 o.supportsReporting = true;

110 }

111 buildCounterAdClient--;

112 return o;

113 }

114

115 checkAdClient(api.AdClient o) {

116 buildCounterAdClient++;

117 if (buildCounterAdClient < 3) {

118 unittest.expect(o.arcOptIn, unittest.isTrue);

119 unittest.expect(o.arcReviewMode, unittest.equals('foo'));

120 unittest.expect(o.id, unittest.equals('foo'));

121 unittest.expect(o.kind, unittest.equals('foo'));

122 unittest.expect(o.productCode, unittest.equals('foo'));

123 unittest.expect(o.supportsReporting, unittest.isTrue);

124 }

125 buildCounterAdClient--;

126 }

127

128 buildUnnamed809() {

129 var o = new core.List<api.AdClient>();

130 o.add(buildAdClient());

131 o.add(buildAdClient());

132 return o;

133 }

134

135 checkUnnamed809(core.List<api.AdClient> o) {

136 unittest.expect(o, unittest.hasLength(2));

137 checkAdClient(o[0]);

138 checkAdClient(o[1]);

139 }

140

141 core.int buildCounterAdClients = 0;

142 buildAdClients() {

143 var o = new api.AdClients();

144 buildCounterAdClients++;

145 if (buildCounterAdClients < 3) {

146 o.etag = "foo";

147 o.items = buildUnnamed809();

148 o.kind = "foo";

149 o.nextPageToken = "foo";

150 }

151 buildCounterAdClients--;

152 return o;

153 }

154

155 checkAdClients(api.AdClients o) {

156 buildCounterAdClients++;

157 if (buildCounterAdClients < 3) {

158 unittest.expect(o.etag, unittest.equals('foo'));

159 checkUnnamed809(o.items);

160 unittest.expect(o.kind, unittest.equals('foo'));

161 unittest.expect(o.nextPageToken, unittest.equals('foo'));

162 }

163 buildCounterAdClients--;

164 }

165

166 core.int buildCounterAdCode = 0;

167 buildAdCode() {

168 var o = new api.AdCode();

169 buildCounterAdCode++;

170 if (buildCounterAdCode < 3) {

171 o.adCode = "foo";

172 o.kind = "foo";

173 }

174 buildCounterAdCode--;

175 return o;

176 }

177

178 checkAdCode(api.AdCode o) {

179 buildCounterAdCode++;

180 if (buildCounterAdCode < 3) {

181 unittest.expect(o.adCode, unittest.equals('foo'));

182 unittest.expect(o.kind, unittest.equals('foo'));

183 }

184 buildCounterAdCode--;

185 }

186

187 core.int buildCounterAdStyleColors = 0;

188 buildAdStyleColors() {

189 var o = new api.AdStyleColors();

190 buildCounterAdStyleColors++;

191 if (buildCounterAdStyleColors < 3) {

192 o.background = "foo";

193 o.border = "foo";

194 o.text = "foo";

195 o.title = "foo";

196 o.url = "foo";

197 }

198 buildCounterAdStyleColors--;

199 return o;

200 }

201

202 checkAdStyleColors(api.AdStyleColors o) {

203 buildCounterAdStyleColors++;

204 if (buildCounterAdStyleColors < 3) {

205 unittest.expect(o.background, unittest.equals('foo'));

206 unittest.expect(o.border, unittest.equals('foo'));

207 unittest.expect(o.text, unittest.equals('foo'));

208 unittest.expect(o.title, unittest.equals('foo'));

209 unittest.expect(o.url, unittest.equals('foo'));

210 }

211 buildCounterAdStyleColors--;

212 }

213

214 core.int buildCounterAdStyleFont = 0;

215 buildAdStyleFont() {

216 var o = new api.AdStyleFont();

217 buildCounterAdStyleFont++;

218 if (buildCounterAdStyleFont < 3) {

219 o.family = "foo";

220 o.size = "foo";

221 }

222 buildCounterAdStyleFont--;

223 return o;

224 }

225

226 checkAdStyleFont(api.AdStyleFont o) {

227 buildCounterAdStyleFont++;

228 if (buildCounterAdStyleFont < 3) {

229 unittest.expect(o.family, unittest.equals('foo'));

230 unittest.expect(o.size, unittest.equals('foo'));

231 }

232 buildCounterAdStyleFont--;

233 }

234

235 core.int buildCounterAdStyle = 0;

236 buildAdStyle() {

237 var o = new api.AdStyle();

238 buildCounterAdStyle++;

239 if (buildCounterAdStyle < 3) {

240 o.colors = buildAdStyleColors();

241 o.corners = "foo";

242 o.font = buildAdStyleFont();

243 o.kind = "foo";

244 }

245 buildCounterAdStyle--;

246 return o;

247 }

248

249 checkAdStyle(api.AdStyle o) {

250 buildCounterAdStyle++;

251 if (buildCounterAdStyle < 3) {

252 checkAdStyleColors(o.colors);

253 unittest.expect(o.corners, unittest.equals('foo'));

254 checkAdStyleFont(o.font);

255 unittest.expect(o.kind, unittest.equals('foo'));

256 }

257 buildCounterAdStyle--;

258 }

259

260 core.int buildCounterAdUnitContentAdsSettingsBackupOption = 0;

261 buildAdUnitContentAdsSettingsBackupOption() {

262 var o = new api.AdUnitContentAdsSettingsBackupOption();

263 buildCounterAdUnitContentAdsSettingsBackupOption++;

264 if (buildCounterAdUnitContentAdsSettingsBackupOption < 3) {

265 o.color = "foo";

266 o.type = "foo";

267 o.url = "foo";

268 }

269 buildCounterAdUnitContentAdsSettingsBackupOption--;

270 return o;

271 }

272

273 checkAdUnitContentAdsSettingsBackupOption(api.AdUnitContentAdsSettingsBackupOpti on o) {

274 buildCounterAdUnitContentAdsSettingsBackupOption++;

275 if (buildCounterAdUnitContentAdsSettingsBackupOption < 3) {

276 unittest.expect(o.color, unittest.equals('foo'));

277 unittest.expect(o.type, unittest.equals('foo'));

278 unittest.expect(o.url, unittest.equals('foo'));

279 }

280 buildCounterAdUnitContentAdsSettingsBackupOption--;

281 }

282

283 core.int buildCounterAdUnitContentAdsSettings = 0;

284 buildAdUnitContentAdsSettings() {

285 var o = new api.AdUnitContentAdsSettings();

286 buildCounterAdUnitContentAdsSettings++;

287 if (buildCounterAdUnitContentAdsSettings < 3) {

288 o.backupOption = buildAdUnitContentAdsSettingsBackupOption();

289 o.size = "foo";

290 o.type = "foo";

291 }

292 buildCounterAdUnitContentAdsSettings--;

293 return o;

294 }

295

296 checkAdUnitContentAdsSettings(api.AdUnitContentAdsSettings o) {

297 buildCounterAdUnitContentAdsSettings++;

298 if (buildCounterAdUnitContentAdsSettings < 3) {

299 checkAdUnitContentAdsSettingsBackupOption(o.backupOption);

300 unittest.expect(o.size, unittest.equals('foo'));

301 unittest.expect(o.type, unittest.equals('foo'));

302 }

303 buildCounterAdUnitContentAdsSettings--;

304 }

305

306 core.int buildCounterAdUnitFeedAdsSettings = 0;

307 buildAdUnitFeedAdsSettings() {

308 var o = new api.AdUnitFeedAdsSettings();

309 buildCounterAdUnitFeedAdsSettings++;

310 if (buildCounterAdUnitFeedAdsSettings < 3) {

311 o.adPosition = "foo";

312 o.frequency = 42;

313 o.minimumWordCount = 42;

314 o.type = "foo";

315 }

316 buildCounterAdUnitFeedAdsSettings--;

317 return o;

318 }

319

320 checkAdUnitFeedAdsSettings(api.AdUnitFeedAdsSettings o) {

321 buildCounterAdUnitFeedAdsSettings++;

322 if (buildCounterAdUnitFeedAdsSettings < 3) {

323 unittest.expect(o.adPosition, unittest.equals('foo'));

324 unittest.expect(o.frequency, unittest.equals(42));

325 unittest.expect(o.minimumWordCount, unittest.equals(42));

326 unittest.expect(o.type, unittest.equals('foo'));

327 }

328 buildCounterAdUnitFeedAdsSettings--;

329 }

330

331 core.int buildCounterAdUnitMobileContentAdsSettings = 0;

332 buildAdUnitMobileContentAdsSettings() {

333 var o = new api.AdUnitMobileContentAdsSettings();

334 buildCounterAdUnitMobileContentAdsSettings++;

335 if (buildCounterAdUnitMobileContentAdsSettings < 3) {

336 o.markupLanguage = "foo";

337 o.scriptingLanguage = "foo";

338 o.size = "foo";

339 o.type = "foo";

340 }

341 buildCounterAdUnitMobileContentAdsSettings--;

342 return o;

343 }

344

345 checkAdUnitMobileContentAdsSettings(api.AdUnitMobileContentAdsSettings o) {

346 buildCounterAdUnitMobileContentAdsSettings++;

347 if (buildCounterAdUnitMobileContentAdsSettings < 3) {

348 unittest.expect(o.markupLanguage, unittest.equals('foo'));

349 unittest.expect(o.scriptingLanguage, unittest.equals('foo'));

350 unittest.expect(o.size, unittest.equals('foo'));

351 unittest.expect(o.type, unittest.equals('foo'));

352 }

353 buildCounterAdUnitMobileContentAdsSettings--;

354 }

355

356 core.int buildCounterAdUnit = 0;

357 buildAdUnit() {

358 var o = new api.AdUnit();

359 buildCounterAdUnit++;

360 if (buildCounterAdUnit < 3) {

361 o.code = "foo";

362 o.contentAdsSettings = buildAdUnitContentAdsSettings();

363 o.customStyle = buildAdStyle();

364 o.feedAdsSettings = buildAdUnitFeedAdsSettings();

365 o.id = "foo";

366 o.kind = "foo";

367 o.mobileContentAdsSettings = buildAdUnitMobileContentAdsSettings();

368 o.name = "foo";

369 o.savedStyleId = "foo";

370 o.status = "foo";

371 }

372 buildCounterAdUnit--;

373 return o;

374 }

375

376 checkAdUnit(api.AdUnit o) {

377 buildCounterAdUnit++;

378 if (buildCounterAdUnit < 3) {

379 unittest.expect(o.code, unittest.equals('foo'));

380 checkAdUnitContentAdsSettings(o.contentAdsSettings);

381 checkAdStyle(o.customStyle);

382 checkAdUnitFeedAdsSettings(o.feedAdsSettings);

383 unittest.expect(o.id, unittest.equals('foo'));

384 unittest.expect(o.kind, unittest.equals('foo'));

385 checkAdUnitMobileContentAdsSettings(o.mobileContentAdsSettings);

386 unittest.expect(o.name, unittest.equals('foo'));

387 unittest.expect(o.savedStyleId, unittest.equals('foo'));

388 unittest.expect(o.status, unittest.equals('foo'));

389 }

390 buildCounterAdUnit--;

391 }

392

393 buildUnnamed810() {

394 var o = new core.List<api.AdUnit>();

395 o.add(buildAdUnit());

396 o.add(buildAdUnit());

397 return o;

398 }

399

400 checkUnnamed810(core.List<api.AdUnit> o) {

401 unittest.expect(o, unittest.hasLength(2));

402 checkAdUnit(o[0]);

403 checkAdUnit(o[1]);

404 }

405

406 core.int buildCounterAdUnits = 0;

407 buildAdUnits() {

408 var o = new api.AdUnits();

409 buildCounterAdUnits++;

410 if (buildCounterAdUnits < 3) {

411 o.etag = "foo";

412 o.items = buildUnnamed810();

413 o.kind = "foo";

414 o.nextPageToken = "foo";

415 }

416 buildCounterAdUnits--;

417 return o;

418 }

419

420 checkAdUnits(api.AdUnits o) {

421 buildCounterAdUnits++;

422 if (buildCounterAdUnits < 3) {

423 unittest.expect(o.etag, unittest.equals('foo'));

424 checkUnnamed810(o.items);

425 unittest.expect(o.kind, unittest.equals('foo'));

426 unittest.expect(o.nextPageToken, unittest.equals('foo'));

427 }

428 buildCounterAdUnits--;

429 }

430

431 buildUnnamed811() {

432 var o = new core.List<core.String>();

433 o.add("foo");

434 o.add("foo");

435 return o;

436 }

437

438 checkUnnamed811(core.List<core.String> o) {

439 unittest.expect(o, unittest.hasLength(2));

440 unittest.expect(o[0], unittest.equals('foo'));

441 unittest.expect(o[1], unittest.equals('foo'));

442 }

443

444 core.int buildCounterAdsenseReportsGenerateResponseHeaders = 0;

445 buildAdsenseReportsGenerateResponseHeaders() {

446 var o = new api.AdsenseReportsGenerateResponseHeaders();

447 buildCounterAdsenseReportsGenerateResponseHeaders++;

448 if (buildCounterAdsenseReportsGenerateResponseHeaders < 3) {

449 o.currency = "foo";

450 o.name = "foo";

451 o.type = "foo";

452 }

453 buildCounterAdsenseReportsGenerateResponseHeaders--;

454 return o;

455 }

456

457 checkAdsenseReportsGenerateResponseHeaders(api.AdsenseReportsGenerateResponseHea ders o) {

458 buildCounterAdsenseReportsGenerateResponseHeaders++;

459 if (buildCounterAdsenseReportsGenerateResponseHeaders < 3) {

460 unittest.expect(o.currency, unittest.equals('foo'));

461 unittest.expect(o.name, unittest.equals('foo'));

462 unittest.expect(o.type, unittest.equals('foo'));

463 }

464 buildCounterAdsenseReportsGenerateResponseHeaders--;

465 }

466

467 buildUnnamed812() {

468 var o = new core.List<api.AdsenseReportsGenerateResponseHeaders>();

469 o.add(buildAdsenseReportsGenerateResponseHeaders());

470 o.add(buildAdsenseReportsGenerateResponseHeaders());

471 return o;

472 }

473

474 checkUnnamed812(core.List<api.AdsenseReportsGenerateResponseHeaders> o) {

475 unittest.expect(o, unittest.hasLength(2));

476 checkAdsenseReportsGenerateResponseHeaders(o[0]);

477 checkAdsenseReportsGenerateResponseHeaders(o[1]);

478 }

479

480 buildUnnamed813() {

481 var o = new core.List<core.String>();

482 o.add("foo");

483 o.add("foo");

484 return o;

485 }

486

487 checkUnnamed813(core.List<core.String> o) {

488 unittest.expect(o, unittest.hasLength(2));

489 unittest.expect(o[0], unittest.equals('foo'));

490 unittest.expect(o[1], unittest.equals('foo'));

491 }

492

493 buildUnnamed814() {

494 var o = new core.List<core.List<core.String>>();

495 o.add(buildUnnamed813());

496 o.add(buildUnnamed813());

497 return o;

498 }

499

500 checkUnnamed814(core.List<core.List<core.String>> o) {

501 unittest.expect(o, unittest.hasLength(2));

502 checkUnnamed813(o[0]);

503 checkUnnamed813(o[1]);

504 }

505

506 buildUnnamed815() {

507 var o = new core.List<core.String>();

508 o.add("foo");

509 o.add("foo");

510 return o;

511 }

512

513 checkUnnamed815(core.List<core.String> o) {

514 unittest.expect(o, unittest.hasLength(2));

515 unittest.expect(o[0], unittest.equals('foo'));

516 unittest.expect(o[1], unittest.equals('foo'));

517 }

518

519 buildUnnamed816() {

520 var o = new core.List<core.String>();

521 o.add("foo");

522 o.add("foo");

523 return o;

524 }

525

526 checkUnnamed816(core.List<core.String> o) {

527 unittest.expect(o, unittest.hasLength(2));

528 unittest.expect(o[0], unittest.equals('foo'));

529 unittest.expect(o[1], unittest.equals('foo'));

530 }

531

532 core.int buildCounterAdsenseReportsGenerateResponse = 0;

533 buildAdsenseReportsGenerateResponse() {

534 var o = new api.AdsenseReportsGenerateResponse();

535 buildCounterAdsenseReportsGenerateResponse++;

536 if (buildCounterAdsenseReportsGenerateResponse < 3) {

537 o.averages = buildUnnamed811();

538 o.endDate = "foo";

539 o.headers = buildUnnamed812();

540 o.kind = "foo";

541 o.rows = buildUnnamed814();

542 o.startDate = "foo";

543 o.totalMatchedRows = "foo";

544 o.totals = buildUnnamed815();

545 o.warnings = buildUnnamed816();

546 }

547 buildCounterAdsenseReportsGenerateResponse--;

548 return o;

549 }

550

551 checkAdsenseReportsGenerateResponse(api.AdsenseReportsGenerateResponse o) {

552 buildCounterAdsenseReportsGenerateResponse++;

553 if (buildCounterAdsenseReportsGenerateResponse < 3) {

554 checkUnnamed811(o.averages);

555 unittest.expect(o.endDate, unittest.equals('foo'));

556 checkUnnamed812(o.headers);

557 unittest.expect(o.kind, unittest.equals('foo'));

558 checkUnnamed814(o.rows);

559 unittest.expect(o.startDate, unittest.equals('foo'));

560 unittest.expect(o.totalMatchedRows, unittest.equals('foo'));

561 checkUnnamed815(o.totals);

562 checkUnnamed816(o.warnings);

563 }

564 buildCounterAdsenseReportsGenerateResponse--;

565 }

566

567 core.int buildCounterAlert = 0;

568 buildAlert() {

569 var o = new api.Alert();

570 buildCounterAlert++;

571 if (buildCounterAlert < 3) {

572 o.id = "foo";

573 o.isDismissible = true;

574 o.kind = "foo";

575 o.message = "foo";

576 o.severity = "foo";

577 o.type = "foo";

578 }

579 buildCounterAlert--;

580 return o;

581 }

582

583 checkAlert(api.Alert o) {

584 buildCounterAlert++;

585 if (buildCounterAlert < 3) {

586 unittest.expect(o.id, unittest.equals('foo'));

587 unittest.expect(o.isDismissible, unittest.isTrue);

588 unittest.expect(o.kind, unittest.equals('foo'));

589 unittest.expect(o.message, unittest.equals('foo'));

590 unittest.expect(o.severity, unittest.equals('foo'));

591 unittest.expect(o.type, unittest.equals('foo'));

592 }

593 buildCounterAlert--;

594 }

595

596 buildUnnamed817() {

597 var o = new core.List<api.Alert>();

598 o.add(buildAlert());

599 o.add(buildAlert());

600 return o;

601 }

602

603 checkUnnamed817(core.List<api.Alert> o) {

604 unittest.expect(o, unittest.hasLength(2));

605 checkAlert(o[0]);

606 checkAlert(o[1]);

607 }

608

609 core.int buildCounterAlerts = 0;

610 buildAlerts() {

611 var o = new api.Alerts();

612 buildCounterAlerts++;

613 if (buildCounterAlerts < 3) {

614 o.items = buildUnnamed817();

615 o.kind = "foo";

616 }

617 buildCounterAlerts--;

618 return o;

619 }

620

621 checkAlerts(api.Alerts o) {

622 buildCounterAlerts++;

623 if (buildCounterAlerts < 3) {

624 checkUnnamed817(o.items);

625 unittest.expect(o.kind, unittest.equals('foo'));

626 }

627 buildCounterAlerts--;

628 }

629

630 core.int buildCounterCustomChannelTargetingInfo = 0;

631 buildCustomChannelTargetingInfo() {

632 var o = new api.CustomChannelTargetingInfo();

633 buildCounterCustomChannelTargetingInfo++;

634 if (buildCounterCustomChannelTargetingInfo < 3) {

635 o.adsAppearOn = "foo";

636 o.description = "foo";

637 o.location = "foo";

638 o.siteLanguage = "foo";

639 }

640 buildCounterCustomChannelTargetingInfo--;

641 return o;

642 }

643

644 checkCustomChannelTargetingInfo(api.CustomChannelTargetingInfo o) {

645 buildCounterCustomChannelTargetingInfo++;

646 if (buildCounterCustomChannelTargetingInfo < 3) {

647 unittest.expect(o.adsAppearOn, unittest.equals('foo'));

648 unittest.expect(o.description, unittest.equals('foo'));

649 unittest.expect(o.location, unittest.equals('foo'));

650 unittest.expect(o.siteLanguage, unittest.equals('foo'));

651 }

652 buildCounterCustomChannelTargetingInfo--;

653 }

654

655 core.int buildCounterCustomChannel = 0;

656 buildCustomChannel() {

657 var o = new api.CustomChannel();

658 buildCounterCustomChannel++;

659 if (buildCounterCustomChannel < 3) {

660 o.code = "foo";

661 o.id = "foo";

662 o.kind = "foo";

663 o.name = "foo";

664 o.targetingInfo = buildCustomChannelTargetingInfo();

665 }

666 buildCounterCustomChannel--;

667 return o;

668 }

669

670 checkCustomChannel(api.CustomChannel o) {

671 buildCounterCustomChannel++;

672 if (buildCounterCustomChannel < 3) {

673 unittest.expect(o.code, unittest.equals('foo'));

674 unittest.expect(o.id, unittest.equals('foo'));

675 unittest.expect(o.kind, unittest.equals('foo'));

676 unittest.expect(o.name, unittest.equals('foo'));

677 checkCustomChannelTargetingInfo(o.targetingInfo);

678 }

679 buildCounterCustomChannel--;

680 }

681

682 buildUnnamed818() {

683 var o = new core.List<api.CustomChannel>();

684 o.add(buildCustomChannel());

685 o.add(buildCustomChannel());

686 return o;

687 }

688

689 checkUnnamed818(core.List<api.CustomChannel> o) {

690 unittest.expect(o, unittest.hasLength(2));

691 checkCustomChannel(o[0]);

692 checkCustomChannel(o[1]);

693 }

694

695 core.int buildCounterCustomChannels = 0;

696 buildCustomChannels() {

697 var o = new api.CustomChannels();

698 buildCounterCustomChannels++;

699 if (buildCounterCustomChannels < 3) {

700 o.etag = "foo";

701 o.items = buildUnnamed818();

702 o.kind = "foo";

703 o.nextPageToken = "foo";

704 }

705 buildCounterCustomChannels--;

706 return o;

707 }

708

709 checkCustomChannels(api.CustomChannels o) {

710 buildCounterCustomChannels++;

711 if (buildCounterCustomChannels < 3) {

712 unittest.expect(o.etag, unittest.equals('foo'));

713 checkUnnamed818(o.items);

714 unittest.expect(o.kind, unittest.equals('foo'));

715 unittest.expect(o.nextPageToken, unittest.equals('foo'));

716 }

717 buildCounterCustomChannels--;

718 }

719

720 buildUnnamed819() {

721 var o = new core.List<api.ReportingMetadataEntry>();

722 o.add(buildReportingMetadataEntry());

723 o.add(buildReportingMetadataEntry());

724 return o;

725 }

726

727 checkUnnamed819(core.List<api.ReportingMetadataEntry> o) {

728 unittest.expect(o, unittest.hasLength(2));

729 checkReportingMetadataEntry(o[0]);

730 checkReportingMetadataEntry(o[1]);

731 }

732

733 core.int buildCounterMetadata = 0;

734 buildMetadata() {

735 var o = new api.Metadata();

736 buildCounterMetadata++;

737 if (buildCounterMetadata < 3) {

738 o.items = buildUnnamed819();

739 o.kind = "foo";

740 }

741 buildCounterMetadata--;

742 return o;

743 }

744

745 checkMetadata(api.Metadata o) {

746 buildCounterMetadata++;

747 if (buildCounterMetadata < 3) {

748 checkUnnamed819(o.items);

749 unittest.expect(o.kind, unittest.equals('foo'));

750 }

751 buildCounterMetadata--;

752 }

753

754 core.int buildCounterPayment = 0;

755 buildPayment() {

756 var o = new api.Payment();

757 buildCounterPayment++;

758 if (buildCounterPayment < 3) {

759 o.id = "foo";

760 o.kind = "foo";

761 o.paymentAmount = "foo";

762 o.paymentAmountCurrencyCode = "foo";

763 o.paymentDate = "foo";

764 }

765 buildCounterPayment--;

766 return o;

767 }

768

769 checkPayment(api.Payment o) {

770 buildCounterPayment++;

771 if (buildCounterPayment < 3) {

772 unittest.expect(o.id, unittest.equals('foo'));

773 unittest.expect(o.kind, unittest.equals('foo'));

774 unittest.expect(o.paymentAmount, unittest.equals('foo'));

775 unittest.expect(o.paymentAmountCurrencyCode, unittest.equals('foo'));

776 unittest.expect(o.paymentDate, unittest.equals('foo'));

777 }

778 buildCounterPayment--;

779 }

780

781 buildUnnamed820() {

782 var o = new core.List<api.Payment>();

783 o.add(buildPayment());

784 o.add(buildPayment());

785 return o;

786 }

787

788 checkUnnamed820(core.List<api.Payment> o) {

789 unittest.expect(o, unittest.hasLength(2));

790 checkPayment(o[0]);

791 checkPayment(o[1]);

792 }

793

794 core.int buildCounterPayments = 0;

795 buildPayments() {

796 var o = new api.Payments();

797 buildCounterPayments++;

798 if (buildCounterPayments < 3) {

799 o.items = buildUnnamed820();

800 o.kind = "foo";

801 }

802 buildCounterPayments--;

803 return o;

804 }

805

806 checkPayments(api.Payments o) {

807 buildCounterPayments++;

808 if (buildCounterPayments < 3) {

809 checkUnnamed820(o.items);

810 unittest.expect(o.kind, unittest.equals('foo'));

811 }

812 buildCounterPayments--;

813 }

814

815 buildUnnamed821() {

816 var o = new core.List<core.String>();

817 o.add("foo");

818 o.add("foo");

819 return o;

820 }

821

822 checkUnnamed821(core.List<core.String> o) {

823 unittest.expect(o, unittest.hasLength(2));

824 unittest.expect(o[0], unittest.equals('foo'));

825 unittest.expect(o[1], unittest.equals('foo'));

826 }

827

828 buildUnnamed822() {

829 var o = new core.List<core.String>();

830 o.add("foo");

831 o.add("foo");

832 return o;

833 }

834

835 checkUnnamed822(core.List<core.String> o) {

836 unittest.expect(o, unittest.hasLength(2));

837 unittest.expect(o[0], unittest.equals('foo'));

838 unittest.expect(o[1], unittest.equals('foo'));

839 }

840

841 buildUnnamed823() {

842 var o = new core.List<core.String>();

843 o.add("foo");

844 o.add("foo");

845 return o;

846 }

847

848 checkUnnamed823(core.List<core.String> o) {

849 unittest.expect(o, unittest.hasLength(2));

850 unittest.expect(o[0], unittest.equals('foo'));

851 unittest.expect(o[1], unittest.equals('foo'));

852 }

853

854 buildUnnamed824() {

855 var o = new core.List<core.String>();

856 o.add("foo");

857 o.add("foo");

858 return o;

859 }

860

861 checkUnnamed824(core.List<core.String> o) {

862 unittest.expect(o, unittest.hasLength(2));

863 unittest.expect(o[0], unittest.equals('foo'));

864 unittest.expect(o[1], unittest.equals('foo'));

865 }

866

867 buildUnnamed825() {

868 var o = new core.List<core.String>();

869 o.add("foo");

870 o.add("foo");

871 return o;

872 }

873

874 checkUnnamed825(core.List<core.String> o) {

875 unittest.expect(o, unittest.hasLength(2));

876 unittest.expect(o[0], unittest.equals('foo'));

877 unittest.expect(o[1], unittest.equals('foo'));

878 }

879

880 core.int buildCounterReportingMetadataEntry = 0;

881 buildReportingMetadataEntry() {

882 var o = new api.ReportingMetadataEntry();

883 buildCounterReportingMetadataEntry++;

884 if (buildCounterReportingMetadataEntry < 3) {

885 o.compatibleDimensions = buildUnnamed821();

886 o.compatibleMetrics = buildUnnamed822();

887 o.id = "foo";

888 o.kind = "foo";

889 o.requiredDimensions = buildUnnamed823();

890 o.requiredMetrics = buildUnnamed824();

891 o.supportedProducts = buildUnnamed825();

892 }

893 buildCounterReportingMetadataEntry--;

894 return o;

895 }

896

897 checkReportingMetadataEntry(api.ReportingMetadataEntry o) {

898 buildCounterReportingMetadataEntry++;

899 if (buildCounterReportingMetadataEntry < 3) {

900 checkUnnamed821(o.compatibleDimensions);

901 checkUnnamed822(o.compatibleMetrics);

902 unittest.expect(o.id, unittest.equals('foo'));

903 unittest.expect(o.kind, unittest.equals('foo'));

904 checkUnnamed823(o.requiredDimensions);

905 checkUnnamed824(o.requiredMetrics);

906 checkUnnamed825(o.supportedProducts);

907 }

908 buildCounterReportingMetadataEntry--;

909 }

910

911 core.int buildCounterSavedAdStyle = 0;

912 buildSavedAdStyle() {

913 var o = new api.SavedAdStyle();

914 buildCounterSavedAdStyle++;

915 if (buildCounterSavedAdStyle < 3) {

916 o.adStyle = buildAdStyle();

917 o.id = "foo";

918 o.kind = "foo";

919 o.name = "foo";

920 }

921 buildCounterSavedAdStyle--;

922 return o;

923 }

924

925 checkSavedAdStyle(api.SavedAdStyle o) {

926 buildCounterSavedAdStyle++;

927 if (buildCounterSavedAdStyle < 3) {

928 checkAdStyle(o.adStyle);

929 unittest.expect(o.id, unittest.equals('foo'));

930 unittest.expect(o.kind, unittest.equals('foo'));

931 unittest.expect(o.name, unittest.equals('foo'));

932 }

933 buildCounterSavedAdStyle--;

934 }

935

936 buildUnnamed826() {

937 var o = new core.List<api.SavedAdStyle>();

938 o.add(buildSavedAdStyle());

939 o.add(buildSavedAdStyle());

940 return o;

941 }

942

943 checkUnnamed826(core.List<api.SavedAdStyle> o) {

944 unittest.expect(o, unittest.hasLength(2));

945 checkSavedAdStyle(o[0]);

946 checkSavedAdStyle(o[1]);

947 }

948

949 core.int buildCounterSavedAdStyles = 0;

950 buildSavedAdStyles() {

951 var o = new api.SavedAdStyles();

952 buildCounterSavedAdStyles++;

953 if (buildCounterSavedAdStyles < 3) {

954 o.etag = "foo";

955 o.items = buildUnnamed826();

956 o.kind = "foo";

957 o.nextPageToken = "foo";

958 }

959 buildCounterSavedAdStyles--;

960 return o;

961 }

962

963 checkSavedAdStyles(api.SavedAdStyles o) {

964 buildCounterSavedAdStyles++;

965 if (buildCounterSavedAdStyles < 3) {

966 unittest.expect(o.etag, unittest.equals('foo'));

967 checkUnnamed826(o.items);

968 unittest.expect(o.kind, unittest.equals('foo'));

969 unittest.expect(o.nextPageToken, unittest.equals('foo'));

970 }

971 buildCounterSavedAdStyles--;

972 }

973

974 core.int buildCounterSavedReport = 0;

975 buildSavedReport() {

976 var o = new api.SavedReport();

977 buildCounterSavedReport++;

978 if (buildCounterSavedReport < 3) {

979 o.id = "foo";

980 o.kind = "foo";

981 o.name = "foo";

982 }

983 buildCounterSavedReport--;

984 return o;

985 }

986

987 checkSavedReport(api.SavedReport o) {

988 buildCounterSavedReport++;

989 if (buildCounterSavedReport < 3) {

990 unittest.expect(o.id, unittest.equals('foo'));

991 unittest.expect(o.kind, unittest.equals('foo'));

992 unittest.expect(o.name, unittest.equals('foo'));

993 }

994 buildCounterSavedReport--;

995 }

996

997 buildUnnamed827() {

998 var o = new core.List<api.SavedReport>();

999 o.add(buildSavedReport());

1000 o.add(buildSavedReport());

1001 return o;

1002 }

1003

1004 checkUnnamed827(core.List<api.SavedReport> o) {

1005 unittest.expect(o, unittest.hasLength(2));

1006 checkSavedReport(o[0]);

1007 checkSavedReport(o[1]);

1008 }

1009

1010 core.int buildCounterSavedReports = 0;

1011 buildSavedReports() {

1012 var o = new api.SavedReports();

1013 buildCounterSavedReports++;

1014 if (buildCounterSavedReports < 3) {

1015 o.etag = "foo";

1016 o.items = buildUnnamed827();

1017 o.kind = "foo";

1018 o.nextPageToken = "foo";

1019 }

1020 buildCounterSavedReports--;

1021 return o;

1022 }

1023

1024 checkSavedReports(api.SavedReports o) {

1025 buildCounterSavedReports++;

1026 if (buildCounterSavedReports < 3) {

1027 unittest.expect(o.etag, unittest.equals('foo'));

1028 checkUnnamed827(o.items);

1029 unittest.expect(o.kind, unittest.equals('foo'));

1030 unittest.expect(o.nextPageToken, unittest.equals('foo'));

1031 }

1032 buildCounterSavedReports--;

1033 }

1034

1035 core.int buildCounterUrlChannel = 0;

1036 buildUrlChannel() {

1037 var o = new api.UrlChannel();

1038 buildCounterUrlChannel++;

1039 if (buildCounterUrlChannel < 3) {

1040 o.id = "foo";

1041 o.kind = "foo";

1042 o.urlPattern = "foo";

1043 }

1044 buildCounterUrlChannel--;

1045 return o;

1046 }

1047

1048 checkUrlChannel(api.UrlChannel o) {

1049 buildCounterUrlChannel++;

1050 if (buildCounterUrlChannel < 3) {

1051 unittest.expect(o.id, unittest.equals('foo'));

1052 unittest.expect(o.kind, unittest.equals('foo'));

1053 unittest.expect(o.urlPattern, unittest.equals('foo'));

1054 }

1055 buildCounterUrlChannel--;

1056 }

1057

1058 buildUnnamed828() {

1059 var o = new core.List<api.UrlChannel>();

1060 o.add(buildUrlChannel());

1061 o.add(buildUrlChannel());

1062 return o;

1063 }

1064

1065 checkUnnamed828(core.List<api.UrlChannel> o) {

1066 unittest.expect(o, unittest.hasLength(2));

1067 checkUrlChannel(o[0]);

1068 checkUrlChannel(o[1]);

1069 }

1070

1071 core.int buildCounterUrlChannels = 0;

1072 buildUrlChannels() {

1073 var o = new api.UrlChannels();

1074 buildCounterUrlChannels++;

1075 if (buildCounterUrlChannels < 3) {

1076 o.etag = "foo";

1077 o.items = buildUnnamed828();

1078 o.kind = "foo";

1079 o.nextPageToken = "foo";

1080 }

1081 buildCounterUrlChannels--;

1082 return o;

1083 }

1084

1085 checkUrlChannels(api.UrlChannels o) {

1086 buildCounterUrlChannels++;

1087 if (buildCounterUrlChannels < 3) {

1088 unittest.expect(o.etag, unittest.equals('foo'));

1089 checkUnnamed828(o.items);

1090 unittest.expect(o.kind, unittest.equals('foo'));

1091 unittest.expect(o.nextPageToken, unittest.equals('foo'));

1092 }

1093 buildCounterUrlChannels--;

1094 }

1095

1096 buildUnnamed829() {

1097 var o = new core.List<core.String>();

1098 o.add("foo");

1099 o.add("foo");

1100 return o;

1101 }

1102

1103 checkUnnamed829(core.List<core.String> o) {

1104 unittest.expect(o, unittest.hasLength(2));

1105 unittest.expect(o[0], unittest.equals('foo'));

1106 unittest.expect(o[1], unittest.equals('foo'));

1107 }

1108

1109 buildUnnamed830() {

1110 var o = new core.List<core.String>();

1111 o.add("foo");

1112 o.add("foo");

1113 return o;

1114 }

1115

1116 checkUnnamed830(core.List<core.String> o) {

1117 unittest.expect(o, unittest.hasLength(2));

1118 unittest.expect(o[0], unittest.equals('foo'));

1119 unittest.expect(o[1], unittest.equals('foo'));

1120 }

1121

1122 buildUnnamed831() {

1123 var o = new core.List<core.String>();

1124 o.add("foo");

1125 o.add("foo");

1126 return o;

1127 }

1128

1129 checkUnnamed831(core.List<core.String> o) {

1130 unittest.expect(o, unittest.hasLength(2));

1131 unittest.expect(o[0], unittest.equals('foo'));

1132 unittest.expect(o[1], unittest.equals('foo'));

1133 }

1134

1135 buildUnnamed832() {

1136 var o = new core.List<core.String>();

1137 o.add("foo");

1138 o.add("foo");

1139 return o;

1140 }

1141

1142 checkUnnamed832(core.List<core.String> o) {

1143 unittest.expect(o, unittest.hasLength(2));

1144 unittest.expect(o[0], unittest.equals('foo'));

1145 unittest.expect(o[1], unittest.equals('foo'));

1146 }

1147

1148 buildUnnamed833() {

1149 var o = new core.List<core.String>();

1150 o.add("foo");

1151 o.add("foo");

1152 return o;

1153 }

1154

1155 checkUnnamed833(core.List<core.String> o) {

1156 unittest.expect(o, unittest.hasLength(2));

1157 unittest.expect(o[0], unittest.equals('foo'));

1158 unittest.expect(o[1], unittest.equals('foo'));

1159 }

1160

1161 buildUnnamed834() {

1162 var o = new core.List<core.String>();

1163 o.add("foo");

1164 o.add("foo");

1165 return o;

1166 }

1167

1168 checkUnnamed834(core.List<core.String> o) {

1169 unittest.expect(o, unittest.hasLength(2));

1170 unittest.expect(o[0], unittest.equals('foo'));

1171 unittest.expect(o[1], unittest.equals('foo'));

1172 }

1173

1174 buildUnnamed835() {

1175 var o = new core.List<core.String>();

1176 o.add("foo");

1177 o.add("foo");

1178 return o;

1179 }

1180

1181 checkUnnamed835(core.List<core.String> o) {

1182 unittest.expect(o, unittest.hasLength(2));

1183 unittest.expect(o[0], unittest.equals('foo'));

1184 unittest.expect(o[1], unittest.equals('foo'));

1185 }

1186

1187 buildUnnamed836() {

1188 var o = new core.List<core.String>();

1189 o.add("foo");

1190 o.add("foo");

1191 return o;

1192 }

1193

1194 checkUnnamed836(core.List<core.String> o) {

1195 unittest.expect(o, unittest.hasLength(2));

1196 unittest.expect(o[0], unittest.equals('foo'));

1197 unittest.expect(o[1], unittest.equals('foo'));

1198 }

1199

1200 buildUnnamed837() {

1201 var o = new core.List<core.String>();

1202 o.add("foo");

1203 o.add("foo");

1204 return o;

1205 }

1206

1207 checkUnnamed837(core.List<core.String> o) {

1208 unittest.expect(o, unittest.hasLength(2));

1209 unittest.expect(o[0], unittest.equals('foo'));

1210 unittest.expect(o[1], unittest.equals('foo'));

1211 }

1212

1213

1214 main() {

1215 unittest.group("obj-schema-Account", () {

1216 unittest.test("to-json--from-json", () {

1217 var o = buildAccount();

1218 var od = new api.Account.fromJson(o.toJson());

1219 checkAccount(od);

1220 });

1221 });

1222

1223

1224 unittest.group("obj-schema-Accounts", () {

1225 unittest.test("to-json--from-json", () {

1226 var o = buildAccounts();

1227 var od = new api.Accounts.fromJson(o.toJson());

1228 checkAccounts(od);

1229 });

1230 });

1231

1232

1233 unittest.group("obj-schema-AdClient", () {

1234 unittest.test("to-json--from-json", () {

1235 var o = buildAdClient();

1236 var od = new api.AdClient.fromJson(o.toJson());

1237 checkAdClient(od);

1238 });

1239 });

1240

1241

1242 unittest.group("obj-schema-AdClients", () {

1243 unittest.test("to-json--from-json", () {

1244 var o = buildAdClients();

1245 var od = new api.AdClients.fromJson(o.toJson());

1246 checkAdClients(od);

1247 });

1248 });

1249

1250

1251 unittest.group("obj-schema-AdCode", () {

1252 unittest.test("to-json--from-json", () {

1253 var o = buildAdCode();

1254 var od = new api.AdCode.fromJson(o.toJson());

1255 checkAdCode(od);

1256 });

1257 });

1258

1259

1260 unittest.group("obj-schema-AdStyleColors", () {

1261 unittest.test("to-json--from-json", () {

1262 var o = buildAdStyleColors();

1263 var od = new api.AdStyleColors.fromJson(o.toJson());

1264 checkAdStyleColors(od);

1265 });

1266 });

1267

1268

1269 unittest.group("obj-schema-AdStyleFont", () {

1270 unittest.test("to-json--from-json", () {

1271 var o = buildAdStyleFont();

1272 var od = new api.AdStyleFont.fromJson(o.toJson());

1273 checkAdStyleFont(od);

1274 });

1275 });

1276

1277

1278 unittest.group("obj-schema-AdStyle", () {

1279 unittest.test("to-json--from-json", () {

1280 var o = buildAdStyle();

1281 var od = new api.AdStyle.fromJson(o.toJson());

1282 checkAdStyle(od);

1283 });

1284 });

1285

1286

1287 unittest.group("obj-schema-AdUnitContentAdsSettingsBackupOption", () {

1288 unittest.test("to-json--from-json", () {

1289 var o = buildAdUnitContentAdsSettingsBackupOption();

1290 var od = new api.AdUnitContentAdsSettingsBackupOption.fromJson(o.toJson()) ;

1291 checkAdUnitContentAdsSettingsBackupOption(od);

1292 });

1293 });

1294

1295

1296 unittest.group("obj-schema-AdUnitContentAdsSettings", () {

1297 unittest.test("to-json--from-json", () {

1298 var o = buildAdUnitContentAdsSettings();

1299 var od = new api.AdUnitContentAdsSettings.fromJson(o.toJson());

1300 checkAdUnitContentAdsSettings(od);

1301 });

1302 });

1303

1304

1305 unittest.group("obj-schema-AdUnitFeedAdsSettings", () {

1306 unittest.test("to-json--from-json", () {

1307 var o = buildAdUnitFeedAdsSettings();

1308 var od = new api.AdUnitFeedAdsSettings.fromJson(o.toJson());

1309 checkAdUnitFeedAdsSettings(od);

1310 });

1311 });

1312

1313

1314 unittest.group("obj-schema-AdUnitMobileContentAdsSettings", () {

1315 unittest.test("to-json--from-json", () {

1316 var o = buildAdUnitMobileContentAdsSettings();

1317 var od = new api.AdUnitMobileContentAdsSettings.fromJson(o.toJson());

1318 checkAdUnitMobileContentAdsSettings(od);

1319 });

1320 });

1321

1322

1323 unittest.group("obj-schema-AdUnit", () {

1324 unittest.test("to-json--from-json", () {

1325 var o = buildAdUnit();

1326 var od = new api.AdUnit.fromJson(o.toJson());

1327 checkAdUnit(od);

1328 });

1329 });

1330

1331

1332 unittest.group("obj-schema-AdUnits", () {

1333 unittest.test("to-json--from-json", () {

1334 var o = buildAdUnits();

1335 var od = new api.AdUnits.fromJson(o.toJson());

1336 checkAdUnits(od);

1337 });

1338 });

1339

1340

1341 unittest.group("obj-schema-AdsenseReportsGenerateResponseHeaders", () {

1342 unittest.test("to-json--from-json", () {

1343 var o = buildAdsenseReportsGenerateResponseHeaders();

1344 var od = new api.AdsenseReportsGenerateResponseHeaders.fromJson(o.toJson() );

1345 checkAdsenseReportsGenerateResponseHeaders(od);

1346 });

1347 });

1348

1349

1350 unittest.group("obj-schema-AdsenseReportsGenerateResponse", () {

1351 unittest.test("to-json--from-json", () {

1352 var o = buildAdsenseReportsGenerateResponse();

1353 var od = new api.AdsenseReportsGenerateResponse.fromJson(o.toJson());

1354 checkAdsenseReportsGenerateResponse(od);

1355 });

1356 });

1357

1358

1359 unittest.group("obj-schema-Alert", () {

1360 unittest.test("to-json--from-json", () {

1361 var o = buildAlert();

1362 var od = new api.Alert.fromJson(o.toJson());

1363 checkAlert(od);

1364 });

1365 });

1366

1367

1368 unittest.group("obj-schema-Alerts", () {

1369 unittest.test("to-json--from-json", () {

1370 var o = buildAlerts();

1371 var od = new api.Alerts.fromJson(o.toJson());

1372 checkAlerts(od);

1373 });

1374 });

1375

1376

1377 unittest.group("obj-schema-CustomChannelTargetingInfo", () {

1378 unittest.test("to-json--from-json", () {

1379 var o = buildCustomChannelTargetingInfo();

1380 var od = new api.CustomChannelTargetingInfo.fromJson(o.toJson());

1381 checkCustomChannelTargetingInfo(od);

1382 });

1383 });

1384

1385

1386 unittest.group("obj-schema-CustomChannel", () {

1387 unittest.test("to-json--from-json", () {

1388 var o = buildCustomChannel();

1389 var od = new api.CustomChannel.fromJson(o.toJson());

1390 checkCustomChannel(od);

1391 });

1392 });

1393

1394

1395 unittest.group("obj-schema-CustomChannels", () {

1396 unittest.test("to-json--from-json", () {

1397 var o = buildCustomChannels();

1398 var od = new api.CustomChannels.fromJson(o.toJson());

1399 checkCustomChannels(od);

1400 });

1401 });

1402

1403

1404 unittest.group("obj-schema-Metadata", () {

1405 unittest.test("to-json--from-json", () {

1406 var o = buildMetadata();

1407 var od = new api.Metadata.fromJson(o.toJson());

1408 checkMetadata(od);

1409 });

1410 });

1411

1412

1413 unittest.group("obj-schema-Payment", () {

1414 unittest.test("to-json--from-json", () {

1415 var o = buildPayment();

1416 var od = new api.Payment.fromJson(o.toJson());

1417 checkPayment(od);

1418 });

1419 });

1420

1421

1422 unittest.group("obj-schema-Payments", () {

1423 unittest.test("to-json--from-json", () {

1424 var o = buildPayments();

1425 var od = new api.Payments.fromJson(o.toJson());

1426 checkPayments(od);

1427 });

1428 });

1429

1430

1431 unittest.group("obj-schema-ReportingMetadataEntry", () {

1432 unittest.test("to-json--from-json", () {

1433 var o = buildReportingMetadataEntry();

1434 var od = new api.ReportingMetadataEntry.fromJson(o.toJson());

1435 checkReportingMetadataEntry(od);

1436 });

1437 });

1438

1439

1440 unittest.group("obj-schema-SavedAdStyle", () {

1441 unittest.test("to-json--from-json", () {

1442 var o = buildSavedAdStyle();

1443 var od = new api.SavedAdStyle.fromJson(o.toJson());

1444 checkSavedAdStyle(od);

1445 });

1446 });

1447

1448

1449 unittest.group("obj-schema-SavedAdStyles", () {

1450 unittest.test("to-json--from-json", () {

1451 var o = buildSavedAdStyles();

1452 var od = new api.SavedAdStyles.fromJson(o.toJson());

1453 checkSavedAdStyles(od);

1454 });

1455 });

1456

1457

1458 unittest.group("obj-schema-SavedReport", () {

1459 unittest.test("to-json--from-json", () {

1460 var o = buildSavedReport();

1461 var od = new api.SavedReport.fromJson(o.toJson());

1462 checkSavedReport(od);

1463 });

1464 });

1465

1466

1467 unittest.group("obj-schema-SavedReports", () {

1468 unittest.test("to-json--from-json", () {

1469 var o = buildSavedReports();

1470 var od = new api.SavedReports.fromJson(o.toJson());

1471 checkSavedReports(od);

1472 });

1473 });

1474

1475

1476 unittest.group("obj-schema-UrlChannel", () {

1477 unittest.test("to-json--from-json", () {

1478 var o = buildUrlChannel();

1479 var od = new api.UrlChannel.fromJson(o.toJson());

1480 checkUrlChannel(od);

1481 });

1482 });

1483

1484

1485 unittest.group("obj-schema-UrlChannels", () {

1486 unittest.test("to-json--from-json", () {

1487 var o = buildUrlChannels();

1488 var od = new api.UrlChannels.fromJson(o.toJson());

1489 checkUrlChannels(od);

1490 });

1491 });

1492

1493

1494 unittest.group("resource-AccountsResourceApi", () {

1495 unittest.test("method--get", () {

1496

1497 var mock = new common_test.HttpServerMock();

1498 api.AccountsResourceApi res = new api.AdsenseApi(mock).accounts;

1499 var arg_accountId = "foo";

1500 var arg_tree = true;

1501 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1502 var path = (req.url).path;

1503 var pathOffset = 0;

1504 var index;

1505 var subPart;

1506 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1507 pathOffset += 14;

1508 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1509 pathOffset += 9;

1510 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1511 pathOffset = path.length;

1512 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1513

1514 var query = (req.url).query;

1515 var queryOffset = 0;

1516 var queryMap = {};

1517 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1518 parseBool(n) {

1519 if (n == "true") return true;

1520 if (n == "false") return false;

1521 if (n == null) return null;

1522 throw new core.ArgumentError("Invalid boolean: $n");

1523 }

1524 if (query.length > 0) {

1525 for (var part in query.split("&")) {

1526 var keyvalue = part.split("=");

1527 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1528 }

1529 }

1530 unittest.expect(queryMap["tree"].first, unittest.equals("$arg_tree"));

1531

1532

1533 var h = {

1534 "content-type" : "application/json; charset=utf-8",

1535 };

1536 var resp = convert.JSON.encode(buildAccount());

1537 return new async.Future.value(common_test.stringResponse(200, h, resp));

1538 }), true);

1539 res.get(arg_accountId, tree: arg_tree).then(unittest.expectAsync(((api.Acc ount response) {

1540 checkAccount(response);

1541 })));

1542 });

1543

1544 unittest.test("method--list", () {

1545

1546 var mock = new common_test.HttpServerMock();

1547 api.AccountsResourceApi res = new api.AdsenseApi(mock).accounts;

1548 var arg_maxResults = 42;

1549 var arg_pageToken = "foo";

1550 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1551 var path = (req.url).path;

1552 var pathOffset = 0;

1553 var index;

1554 var subPart;

1555 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1556 pathOffset += 14;

1557 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("accounts"));

1558 pathOffset += 8;

1559

1560 var query = (req.url).query;

1561 var queryOffset = 0;

1562 var queryMap = {};

1563 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1564 parseBool(n) {

1565 if (n == "true") return true;

1566 if (n == "false") return false;

1567 if (n == null) return null;

1568 throw new core.ArgumentError("Invalid boolean: $n");

1569 }

1570 if (query.length > 0) {

1571 for (var part in query.split("&")) {

1572 var keyvalue = part.split("=");

1573 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1574 }

1575 }

1576 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

1577 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

1578

1579

1580 var h = {

1581 "content-type" : "application/json; charset=utf-8",

1582 };

1583 var resp = convert.JSON.encode(buildAccounts());

1584 return new async.Future.value(common_test.stringResponse(200, h, resp));

1585 }), true);

1586 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken).then(unitte st.expectAsync(((api.Accounts response) {

1587 checkAccounts(response);

1588 })));

1589 });

1590

1591 });

1592

1593

1594 unittest.group("resource-AccountsAdclientsResourceApi", () {

1595 unittest.test("method--list", () {

1596

1597 var mock = new common_test.HttpServerMock();

1598 api.AccountsAdclientsResourceApi res = new api.AdsenseApi(mock).accounts.a dclients;

1599 var arg_accountId = "foo";

1600 var arg_maxResults = 42;

1601 var arg_pageToken = "foo";

1602 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1603 var path = (req.url).path;

1604 var pathOffset = 0;

1605 var index;

1606 var subPart;

1607 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1608 pathOffset += 14;

1609 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1610 pathOffset += 9;

1611 index = path.indexOf("/adclients", pathOffset);

1612 unittest.expect(index >= 0, unittest.isTrue);

1613 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1614 pathOffset = index;

1615 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1616 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("/adclients"));

1617 pathOffset += 10;

1618

1619 var query = (req.url).query;

1620 var queryOffset = 0;

1621 var queryMap = {};

1622 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1623 parseBool(n) {

1624 if (n == "true") return true;

1625 if (n == "false") return false;

1626 if (n == null) return null;

1627 throw new core.ArgumentError("Invalid boolean: $n");

1628 }

1629 if (query.length > 0) {

1630 for (var part in query.split("&")) {

1631 var keyvalue = part.split("=");

1632 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1633 }

1634 }

1635 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

1636 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

1637

1638

1639 var h = {

1640 "content-type" : "application/json; charset=utf-8",

1641 };

1642 var resp = convert.JSON.encode(buildAdClients());

1643 return new async.Future.value(common_test.stringResponse(200, h, resp));

1644 }), true);

1645 res.list(arg_accountId, maxResults: arg_maxResults, pageToken: arg_pageTok en).then(unittest.expectAsync(((api.AdClients response) {

1646 checkAdClients(response);

1647 })));

1648 });

1649

1650 });

1651

1652

1653 unittest.group("resource-AccountsAdunitsResourceApi", () {

1654 unittest.test("method--get", () {

1655

1656 var mock = new common_test.HttpServerMock();

1657 api.AccountsAdunitsResourceApi res = new api.AdsenseApi(mock).accounts.adu nits;

1658 var arg_accountId = "foo";

1659 var arg_adClientId = "foo";

1660 var arg_adUnitId = "foo";

1661 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1662 var path = (req.url).path;

1663 var pathOffset = 0;

1664 var index;

1665 var subPart;

1666 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1667 pathOffset += 14;

1668 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1669 pathOffset += 9;

1670 index = path.indexOf("/adclients/", pathOffset);

1671 unittest.expect(index >= 0, unittest.isTrue);

1672 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1673 pathOffset = index;

1674 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1675 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

1676 pathOffset += 11;

1677 index = path.indexOf("/adunits/", pathOffset);

1678 unittest.expect(index >= 0, unittest.isTrue);

1679 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1680 pathOffset = index;

1681 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

1682 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

1683 pathOffset += 9;

1684 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1685 pathOffset = path.length;

1686 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

1687

1688 var query = (req.url).query;

1689 var queryOffset = 0;

1690 var queryMap = {};

1691 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1692 parseBool(n) {

1693 if (n == "true") return true;

1694 if (n == "false") return false;

1695 if (n == null) return null;

1696 throw new core.ArgumentError("Invalid boolean: $n");

1697 }

1698 if (query.length > 0) {

1699 for (var part in query.split("&")) {

1700 var keyvalue = part.split("=");

1701 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1702 }

1703 }

1704

1705

1706 var h = {

1707 "content-type" : "application/json; charset=utf-8",

1708 };

1709 var resp = convert.JSON.encode(buildAdUnit());

1710 return new async.Future.value(common_test.stringResponse(200, h, resp));

1711 }), true);

1712 res.get(arg_accountId, arg_adClientId, arg_adUnitId).then(unittest.expectA sync(((api.AdUnit response) {

1713 checkAdUnit(response);

1714 })));

1715 });

1716

1717 unittest.test("method--getAdCode", () {

1718

1719 var mock = new common_test.HttpServerMock();

1720 api.AccountsAdunitsResourceApi res = new api.AdsenseApi(mock).accounts.adu nits;

1721 var arg_accountId = "foo";

1722 var arg_adClientId = "foo";

1723 var arg_adUnitId = "foo";

1724 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1725 var path = (req.url).path;

1726 var pathOffset = 0;

1727 var index;

1728 var subPart;

1729 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1730 pathOffset += 14;

1731 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1732 pathOffset += 9;

1733 index = path.indexOf("/adclients/", pathOffset);

1734 unittest.expect(index >= 0, unittest.isTrue);

1735 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1736 pathOffset = index;

1737 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1738 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

1739 pathOffset += 11;

1740 index = path.indexOf("/adunits/", pathOffset);

1741 unittest.expect(index >= 0, unittest.isTrue);

1742 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1743 pathOffset = index;

1744 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

1745 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

1746 pathOffset += 9;

1747 index = path.indexOf("/adcode", pathOffset);

1748 unittest.expect(index >= 0, unittest.isTrue);

1749 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1750 pathOffset = index;

1751 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

1752 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/adcode"));

1753 pathOffset += 7;

1754

1755 var query = (req.url).query;

1756 var queryOffset = 0;

1757 var queryMap = {};

1758 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1759 parseBool(n) {

1760 if (n == "true") return true;

1761 if (n == "false") return false;

1762 if (n == null) return null;

1763 throw new core.ArgumentError("Invalid boolean: $n");

1764 }

1765 if (query.length > 0) {

1766 for (var part in query.split("&")) {

1767 var keyvalue = part.split("=");

1768 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1769 }

1770 }

1771

1772

1773 var h = {

1774 "content-type" : "application/json; charset=utf-8",

1775 };

1776 var resp = convert.JSON.encode(buildAdCode());

1777 return new async.Future.value(common_test.stringResponse(200, h, resp));

1778 }), true);

1779 res.getAdCode(arg_accountId, arg_adClientId, arg_adUnitId).then(unittest.e xpectAsync(((api.AdCode response) {

1780 checkAdCode(response);

1781 })));

1782 });

1783

1784 unittest.test("method--list", () {

1785

1786 var mock = new common_test.HttpServerMock();

1787 api.AccountsAdunitsResourceApi res = new api.AdsenseApi(mock).accounts.adu nits;

1788 var arg_accountId = "foo";

1789 var arg_adClientId = "foo";

1790 var arg_includeInactive = true;

1791 var arg_maxResults = 42;

1792 var arg_pageToken = "foo";

1793 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1794 var path = (req.url).path;

1795 var pathOffset = 0;

1796 var index;

1797 var subPart;

1798 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1799 pathOffset += 14;

1800 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1801 pathOffset += 9;

1802 index = path.indexOf("/adclients/", pathOffset);

1803 unittest.expect(index >= 0, unittest.isTrue);

1804 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1805 pathOffset = index;

1806 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1807 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

1808 pathOffset += 11;

1809 index = path.indexOf("/adunits", pathOffset);

1810 unittest.expect(index >= 0, unittest.isTrue);

1811 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1812 pathOffset = index;

1813 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

1814 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/adunits"));

1815 pathOffset += 8;

1816

1817 var query = (req.url).query;

1818 var queryOffset = 0;

1819 var queryMap = {};

1820 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1821 parseBool(n) {

1822 if (n == "true") return true;

1823 if (n == "false") return false;

1824 if (n == null) return null;

1825 throw new core.ArgumentError("Invalid boolean: $n");

1826 }

1827 if (query.length > 0) {

1828 for (var part in query.split("&")) {

1829 var keyvalue = part.split("=");

1830 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1831 }

1832 }

1833 unittest.expect(queryMap["includeInactive"].first, unittest.equals("$arg _includeInactive"));

1834 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

1835 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

1836

1837

1838 var h = {

1839 "content-type" : "application/json; charset=utf-8",

1840 };

1841 var resp = convert.JSON.encode(buildAdUnits());

1842 return new async.Future.value(common_test.stringResponse(200, h, resp));

1843 }), true);

1844 res.list(arg_accountId, arg_adClientId, includeInactive: arg_includeInacti ve, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAs ync(((api.AdUnits response) {

1845 checkAdUnits(response);

1846 })));

1847 });

1848

1849 });

1850

1851

1852 unittest.group("resource-AccountsAdunitsCustomchannelsResourceApi", () {

1853 unittest.test("method--list", () {

1854

1855 var mock = new common_test.HttpServerMock();

1856 api.AccountsAdunitsCustomchannelsResourceApi res = new api.AdsenseApi(mock ).accounts.adunits.customchannels;

1857 var arg_accountId = "foo";

1858 var arg_adClientId = "foo";

1859 var arg_adUnitId = "foo";

1860 var arg_maxResults = 42;

1861 var arg_pageToken = "foo";

1862 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1863 var path = (req.url).path;

1864 var pathOffset = 0;

1865 var index;

1866 var subPart;

1867 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1868 pathOffset += 14;

1869 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1870 pathOffset += 9;

1871 index = path.indexOf("/adclients/", pathOffset);

1872 unittest.expect(index >= 0, unittest.isTrue);

1873 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1874 pathOffset = index;

1875 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1876 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

1877 pathOffset += 11;

1878 index = path.indexOf("/adunits/", pathOffset);

1879 unittest.expect(index >= 0, unittest.isTrue);

1880 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1881 pathOffset = index;

1882 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

1883 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

1884 pathOffset += 9;

1885 index = path.indexOf("/customchannels", pathOffset);

1886 unittest.expect(index >= 0, unittest.isTrue);

1887 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1888 pathOffset = index;

1889 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

1890 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/customchannels"));

1891 pathOffset += 15;

1892

1893 var query = (req.url).query;

1894 var queryOffset = 0;

1895 var queryMap = {};

1896 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1897 parseBool(n) {

1898 if (n == "true") return true;

1899 if (n == "false") return false;

1900 if (n == null) return null;

1901 throw new core.ArgumentError("Invalid boolean: $n");

1902 }

1903 if (query.length > 0) {

1904 for (var part in query.split("&")) {

1905 var keyvalue = part.split("=");

1906 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1907 }

1908 }

1909 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

1910 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

1911

1912

1913 var h = {

1914 "content-type" : "application/json; charset=utf-8",

1915 };

1916 var resp = convert.JSON.encode(buildCustomChannels());

1917 return new async.Future.value(common_test.stringResponse(200, h, resp));

1918 }), true);

1919 res.list(arg_accountId, arg_adClientId, arg_adUnitId, maxResults: arg_maxR esults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.CustomChannels response) {

1920 checkCustomChannels(response);

1921 })));

1922 });

1923

1924 });

1925

1926

1927 unittest.group("resource-AccountsAlertsResourceApi", () {

1928 unittest.test("method--delete", () {

1929

1930 var mock = new common_test.HttpServerMock();

1931 api.AccountsAlertsResourceApi res = new api.AdsenseApi(mock).accounts.aler ts;

1932 var arg_accountId = "foo";

1933 var arg_alertId = "foo";

1934 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1935 var path = (req.url).path;

1936 var pathOffset = 0;

1937 var index;

1938 var subPart;

1939 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1940 pathOffset += 14;

1941 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1942 pathOffset += 9;

1943 index = path.indexOf("/alerts/", pathOffset);

1944 unittest.expect(index >= 0, unittest.isTrue);

1945 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1946 pathOffset = index;

1947 unittest.expect(subPart, unittest.equals("$arg_accountId"));

1948 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/alerts/"));

1949 pathOffset += 8;

1950 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

1951 pathOffset = path.length;

1952 unittest.expect(subPart, unittest.equals("$arg_alertId"));

1953

1954 var query = (req.url).query;

1955 var queryOffset = 0;

1956 var queryMap = {};

1957 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

1958 parseBool(n) {

1959 if (n == "true") return true;

1960 if (n == "false") return false;

1961 if (n == null) return null;

1962 throw new core.ArgumentError("Invalid boolean: $n");

1963 }

1964 if (query.length > 0) {

1965 for (var part in query.split("&")) {

1966 var keyvalue = part.split("=");

1967 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

1968 }

1969 }

1970

1971

1972 var h = {

1973 "content-type" : "application/json; charset=utf-8",

1974 };

1975 var resp = "";

1976 return new async.Future.value(common_test.stringResponse(200, h, resp));

1977 }), true);

1978 res.delete(arg_accountId, arg_alertId).then(unittest.expectAsync((_) {}));

1979 });

1980

1981 unittest.test("method--list", () {

1982

1983 var mock = new common_test.HttpServerMock();

1984 api.AccountsAlertsResourceApi res = new api.AdsenseApi(mock).accounts.aler ts;

1985 var arg_accountId = "foo";

1986 var arg_locale = "foo";

1987 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

1988 var path = (req.url).path;

1989 var pathOffset = 0;

1990 var index;

1991 var subPart;

1992 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

1993 pathOffset += 14;

1994 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

1995 pathOffset += 9;

1996 index = path.indexOf("/alerts", pathOffset);

1997 unittest.expect(index >= 0, unittest.isTrue);

1998 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

1999 pathOffset = index;

2000 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2001 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/alerts"));

2002 pathOffset += 7;

2003

2004 var query = (req.url).query;

2005 var queryOffset = 0;

2006 var queryMap = {};

2007 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2008 parseBool(n) {

2009 if (n == "true") return true;

2010 if (n == "false") return false;

2011 if (n == null) return null;

2012 throw new core.ArgumentError("Invalid boolean: $n");

2013 }

2014 if (query.length > 0) {

2015 for (var part in query.split("&")) {

2016 var keyvalue = part.split("=");

2017 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2018 }

2019 }

2020 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

2021

2022

2023 var h = {

2024 "content-type" : "application/json; charset=utf-8",

2025 };

2026 var resp = convert.JSON.encode(buildAlerts());

2027 return new async.Future.value(common_test.stringResponse(200, h, resp));

2028 }), true);

2029 res.list(arg_accountId, locale: arg_locale).then(unittest.expectAsync(((ap i.Alerts response) {

2030 checkAlerts(response);

2031 })));

2032 });

2033

2034 });

2035

2036

2037 unittest.group("resource-AccountsCustomchannelsResourceApi", () {

2038 unittest.test("method--get", () {

2039

2040 var mock = new common_test.HttpServerMock();

2041 api.AccountsCustomchannelsResourceApi res = new api.AdsenseApi(mock).accou nts.customchannels;

2042 var arg_accountId = "foo";

2043 var arg_adClientId = "foo";

2044 var arg_customChannelId = "foo";

2045 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2046 var path = (req.url).path;

2047 var pathOffset = 0;

2048 var index;

2049 var subPart;

2050 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2051 pathOffset += 14;

2052 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2053 pathOffset += 9;

2054 index = path.indexOf("/adclients/", pathOffset);

2055 unittest.expect(index >= 0, unittest.isTrue);

2056 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2057 pathOffset = index;

2058 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2059 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

2060 pathOffset += 11;

2061 index = path.indexOf("/customchannels/", pathOffset);

2062 unittest.expect(index >= 0, unittest.isTrue);

2063 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2064 pathOffset = index;

2065 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2066 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/customchannels/"));

2067 pathOffset += 16;

2068 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2069 pathOffset = path.length;

2070 unittest.expect(subPart, unittest.equals("$arg_customChannelId"));

2071

2072 var query = (req.url).query;

2073 var queryOffset = 0;

2074 var queryMap = {};

2075 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2076 parseBool(n) {

2077 if (n == "true") return true;

2078 if (n == "false") return false;

2079 if (n == null) return null;

2080 throw new core.ArgumentError("Invalid boolean: $n");

2081 }

2082 if (query.length > 0) {

2083 for (var part in query.split("&")) {

2084 var keyvalue = part.split("=");

2085 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2086 }

2087 }

2088

2089

2090 var h = {

2091 "content-type" : "application/json; charset=utf-8",

2092 };

2093 var resp = convert.JSON.encode(buildCustomChannel());

2094 return new async.Future.value(common_test.stringResponse(200, h, resp));

2095 }), true);

2096 res.get(arg_accountId, arg_adClientId, arg_customChannelId).then(unittest. expectAsync(((api.CustomChannel response) {

2097 checkCustomChannel(response);

2098 })));

2099 });

2100

2101 unittest.test("method--list", () {

2102

2103 var mock = new common_test.HttpServerMock();

2104 api.AccountsCustomchannelsResourceApi res = new api.AdsenseApi(mock).accou nts.customchannels;

2105 var arg_accountId = "foo";

2106 var arg_adClientId = "foo";

2107 var arg_maxResults = 42;

2108 var arg_pageToken = "foo";

2109 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2110 var path = (req.url).path;

2111 var pathOffset = 0;

2112 var index;

2113 var subPart;

2114 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2115 pathOffset += 14;

2116 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2117 pathOffset += 9;

2118 index = path.indexOf("/adclients/", pathOffset);

2119 unittest.expect(index >= 0, unittest.isTrue);

2120 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2121 pathOffset = index;

2122 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2123 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

2124 pathOffset += 11;

2125 index = path.indexOf("/customchannels", pathOffset);

2126 unittest.expect(index >= 0, unittest.isTrue);

2127 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2128 pathOffset = index;

2129 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2130 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/customchannels"));

2131 pathOffset += 15;

2132

2133 var query = (req.url).query;

2134 var queryOffset = 0;

2135 var queryMap = {};

2136 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2137 parseBool(n) {

2138 if (n == "true") return true;

2139 if (n == "false") return false;

2140 if (n == null) return null;

2141 throw new core.ArgumentError("Invalid boolean: $n");

2142 }

2143 if (query.length > 0) {

2144 for (var part in query.split("&")) {

2145 var keyvalue = part.split("=");

2146 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2147 }

2148 }

2149 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2150 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2151

2152

2153 var h = {

2154 "content-type" : "application/json; charset=utf-8",

2155 };

2156 var resp = convert.JSON.encode(buildCustomChannels());

2157 return new async.Future.value(common_test.stringResponse(200, h, resp));

2158 }), true);

2159 res.list(arg_accountId, arg_adClientId, maxResults: arg_maxResults, pageTo ken: arg_pageToken).then(unittest.expectAsync(((api.CustomChannels response) {

2160 checkCustomChannels(response);

2161 })));

2162 });

2163

2164 });

2165

2166

2167 unittest.group("resource-AccountsCustomchannelsAdunitsResourceApi", () {

2168 unittest.test("method--list", () {

2169

2170 var mock = new common_test.HttpServerMock();

2171 api.AccountsCustomchannelsAdunitsResourceApi res = new api.AdsenseApi(mock ).accounts.customchannels.adunits;

2172 var arg_accountId = "foo";

2173 var arg_adClientId = "foo";

2174 var arg_customChannelId = "foo";

2175 var arg_includeInactive = true;

2176 var arg_maxResults = 42;

2177 var arg_pageToken = "foo";

2178 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2179 var path = (req.url).path;

2180 var pathOffset = 0;

2181 var index;

2182 var subPart;

2183 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2184 pathOffset += 14;

2185 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2186 pathOffset += 9;

2187 index = path.indexOf("/adclients/", pathOffset);

2188 unittest.expect(index >= 0, unittest.isTrue);

2189 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2190 pathOffset = index;

2191 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2192 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

2193 pathOffset += 11;

2194 index = path.indexOf("/customchannels/", pathOffset);

2195 unittest.expect(index >= 0, unittest.isTrue);

2196 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2197 pathOffset = index;

2198 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2199 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/customchannels/"));

2200 pathOffset += 16;

2201 index = path.indexOf("/adunits", pathOffset);

2202 unittest.expect(index >= 0, unittest.isTrue);

2203 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2204 pathOffset = index;

2205 unittest.expect(subPart, unittest.equals("$arg_customChannelId"));

2206 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/adunits"));

2207 pathOffset += 8;

2208

2209 var query = (req.url).query;

2210 var queryOffset = 0;

2211 var queryMap = {};

2212 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2213 parseBool(n) {

2214 if (n == "true") return true;

2215 if (n == "false") return false;

2216 if (n == null) return null;

2217 throw new core.ArgumentError("Invalid boolean: $n");

2218 }

2219 if (query.length > 0) {

2220 for (var part in query.split("&")) {

2221 var keyvalue = part.split("=");

2222 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2223 }

2224 }

2225 unittest.expect(queryMap["includeInactive"].first, unittest.equals("$arg _includeInactive"));

2226 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2227 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2228

2229

2230 var h = {

2231 "content-type" : "application/json; charset=utf-8",

2232 };

2233 var resp = convert.JSON.encode(buildAdUnits());

2234 return new async.Future.value(common_test.stringResponse(200, h, resp));

2235 }), true);

2236 res.list(arg_accountId, arg_adClientId, arg_customChannelId, includeInacti ve: arg_includeInactive, maxResults: arg_maxResults, pageToken: arg_pageToken).t hen(unittest.expectAsync(((api.AdUnits response) {

2237 checkAdUnits(response);

2238 })));

2239 });

2240

2241 });

2242

2243

2244 unittest.group("resource-AccountsPaymentsResourceApi", () {

2245 unittest.test("method--list", () {

2246

2247 var mock = new common_test.HttpServerMock();

2248 api.AccountsPaymentsResourceApi res = new api.AdsenseApi(mock).accounts.pa yments;

2249 var arg_accountId = "foo";

2250 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2251 var path = (req.url).path;

2252 var pathOffset = 0;

2253 var index;

2254 var subPart;

2255 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2256 pathOffset += 14;

2257 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2258 pathOffset += 9;

2259 index = path.indexOf("/payments", pathOffset);

2260 unittest.expect(index >= 0, unittest.isTrue);

2261 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2262 pathOffset = index;

2263 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2264 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/payments"));

2265 pathOffset += 9;

2266

2267 var query = (req.url).query;

2268 var queryOffset = 0;

2269 var queryMap = {};

2270 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2271 parseBool(n) {

2272 if (n == "true") return true;

2273 if (n == "false") return false;

2274 if (n == null) return null;

2275 throw new core.ArgumentError("Invalid boolean: $n");

2276 }

2277 if (query.length > 0) {

2278 for (var part in query.split("&")) {

2279 var keyvalue = part.split("=");

2280 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2281 }

2282 }

2283

2284

2285 var h = {

2286 "content-type" : "application/json; charset=utf-8",

2287 };

2288 var resp = convert.JSON.encode(buildPayments());

2289 return new async.Future.value(common_test.stringResponse(200, h, resp));

2290 }), true);

2291 res.list(arg_accountId).then(unittest.expectAsync(((api.Payments response) {

2292 checkPayments(response);

2293 })));

2294 });

2295

2296 });

2297

2298

2299 unittest.group("resource-AccountsReportsResourceApi", () {

2300 unittest.test("method--generate", () {

2301 // TODO: Implement tests for media upload;

2302 // TODO: Implement tests for media download;

2303

2304 var mock = new common_test.HttpServerMock();

2305 api.AccountsReportsResourceApi res = new api.AdsenseApi(mock).accounts.rep orts;

2306 var arg_accountId = "foo";

2307 var arg_startDate = "foo";

2308 var arg_endDate = "foo";

2309 var arg_currency = "foo";

2310 var arg_dimension = buildUnnamed829();

2311 var arg_filter = buildUnnamed830();

2312 var arg_locale = "foo";

2313 var arg_maxResults = 42;

2314 var arg_metric = buildUnnamed831();

2315 var arg_sort = buildUnnamed832();

2316 var arg_startIndex = 42;

2317 var arg_useTimezoneReporting = true;

2318 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2319 var path = (req.url).path;

2320 var pathOffset = 0;

2321 var index;

2322 var subPart;

2323 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2324 pathOffset += 14;

2325 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2326 pathOffset += 9;

2327 index = path.indexOf("/reports", pathOffset);

2328 unittest.expect(index >= 0, unittest.isTrue);

2329 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2330 pathOffset = index;

2331 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2332 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/reports"));

2333 pathOffset += 8;

2334

2335 var query = (req.url).query;

2336 var queryOffset = 0;

2337 var queryMap = {};

2338 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2339 parseBool(n) {

2340 if (n == "true") return true;

2341 if (n == "false") return false;

2342 if (n == null) return null;

2343 throw new core.ArgumentError("Invalid boolean: $n");

2344 }

2345 if (query.length > 0) {

2346 for (var part in query.split("&")) {

2347 var keyvalue = part.split("=");

2348 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2349 }

2350 }

2351 unittest.expect(queryMap["startDate"].first, unittest.equals(arg_startDa te));

2352 unittest.expect(queryMap["endDate"].first, unittest.equals(arg_endDate)) ;

2353 unittest.expect(queryMap["currency"].first, unittest.equals(arg_currency ));

2354 unittest.expect(queryMap["dimension"], unittest.equals(arg_dimension));

2355 unittest.expect(queryMap["filter"], unittest.equals(arg_filter));

2356 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

2357 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2358 unittest.expect(queryMap["metric"], unittest.equals(arg_metric));

2359 unittest.expect(queryMap["sort"], unittest.equals(arg_sort));

2360 unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.e quals(arg_startIndex));

2361 unittest.expect(queryMap["useTimezoneReporting"].first, unittest.equals( "$arg_useTimezoneReporting"));

2362

2363

2364 var h = {

2365 "content-type" : "application/json; charset=utf-8",

2366 };

2367 var resp = convert.JSON.encode(buildAdsenseReportsGenerateResponse());

2368 return new async.Future.value(common_test.stringResponse(200, h, resp));

2369 }), true);

2370 res.generate(arg_accountId, arg_startDate, arg_endDate, currency: arg_curr ency, dimension: arg_dimension, filter: arg_filter, locale: arg_locale, maxResul ts: arg_maxResults, metric: arg_metric, sort: arg_sort, startIndex: arg_startInd ex, useTimezoneReporting: arg_useTimezoneReporting).then(unittest.expectAsync((( api.AdsenseReportsGenerateResponse response) {

2371 checkAdsenseReportsGenerateResponse(response);

2372 })));

2373 });

2374

2375 });

2376

2377

2378 unittest.group("resource-AccountsReportsSavedResourceApi", () {

2379 unittest.test("method--generate", () {

2380

2381 var mock = new common_test.HttpServerMock();

2382 api.AccountsReportsSavedResourceApi res = new api.AdsenseApi(mock).account s.reports.saved;

2383 var arg_accountId = "foo";

2384 var arg_savedReportId = "foo";

2385 var arg_locale = "foo";

2386 var arg_maxResults = 42;

2387 var arg_startIndex = 42;

2388 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2389 var path = (req.url).path;

2390 var pathOffset = 0;

2391 var index;

2392 var subPart;

2393 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2394 pathOffset += 14;

2395 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2396 pathOffset += 9;

2397 index = path.indexOf("/reports/", pathOffset);

2398 unittest.expect(index >= 0, unittest.isTrue);

2399 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2400 pathOffset = index;

2401 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2402 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/reports/"));

2403 pathOffset += 9;

2404 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2405 pathOffset = path.length;

2406 unittest.expect(subPart, unittest.equals("$arg_savedReportId"));

2407

2408 var query = (req.url).query;

2409 var queryOffset = 0;

2410 var queryMap = {};

2411 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2412 parseBool(n) {

2413 if (n == "true") return true;

2414 if (n == "false") return false;

2415 if (n == null) return null;

2416 throw new core.ArgumentError("Invalid boolean: $n");

2417 }

2418 if (query.length > 0) {

2419 for (var part in query.split("&")) {

2420 var keyvalue = part.split("=");

2421 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2422 }

2423 }

2424 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

2425 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2426 unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.e quals(arg_startIndex));

2427

2428

2429 var h = {

2430 "content-type" : "application/json; charset=utf-8",

2431 };

2432 var resp = convert.JSON.encode(buildAdsenseReportsGenerateResponse());

2433 return new async.Future.value(common_test.stringResponse(200, h, resp));

2434 }), true);

2435 res.generate(arg_accountId, arg_savedReportId, locale: arg_locale, maxResu lts: arg_maxResults, startIndex: arg_startIndex).then(unittest.expectAsync(((api .AdsenseReportsGenerateResponse response) {

2436 checkAdsenseReportsGenerateResponse(response);

2437 })));

2438 });

2439

2440 unittest.test("method--list", () {

2441

2442 var mock = new common_test.HttpServerMock();

2443 api.AccountsReportsSavedResourceApi res = new api.AdsenseApi(mock).account s.reports.saved;

2444 var arg_accountId = "foo";

2445 var arg_maxResults = 42;

2446 var arg_pageToken = "foo";

2447 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2448 var path = (req.url).path;

2449 var pathOffset = 0;

2450 var index;

2451 var subPart;

2452 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2453 pathOffset += 14;

2454 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2455 pathOffset += 9;

2456 index = path.indexOf("/reports/saved", pathOffset);

2457 unittest.expect(index >= 0, unittest.isTrue);

2458 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2459 pathOffset = index;

2460 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2461 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/reports/saved"));

2462 pathOffset += 14;

2463

2464 var query = (req.url).query;

2465 var queryOffset = 0;

2466 var queryMap = {};

2467 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2468 parseBool(n) {

2469 if (n == "true") return true;

2470 if (n == "false") return false;

2471 if (n == null) return null;

2472 throw new core.ArgumentError("Invalid boolean: $n");

2473 }

2474 if (query.length > 0) {

2475 for (var part in query.split("&")) {

2476 var keyvalue = part.split("=");

2477 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2478 }

2479 }

2480 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2481 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2482

2483

2484 var h = {

2485 "content-type" : "application/json; charset=utf-8",

2486 };

2487 var resp = convert.JSON.encode(buildSavedReports());

2488 return new async.Future.value(common_test.stringResponse(200, h, resp));

2489 }), true);

2490 res.list(arg_accountId, maxResults: arg_maxResults, pageToken: arg_pageTok en).then(unittest.expectAsync(((api.SavedReports response) {

2491 checkSavedReports(response);

2492 })));

2493 });

2494

2495 });

2496

2497

2498 unittest.group("resource-AccountsSavedadstylesResourceApi", () {

2499 unittest.test("method--get", () {

2500

2501 var mock = new common_test.HttpServerMock();

2502 api.AccountsSavedadstylesResourceApi res = new api.AdsenseApi(mock).accoun ts.savedadstyles;

2503 var arg_accountId = "foo";

2504 var arg_savedAdStyleId = "foo";

2505 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2506 var path = (req.url).path;

2507 var pathOffset = 0;

2508 var index;

2509 var subPart;

2510 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2511 pathOffset += 14;

2512 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2513 pathOffset += 9;

2514 index = path.indexOf("/savedadstyles/", pathOffset);

2515 unittest.expect(index >= 0, unittest.isTrue);

2516 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2517 pathOffset = index;

2518 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2519 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/savedadstyles/"));

2520 pathOffset += 15;

2521 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2522 pathOffset = path.length;

2523 unittest.expect(subPart, unittest.equals("$arg_savedAdStyleId"));

2524

2525 var query = (req.url).query;

2526 var queryOffset = 0;

2527 var queryMap = {};

2528 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2529 parseBool(n) {

2530 if (n == "true") return true;

2531 if (n == "false") return false;

2532 if (n == null) return null;

2533 throw new core.ArgumentError("Invalid boolean: $n");

2534 }

2535 if (query.length > 0) {

2536 for (var part in query.split("&")) {

2537 var keyvalue = part.split("=");

2538 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2539 }

2540 }

2541

2542

2543 var h = {

2544 "content-type" : "application/json; charset=utf-8",

2545 };

2546 var resp = convert.JSON.encode(buildSavedAdStyle());

2547 return new async.Future.value(common_test.stringResponse(200, h, resp));

2548 }), true);

2549 res.get(arg_accountId, arg_savedAdStyleId).then(unittest.expectAsync(((api .SavedAdStyle response) {

2550 checkSavedAdStyle(response);

2551 })));

2552 });

2553

2554 unittest.test("method--list", () {

2555

2556 var mock = new common_test.HttpServerMock();

2557 api.AccountsSavedadstylesResourceApi res = new api.AdsenseApi(mock).accoun ts.savedadstyles;

2558 var arg_accountId = "foo";

2559 var arg_maxResults = 42;

2560 var arg_pageToken = "foo";

2561 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2562 var path = (req.url).path;

2563 var pathOffset = 0;

2564 var index;

2565 var subPart;

2566 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2567 pathOffset += 14;

2568 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2569 pathOffset += 9;

2570 index = path.indexOf("/savedadstyles", pathOffset);

2571 unittest.expect(index >= 0, unittest.isTrue);

2572 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2573 pathOffset = index;

2574 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2575 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/savedadstyles"));

2576 pathOffset += 14;

2577

2578 var query = (req.url).query;

2579 var queryOffset = 0;

2580 var queryMap = {};

2581 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2582 parseBool(n) {

2583 if (n == "true") return true;

2584 if (n == "false") return false;

2585 if (n == null) return null;

2586 throw new core.ArgumentError("Invalid boolean: $n");

2587 }

2588 if (query.length > 0) {

2589 for (var part in query.split("&")) {

2590 var keyvalue = part.split("=");

2591 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2592 }

2593 }

2594 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2595 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2596

2597

2598 var h = {

2599 "content-type" : "application/json; charset=utf-8",

2600 };

2601 var resp = convert.JSON.encode(buildSavedAdStyles());

2602 return new async.Future.value(common_test.stringResponse(200, h, resp));

2603 }), true);

2604 res.list(arg_accountId, maxResults: arg_maxResults, pageToken: arg_pageTok en).then(unittest.expectAsync(((api.SavedAdStyles response) {

2605 checkSavedAdStyles(response);

2606 })));

2607 });

2608

2609 });

2610

2611

2612 unittest.group("resource-AccountsUrlchannelsResourceApi", () {

2613 unittest.test("method--list", () {

2614

2615 var mock = new common_test.HttpServerMock();

2616 api.AccountsUrlchannelsResourceApi res = new api.AdsenseApi(mock).accounts .urlchannels;

2617 var arg_accountId = "foo";

2618 var arg_adClientId = "foo";

2619 var arg_maxResults = 42;

2620 var arg_pageToken = "foo";

2621 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2622 var path = (req.url).path;

2623 var pathOffset = 0;

2624 var index;

2625 var subPart;

2626 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2627 pathOffset += 14;

2628 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("accounts/"));

2629 pathOffset += 9;

2630 index = path.indexOf("/adclients/", pathOffset);

2631 unittest.expect(index >= 0, unittest.isTrue);

2632 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2633 pathOffset = index;

2634 unittest.expect(subPart, unittest.equals("$arg_accountId"));

2635 unittest.expect(path.substring(pathOffset, pathOffset + 11), unittest.eq uals("/adclients/"));

2636 pathOffset += 11;

2637 index = path.indexOf("/urlchannels", pathOffset);

2638 unittest.expect(index >= 0, unittest.isTrue);

2639 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2640 pathOffset = index;

2641 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2642 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/urlchannels"));

2643 pathOffset += 12;

2644

2645 var query = (req.url).query;

2646 var queryOffset = 0;

2647 var queryMap = {};

2648 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2649 parseBool(n) {

2650 if (n == "true") return true;

2651 if (n == "false") return false;

2652 if (n == null) return null;

2653 throw new core.ArgumentError("Invalid boolean: $n");

2654 }

2655 if (query.length > 0) {

2656 for (var part in query.split("&")) {

2657 var keyvalue = part.split("=");

2658 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2659 }

2660 }

2661 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2662 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2663

2664

2665 var h = {

2666 "content-type" : "application/json; charset=utf-8",

2667 };

2668 var resp = convert.JSON.encode(buildUrlChannels());

2669 return new async.Future.value(common_test.stringResponse(200, h, resp));

2670 }), true);

2671 res.list(arg_accountId, arg_adClientId, maxResults: arg_maxResults, pageTo ken: arg_pageToken).then(unittest.expectAsync(((api.UrlChannels response) {

2672 checkUrlChannels(response);

2673 })));

2674 });

2675

2676 });

2677

2678

2679 unittest.group("resource-AdclientsResourceApi", () {

2680 unittest.test("method--list", () {

2681

2682 var mock = new common_test.HttpServerMock();

2683 api.AdclientsResourceApi res = new api.AdsenseApi(mock).adclients;

2684 var arg_maxResults = 42;

2685 var arg_pageToken = "foo";

2686 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2687 var path = (req.url).path;

2688 var pathOffset = 0;

2689 var index;

2690 var subPart;

2691 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2692 pathOffset += 14;

2693 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("adclients"));

2694 pathOffset += 9;

2695

2696 var query = (req.url).query;

2697 var queryOffset = 0;

2698 var queryMap = {};

2699 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2700 parseBool(n) {

2701 if (n == "true") return true;

2702 if (n == "false") return false;

2703 if (n == null) return null;

2704 throw new core.ArgumentError("Invalid boolean: $n");

2705 }

2706 if (query.length > 0) {

2707 for (var part in query.split("&")) {

2708 var keyvalue = part.split("=");

2709 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2710 }

2711 }

2712 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2713 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2714

2715

2716 var h = {

2717 "content-type" : "application/json; charset=utf-8",

2718 };

2719 var resp = convert.JSON.encode(buildAdClients());

2720 return new async.Future.value(common_test.stringResponse(200, h, resp));

2721 }), true);

2722 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken).then(unitte st.expectAsync(((api.AdClients response) {

2723 checkAdClients(response);

2724 })));

2725 });

2726

2727 });

2728

2729

2730 unittest.group("resource-AdunitsResourceApi", () {

2731 unittest.test("method--get", () {

2732

2733 var mock = new common_test.HttpServerMock();

2734 api.AdunitsResourceApi res = new api.AdsenseApi(mock).adunits;

2735 var arg_adClientId = "foo";

2736 var arg_adUnitId = "foo";

2737 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2738 var path = (req.url).path;

2739 var pathOffset = 0;

2740 var index;

2741 var subPart;

2742 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2743 pathOffset += 14;

2744 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

2745 pathOffset += 10;

2746 index = path.indexOf("/adunits/", pathOffset);

2747 unittest.expect(index >= 0, unittest.isTrue);

2748 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2749 pathOffset = index;

2750 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2751 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

2752 pathOffset += 9;

2753 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2754 pathOffset = path.length;

2755 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

2756

2757 var query = (req.url).query;

2758 var queryOffset = 0;

2759 var queryMap = {};

2760 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2761 parseBool(n) {

2762 if (n == "true") return true;

2763 if (n == "false") return false;

2764 if (n == null) return null;

2765 throw new core.ArgumentError("Invalid boolean: $n");

2766 }

2767 if (query.length > 0) {

2768 for (var part in query.split("&")) {

2769 var keyvalue = part.split("=");

2770 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2771 }

2772 }

2773

2774

2775 var h = {

2776 "content-type" : "application/json; charset=utf-8",

2777 };

2778 var resp = convert.JSON.encode(buildAdUnit());

2779 return new async.Future.value(common_test.stringResponse(200, h, resp));

2780 }), true);

2781 res.get(arg_adClientId, arg_adUnitId).then(unittest.expectAsync(((api.AdUn it response) {

2782 checkAdUnit(response);

2783 })));

2784 });

2785

2786 unittest.test("method--getAdCode", () {

2787

2788 var mock = new common_test.HttpServerMock();

2789 api.AdunitsResourceApi res = new api.AdsenseApi(mock).adunits;

2790 var arg_adClientId = "foo";

2791 var arg_adUnitId = "foo";

2792 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2793 var path = (req.url).path;

2794 var pathOffset = 0;

2795 var index;

2796 var subPart;

2797 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2798 pathOffset += 14;

2799 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

2800 pathOffset += 10;

2801 index = path.indexOf("/adunits/", pathOffset);

2802 unittest.expect(index >= 0, unittest.isTrue);

2803 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2804 pathOffset = index;

2805 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2806 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

2807 pathOffset += 9;

2808 index = path.indexOf("/adcode", pathOffset);

2809 unittest.expect(index >= 0, unittest.isTrue);

2810 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2811 pathOffset = index;

2812 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

2813 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("/adcode"));

2814 pathOffset += 7;

2815

2816 var query = (req.url).query;

2817 var queryOffset = 0;

2818 var queryMap = {};

2819 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2820 parseBool(n) {

2821 if (n == "true") return true;

2822 if (n == "false") return false;

2823 if (n == null) return null;

2824 throw new core.ArgumentError("Invalid boolean: $n");

2825 }

2826 if (query.length > 0) {

2827 for (var part in query.split("&")) {

2828 var keyvalue = part.split("=");

2829 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2830 }

2831 }

2832

2833

2834 var h = {

2835 "content-type" : "application/json; charset=utf-8",

2836 };

2837 var resp = convert.JSON.encode(buildAdCode());

2838 return new async.Future.value(common_test.stringResponse(200, h, resp));

2839 }), true);

2840 res.getAdCode(arg_adClientId, arg_adUnitId).then(unittest.expectAsync(((ap i.AdCode response) {

2841 checkAdCode(response);

2842 })));

2843 });

2844

2845 unittest.test("method--list", () {

2846

2847 var mock = new common_test.HttpServerMock();

2848 api.AdunitsResourceApi res = new api.AdsenseApi(mock).adunits;

2849 var arg_adClientId = "foo";

2850 var arg_includeInactive = true;

2851 var arg_maxResults = 42;

2852 var arg_pageToken = "foo";

2853 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2854 var path = (req.url).path;

2855 var pathOffset = 0;

2856 var index;

2857 var subPart;

2858 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2859 pathOffset += 14;

2860 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

2861 pathOffset += 10;

2862 index = path.indexOf("/adunits", pathOffset);

2863 unittest.expect(index >= 0, unittest.isTrue);

2864 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2865 pathOffset = index;

2866 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2867 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/adunits"));

2868 pathOffset += 8;

2869

2870 var query = (req.url).query;

2871 var queryOffset = 0;

2872 var queryMap = {};

2873 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2874 parseBool(n) {

2875 if (n == "true") return true;

2876 if (n == "false") return false;

2877 if (n == null) return null;

2878 throw new core.ArgumentError("Invalid boolean: $n");

2879 }

2880 if (query.length > 0) {

2881 for (var part in query.split("&")) {

2882 var keyvalue = part.split("=");

2883 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2884 }

2885 }

2886 unittest.expect(queryMap["includeInactive"].first, unittest.equals("$arg _includeInactive"));

2887 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2888 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2889

2890

2891 var h = {

2892 "content-type" : "application/json; charset=utf-8",

2893 };

2894 var resp = convert.JSON.encode(buildAdUnits());

2895 return new async.Future.value(common_test.stringResponse(200, h, resp));

2896 }), true);

2897 res.list(arg_adClientId, includeInactive: arg_includeInactive, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.expectAsync(((api.AdUni ts response) {

2898 checkAdUnits(response);

2899 })));

2900 });

2901

2902 });

2903

2904

2905 unittest.group("resource-AdunitsCustomchannelsResourceApi", () {

2906 unittest.test("method--list", () {

2907

2908 var mock = new common_test.HttpServerMock();

2909 api.AdunitsCustomchannelsResourceApi res = new api.AdsenseApi(mock).adunit s.customchannels;

2910 var arg_adClientId = "foo";

2911 var arg_adUnitId = "foo";

2912 var arg_maxResults = 42;

2913 var arg_pageToken = "foo";

2914 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2915 var path = (req.url).path;

2916 var pathOffset = 0;

2917 var index;

2918 var subPart;

2919 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2920 pathOffset += 14;

2921 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

2922 pathOffset += 10;

2923 index = path.indexOf("/adunits/", pathOffset);

2924 unittest.expect(index >= 0, unittest.isTrue);

2925 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2926 pathOffset = index;

2927 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

2928 unittest.expect(path.substring(pathOffset, pathOffset + 9), unittest.equ als("/adunits/"));

2929 pathOffset += 9;

2930 index = path.indexOf("/customchannels", pathOffset);

2931 unittest.expect(index >= 0, unittest.isTrue);

2932 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

2933 pathOffset = index;

2934 unittest.expect(subPart, unittest.equals("$arg_adUnitId"));

2935 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/customchannels"));

2936 pathOffset += 15;

2937

2938 var query = (req.url).query;

2939 var queryOffset = 0;

2940 var queryMap = {};

2941 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2942 parseBool(n) {

2943 if (n == "true") return true;

2944 if (n == "false") return false;

2945 if (n == null) return null;

2946 throw new core.ArgumentError("Invalid boolean: $n");

2947 }

2948 if (query.length > 0) {

2949 for (var part in query.split("&")) {

2950 var keyvalue = part.split("=");

2951 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

2952 }

2953 }

2954 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

2955 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

2956

2957

2958 var h = {

2959 "content-type" : "application/json; charset=utf-8",

2960 };

2961 var resp = convert.JSON.encode(buildCustomChannels());

2962 return new async.Future.value(common_test.stringResponse(200, h, resp));

2963 }), true);

2964 res.list(arg_adClientId, arg_adUnitId, maxResults: arg_maxResults, pageTok en: arg_pageToken).then(unittest.expectAsync(((api.CustomChannels response) {

2965 checkCustomChannels(response);

2966 })));

2967 });

2968

2969 });

2970

2971

2972 unittest.group("resource-AlertsResourceApi", () {

2973 unittest.test("method--delete", () {

2974

2975 var mock = new common_test.HttpServerMock();

2976 api.AlertsResourceApi res = new api.AdsenseApi(mock).alerts;

2977 var arg_alertId = "foo";

2978 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

2979 var path = (req.url).path;

2980 var pathOffset = 0;

2981 var index;

2982 var subPart;

2983 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

2984 pathOffset += 14;

2985 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("alerts/"));

2986 pathOffset += 7;

2987 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

2988 pathOffset = path.length;

2989 unittest.expect(subPart, unittest.equals("$arg_alertId"));

2990

2991 var query = (req.url).query;

2992 var queryOffset = 0;

2993 var queryMap = {};

2994 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

2995 parseBool(n) {

2996 if (n == "true") return true;

2997 if (n == "false") return false;

2998 if (n == null) return null;

2999 throw new core.ArgumentError("Invalid boolean: $n");

3000 }

3001 if (query.length > 0) {

3002 for (var part in query.split("&")) {

3003 var keyvalue = part.split("=");

3004 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3005 }

3006 }

3007

3008

3009 var h = {

3010 "content-type" : "application/json; charset=utf-8",

3011 };

3012 var resp = "";

3013 return new async.Future.value(common_test.stringResponse(200, h, resp));

3014 }), true);

3015 res.delete(arg_alertId).then(unittest.expectAsync((_) {}));

3016 });

3017

3018 unittest.test("method--list", () {

3019

3020 var mock = new common_test.HttpServerMock();

3021 api.AlertsResourceApi res = new api.AdsenseApi(mock).alerts;

3022 var arg_locale = "foo";

3023 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3024 var path = (req.url).path;

3025 var pathOffset = 0;

3026 var index;

3027 var subPart;

3028 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3029 pathOffset += 14;

3030 unittest.expect(path.substring(pathOffset, pathOffset + 6), unittest.equ als("alerts"));

3031 pathOffset += 6;

3032

3033 var query = (req.url).query;

3034 var queryOffset = 0;

3035 var queryMap = {};

3036 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3037 parseBool(n) {

3038 if (n == "true") return true;

3039 if (n == "false") return false;

3040 if (n == null) return null;

3041 throw new core.ArgumentError("Invalid boolean: $n");

3042 }

3043 if (query.length > 0) {

3044 for (var part in query.split("&")) {

3045 var keyvalue = part.split("=");

3046 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3047 }

3048 }

3049 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

3050

3051

3052 var h = {

3053 "content-type" : "application/json; charset=utf-8",

3054 };

3055 var resp = convert.JSON.encode(buildAlerts());

3056 return new async.Future.value(common_test.stringResponse(200, h, resp));

3057 }), true);

3058 res.list(locale: arg_locale).then(unittest.expectAsync(((api.Alerts respon se) {

3059 checkAlerts(response);

3060 })));

3061 });

3062

3063 });

3064

3065

3066 unittest.group("resource-CustomchannelsResourceApi", () {

3067 unittest.test("method--get", () {

3068

3069 var mock = new common_test.HttpServerMock();

3070 api.CustomchannelsResourceApi res = new api.AdsenseApi(mock).customchannel s;

3071 var arg_adClientId = "foo";

3072 var arg_customChannelId = "foo";

3073 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3074 var path = (req.url).path;

3075 var pathOffset = 0;

3076 var index;

3077 var subPart;

3078 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3079 pathOffset += 14;

3080 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

3081 pathOffset += 10;

3082 index = path.indexOf("/customchannels/", pathOffset);

3083 unittest.expect(index >= 0, unittest.isTrue);

3084 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3085 pathOffset = index;

3086 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

3087 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/customchannels/"));

3088 pathOffset += 16;

3089 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3090 pathOffset = path.length;

3091 unittest.expect(subPart, unittest.equals("$arg_customChannelId"));

3092

3093 var query = (req.url).query;

3094 var queryOffset = 0;

3095 var queryMap = {};

3096 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3097 parseBool(n) {

3098 if (n == "true") return true;

3099 if (n == "false") return false;

3100 if (n == null) return null;

3101 throw new core.ArgumentError("Invalid boolean: $n");

3102 }

3103 if (query.length > 0) {

3104 for (var part in query.split("&")) {

3105 var keyvalue = part.split("=");

3106 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3107 }

3108 }

3109

3110

3111 var h = {

3112 "content-type" : "application/json; charset=utf-8",

3113 };

3114 var resp = convert.JSON.encode(buildCustomChannel());

3115 return new async.Future.value(common_test.stringResponse(200, h, resp));

3116 }), true);

3117 res.get(arg_adClientId, arg_customChannelId).then(unittest.expectAsync(((a pi.CustomChannel response) {

3118 checkCustomChannel(response);

3119 })));

3120 });

3121

3122 unittest.test("method--list", () {

3123

3124 var mock = new common_test.HttpServerMock();

3125 api.CustomchannelsResourceApi res = new api.AdsenseApi(mock).customchannel s;

3126 var arg_adClientId = "foo";

3127 var arg_maxResults = 42;

3128 var arg_pageToken = "foo";

3129 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3130 var path = (req.url).path;

3131 var pathOffset = 0;

3132 var index;

3133 var subPart;

3134 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3135 pathOffset += 14;

3136 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

3137 pathOffset += 10;

3138 index = path.indexOf("/customchannels", pathOffset);

3139 unittest.expect(index >= 0, unittest.isTrue);

3140 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3141 pathOffset = index;

3142 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

3143 unittest.expect(path.substring(pathOffset, pathOffset + 15), unittest.eq uals("/customchannels"));

3144 pathOffset += 15;

3145

3146 var query = (req.url).query;

3147 var queryOffset = 0;

3148 var queryMap = {};

3149 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3150 parseBool(n) {

3151 if (n == "true") return true;

3152 if (n == "false") return false;

3153 if (n == null) return null;

3154 throw new core.ArgumentError("Invalid boolean: $n");

3155 }

3156 if (query.length > 0) {

3157 for (var part in query.split("&")) {

3158 var keyvalue = part.split("=");

3159 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3160 }

3161 }

3162 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3163 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3164

3165

3166 var h = {

3167 "content-type" : "application/json; charset=utf-8",

3168 };

3169 var resp = convert.JSON.encode(buildCustomChannels());

3170 return new async.Future.value(common_test.stringResponse(200, h, resp));

3171 }), true);

3172 res.list(arg_adClientId, maxResults: arg_maxResults, pageToken: arg_pageTo ken).then(unittest.expectAsync(((api.CustomChannels response) {

3173 checkCustomChannels(response);

3174 })));

3175 });

3176

3177 });

3178

3179

3180 unittest.group("resource-CustomchannelsAdunitsResourceApi", () {

3181 unittest.test("method--list", () {

3182

3183 var mock = new common_test.HttpServerMock();

3184 api.CustomchannelsAdunitsResourceApi res = new api.AdsenseApi(mock).custom channels.adunits;

3185 var arg_adClientId = "foo";

3186 var arg_customChannelId = "foo";

3187 var arg_includeInactive = true;

3188 var arg_maxResults = 42;

3189 var arg_pageToken = "foo";

3190 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3191 var path = (req.url).path;

3192 var pathOffset = 0;

3193 var index;

3194 var subPart;

3195 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3196 pathOffset += 14;

3197 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

3198 pathOffset += 10;

3199 index = path.indexOf("/customchannels/", pathOffset);

3200 unittest.expect(index >= 0, unittest.isTrue);

3201 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3202 pathOffset = index;

3203 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

3204 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("/customchannels/"));

3205 pathOffset += 16;

3206 index = path.indexOf("/adunits", pathOffset);

3207 unittest.expect(index >= 0, unittest.isTrue);

3208 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3209 pathOffset = index;

3210 unittest.expect(subPart, unittest.equals("$arg_customChannelId"));

3211 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("/adunits"));

3212 pathOffset += 8;

3213

3214 var query = (req.url).query;

3215 var queryOffset = 0;

3216 var queryMap = {};

3217 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3218 parseBool(n) {

3219 if (n == "true") return true;

3220 if (n == "false") return false;

3221 if (n == null) return null;

3222 throw new core.ArgumentError("Invalid boolean: $n");

3223 }

3224 if (query.length > 0) {

3225 for (var part in query.split("&")) {

3226 var keyvalue = part.split("=");

3227 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3228 }

3229 }

3230 unittest.expect(queryMap["includeInactive"].first, unittest.equals("$arg _includeInactive"));

3231 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3232 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3233

3234

3235 var h = {

3236 "content-type" : "application/json; charset=utf-8",

3237 };

3238 var resp = convert.JSON.encode(buildAdUnits());

3239 return new async.Future.value(common_test.stringResponse(200, h, resp));

3240 }), true);

3241 res.list(arg_adClientId, arg_customChannelId, includeInactive: arg_include Inactive, maxResults: arg_maxResults, pageToken: arg_pageToken).then(unittest.ex pectAsync(((api.AdUnits response) {

3242 checkAdUnits(response);

3243 })));

3244 });

3245

3246 });

3247

3248

3249 unittest.group("resource-MetadataDimensionsResourceApi", () {

3250 unittest.test("method--list", () {

3251

3252 var mock = new common_test.HttpServerMock();

3253 api.MetadataDimensionsResourceApi res = new api.AdsenseApi(mock).metadata. dimensions;

3254 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3255 var path = (req.url).path;

3256 var pathOffset = 0;

3257 var index;

3258 var subPart;

3259 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3260 pathOffset += 14;

3261 unittest.expect(path.substring(pathOffset, pathOffset + 19), unittest.eq uals("metadata/dimensions"));

3262 pathOffset += 19;

3263

3264 var query = (req.url).query;

3265 var queryOffset = 0;

3266 var queryMap = {};

3267 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3268 parseBool(n) {

3269 if (n == "true") return true;

3270 if (n == "false") return false;

3271 if (n == null) return null;

3272 throw new core.ArgumentError("Invalid boolean: $n");

3273 }

3274 if (query.length > 0) {

3275 for (var part in query.split("&")) {

3276 var keyvalue = part.split("=");

3277 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3278 }

3279 }

3280

3281

3282 var h = {

3283 "content-type" : "application/json; charset=utf-8",

3284 };

3285 var resp = convert.JSON.encode(buildMetadata());

3286 return new async.Future.value(common_test.stringResponse(200, h, resp));

3287 }), true);

3288 res.list().then(unittest.expectAsync(((api.Metadata response) {

3289 checkMetadata(response);

3290 })));

3291 });

3292

3293 });

3294

3295

3296 unittest.group("resource-MetadataMetricsResourceApi", () {

3297 unittest.test("method--list", () {

3298

3299 var mock = new common_test.HttpServerMock();

3300 api.MetadataMetricsResourceApi res = new api.AdsenseApi(mock).metadata.met rics;

3301 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3302 var path = (req.url).path;

3303 var pathOffset = 0;

3304 var index;

3305 var subPart;

3306 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3307 pathOffset += 14;

3308 unittest.expect(path.substring(pathOffset, pathOffset + 16), unittest.eq uals("metadata/metrics"));

3309 pathOffset += 16;

3310

3311 var query = (req.url).query;

3312 var queryOffset = 0;

3313 var queryMap = {};

3314 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3315 parseBool(n) {

3316 if (n == "true") return true;

3317 if (n == "false") return false;

3318 if (n == null) return null;

3319 throw new core.ArgumentError("Invalid boolean: $n");

3320 }

3321 if (query.length > 0) {

3322 for (var part in query.split("&")) {

3323 var keyvalue = part.split("=");

3324 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3325 }

3326 }

3327

3328

3329 var h = {

3330 "content-type" : "application/json; charset=utf-8",

3331 };

3332 var resp = convert.JSON.encode(buildMetadata());

3333 return new async.Future.value(common_test.stringResponse(200, h, resp));

3334 }), true);

3335 res.list().then(unittest.expectAsync(((api.Metadata response) {

3336 checkMetadata(response);

3337 })));

3338 });

3339

3340 });

3341

3342

3343 unittest.group("resource-PaymentsResourceApi", () {

3344 unittest.test("method--list", () {

3345

3346 var mock = new common_test.HttpServerMock();

3347 api.PaymentsResourceApi res = new api.AdsenseApi(mock).payments;

3348 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3349 var path = (req.url).path;

3350 var pathOffset = 0;

3351 var index;

3352 var subPart;

3353 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3354 pathOffset += 14;

3355 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("payments"));

3356 pathOffset += 8;

3357

3358 var query = (req.url).query;

3359 var queryOffset = 0;

3360 var queryMap = {};

3361 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3362 parseBool(n) {

3363 if (n == "true") return true;

3364 if (n == "false") return false;

3365 if (n == null) return null;

3366 throw new core.ArgumentError("Invalid boolean: $n");

3367 }

3368 if (query.length > 0) {

3369 for (var part in query.split("&")) {

3370 var keyvalue = part.split("=");

3371 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3372 }

3373 }

3374

3375

3376 var h = {

3377 "content-type" : "application/json; charset=utf-8",

3378 };

3379 var resp = convert.JSON.encode(buildPayments());

3380 return new async.Future.value(common_test.stringResponse(200, h, resp));

3381 }), true);

3382 res.list().then(unittest.expectAsync(((api.Payments response) {

3383 checkPayments(response);

3384 })));

3385 });

3386

3387 });

3388

3389

3390 unittest.group("resource-ReportsResourceApi", () {

3391 unittest.test("method--generate", () {

3392 // TODO: Implement tests for media upload;

3393 // TODO: Implement tests for media download;

3394

3395 var mock = new common_test.HttpServerMock();

3396 api.ReportsResourceApi res = new api.AdsenseApi(mock).reports;

3397 var arg_startDate = "foo";

3398 var arg_endDate = "foo";

3399 var arg_accountId = buildUnnamed833();

3400 var arg_currency = "foo";

3401 var arg_dimension = buildUnnamed834();

3402 var arg_filter = buildUnnamed835();

3403 var arg_locale = "foo";

3404 var arg_maxResults = 42;

3405 var arg_metric = buildUnnamed836();

3406 var arg_sort = buildUnnamed837();

3407 var arg_startIndex = 42;

3408 var arg_useTimezoneReporting = true;

3409 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3410 var path = (req.url).path;

3411 var pathOffset = 0;

3412 var index;

3413 var subPart;

3414 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3415 pathOffset += 14;

3416 unittest.expect(path.substring(pathOffset, pathOffset + 7), unittest.equ als("reports"));

3417 pathOffset += 7;

3418

3419 var query = (req.url).query;

3420 var queryOffset = 0;

3421 var queryMap = {};

3422 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3423 parseBool(n) {

3424 if (n == "true") return true;

3425 if (n == "false") return false;

3426 if (n == null) return null;

3427 throw new core.ArgumentError("Invalid boolean: $n");

3428 }

3429 if (query.length > 0) {

3430 for (var part in query.split("&")) {

3431 var keyvalue = part.split("=");

3432 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3433 }

3434 }

3435 unittest.expect(queryMap["startDate"].first, unittest.equals(arg_startDa te));

3436 unittest.expect(queryMap["endDate"].first, unittest.equals(arg_endDate)) ;

3437 unittest.expect(queryMap["accountId"], unittest.equals(arg_accountId));

3438 unittest.expect(queryMap["currency"].first, unittest.equals(arg_currency ));

3439 unittest.expect(queryMap["dimension"], unittest.equals(arg_dimension));

3440 unittest.expect(queryMap["filter"], unittest.equals(arg_filter));

3441 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

3442 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3443 unittest.expect(queryMap["metric"], unittest.equals(arg_metric));

3444 unittest.expect(queryMap["sort"], unittest.equals(arg_sort));

3445 unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.e quals(arg_startIndex));

3446 unittest.expect(queryMap["useTimezoneReporting"].first, unittest.equals( "$arg_useTimezoneReporting"));

3447

3448

3449 var h = {

3450 "content-type" : "application/json; charset=utf-8",

3451 };

3452 var resp = convert.JSON.encode(buildAdsenseReportsGenerateResponse());

3453 return new async.Future.value(common_test.stringResponse(200, h, resp));

3454 }), true);

3455 res.generate(arg_startDate, arg_endDate, accountId: arg_accountId, currenc y: arg_currency, dimension: arg_dimension, filter: arg_filter, locale: arg_local e, maxResults: arg_maxResults, metric: arg_metric, sort: arg_sort, startIndex: a rg_startIndex, useTimezoneReporting: arg_useTimezoneReporting).then(unittest.exp ectAsync(((api.AdsenseReportsGenerateResponse response) {

3456 checkAdsenseReportsGenerateResponse(response);

3457 })));

3458 });

3459

3460 });

3461

3462

3463 unittest.group("resource-ReportsSavedResourceApi", () {

3464 unittest.test("method--generate", () {

3465

3466 var mock = new common_test.HttpServerMock();

3467 api.ReportsSavedResourceApi res = new api.AdsenseApi(mock).reports.saved;

3468 var arg_savedReportId = "foo";

3469 var arg_locale = "foo";

3470 var arg_maxResults = 42;

3471 var arg_startIndex = 42;

3472 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3473 var path = (req.url).path;

3474 var pathOffset = 0;

3475 var index;

3476 var subPart;

3477 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3478 pathOffset += 14;

3479 unittest.expect(path.substring(pathOffset, pathOffset + 8), unittest.equ als("reports/"));

3480 pathOffset += 8;

3481 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3482 pathOffset = path.length;

3483 unittest.expect(subPart, unittest.equals("$arg_savedReportId"));

3484

3485 var query = (req.url).query;

3486 var queryOffset = 0;

3487 var queryMap = {};

3488 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3489 parseBool(n) {

3490 if (n == "true") return true;

3491 if (n == "false") return false;

3492 if (n == null) return null;

3493 throw new core.ArgumentError("Invalid boolean: $n");

3494 }

3495 if (query.length > 0) {

3496 for (var part in query.split("&")) {

3497 var keyvalue = part.split("=");

3498 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3499 }

3500 }

3501 unittest.expect(queryMap["locale"].first, unittest.equals(arg_locale));

3502 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3503 unittest.expect(core.int.parse(queryMap["startIndex"].first), unittest.e quals(arg_startIndex));

3504

3505

3506 var h = {

3507 "content-type" : "application/json; charset=utf-8",

3508 };

3509 var resp = convert.JSON.encode(buildAdsenseReportsGenerateResponse());

3510 return new async.Future.value(common_test.stringResponse(200, h, resp));

3511 }), true);

3512 res.generate(arg_savedReportId, locale: arg_locale, maxResults: arg_maxRes ults, startIndex: arg_startIndex).then(unittest.expectAsync(((api.AdsenseReports GenerateResponse response) {

3513 checkAdsenseReportsGenerateResponse(response);

3514 })));

3515 });

3516

3517 unittest.test("method--list", () {

3518

3519 var mock = new common_test.HttpServerMock();

3520 api.ReportsSavedResourceApi res = new api.AdsenseApi(mock).reports.saved;

3521 var arg_maxResults = 42;

3522 var arg_pageToken = "foo";

3523 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3524 var path = (req.url).path;

3525 var pathOffset = 0;

3526 var index;

3527 var subPart;

3528 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3529 pathOffset += 14;

3530 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("reports/saved"));

3531 pathOffset += 13;

3532

3533 var query = (req.url).query;

3534 var queryOffset = 0;

3535 var queryMap = {};

3536 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3537 parseBool(n) {

3538 if (n == "true") return true;

3539 if (n == "false") return false;

3540 if (n == null) return null;

3541 throw new core.ArgumentError("Invalid boolean: $n");

3542 }

3543 if (query.length > 0) {

3544 for (var part in query.split("&")) {

3545 var keyvalue = part.split("=");

3546 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3547 }

3548 }

3549 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3550 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3551

3552

3553 var h = {

3554 "content-type" : "application/json; charset=utf-8",

3555 };

3556 var resp = convert.JSON.encode(buildSavedReports());

3557 return new async.Future.value(common_test.stringResponse(200, h, resp));

3558 }), true);

3559 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken).then(unitte st.expectAsync(((api.SavedReports response) {

3560 checkSavedReports(response);

3561 })));

3562 });

3563

3564 });

3565

3566

3567 unittest.group("resource-SavedadstylesResourceApi", () {

3568 unittest.test("method--get", () {

3569

3570 var mock = new common_test.HttpServerMock();

3571 api.SavedadstylesResourceApi res = new api.AdsenseApi(mock).savedadstyles;

3572 var arg_savedAdStyleId = "foo";

3573 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3574 var path = (req.url).path;

3575 var pathOffset = 0;

3576 var index;

3577 var subPart;

3578 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3579 pathOffset += 14;

3580 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("savedadstyles/"));

3581 pathOffset += 14;

3582 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));

3583 pathOffset = path.length;

3584 unittest.expect(subPart, unittest.equals("$arg_savedAdStyleId"));

3585

3586 var query = (req.url).query;

3587 var queryOffset = 0;

3588 var queryMap = {};

3589 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3590 parseBool(n) {

3591 if (n == "true") return true;

3592 if (n == "false") return false;

3593 if (n == null) return null;

3594 throw new core.ArgumentError("Invalid boolean: $n");

3595 }

3596 if (query.length > 0) {

3597 for (var part in query.split("&")) {

3598 var keyvalue = part.split("=");

3599 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3600 }

3601 }

3602

3603

3604 var h = {

3605 "content-type" : "application/json; charset=utf-8",

3606 };

3607 var resp = convert.JSON.encode(buildSavedAdStyle());

3608 return new async.Future.value(common_test.stringResponse(200, h, resp));

3609 }), true);

3610 res.get(arg_savedAdStyleId).then(unittest.expectAsync(((api.SavedAdStyle r esponse) {

3611 checkSavedAdStyle(response);

3612 })));

3613 });

3614

3615 unittest.test("method--list", () {

3616

3617 var mock = new common_test.HttpServerMock();

3618 api.SavedadstylesResourceApi res = new api.AdsenseApi(mock).savedadstyles;

3619 var arg_maxResults = 42;

3620 var arg_pageToken = "foo";

3621 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3622 var path = (req.url).path;

3623 var pathOffset = 0;

3624 var index;

3625 var subPart;

3626 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3627 pathOffset += 14;

3628 unittest.expect(path.substring(pathOffset, pathOffset + 13), unittest.eq uals("savedadstyles"));

3629 pathOffset += 13;

3630

3631 var query = (req.url).query;

3632 var queryOffset = 0;

3633 var queryMap = {};

3634 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3635 parseBool(n) {

3636 if (n == "true") return true;

3637 if (n == "false") return false;

3638 if (n == null) return null;

3639 throw new core.ArgumentError("Invalid boolean: $n");

3640 }

3641 if (query.length > 0) {

3642 for (var part in query.split("&")) {

3643 var keyvalue = part.split("=");

3644 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3645 }

3646 }

3647 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3648 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3649

3650

3651 var h = {

3652 "content-type" : "application/json; charset=utf-8",

3653 };

3654 var resp = convert.JSON.encode(buildSavedAdStyles());

3655 return new async.Future.value(common_test.stringResponse(200, h, resp));

3656 }), true);

3657 res.list(maxResults: arg_maxResults, pageToken: arg_pageToken).then(unitte st.expectAsync(((api.SavedAdStyles response) {

3658 checkSavedAdStyles(response);

3659 })));

3660 });

3661

3662 });

3663

3664

3665 unittest.group("resource-UrlchannelsResourceApi", () {

3666 unittest.test("method--list", () {

3667

3668 var mock = new common_test.HttpServerMock();

3669 api.UrlchannelsResourceApi res = new api.AdsenseApi(mock).urlchannels;

3670 var arg_adClientId = "foo";

3671 var arg_maxResults = 42;

3672 var arg_pageToken = "foo";

3673 mock.register(unittest.expectAsync((http.BaseRequest req, json) {

3674 var path = (req.url).path;

3675 var pathOffset = 0;

3676 var index;

3677 var subPart;

3678 unittest.expect(path.substring(pathOffset, pathOffset + 14), unittest.eq uals("/adsense/v1.4/"));

3679 pathOffset += 14;

3680 unittest.expect(path.substring(pathOffset, pathOffset + 10), unittest.eq uals("adclients/"));

3681 pathOffset += 10;

3682 index = path.indexOf("/urlchannels", pathOffset);

3683 unittest.expect(index >= 0, unittest.isTrue);

3684 subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset, index ));

3685 pathOffset = index;

3686 unittest.expect(subPart, unittest.equals("$arg_adClientId"));

3687 unittest.expect(path.substring(pathOffset, pathOffset + 12), unittest.eq uals("/urlchannels"));

3688 pathOffset += 12;

3689

3690 var query = (req.url).query;

3691 var queryOffset = 0;

3692 var queryMap = {};

3693 addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);

3694 parseBool(n) {

3695 if (n == "true") return true;

3696 if (n == "false") return false;

3697 if (n == null) return null;

3698 throw new core.ArgumentError("Invalid boolean: $n");

3699 }

3700 if (query.length > 0) {

3701 for (var part in query.split("&")) {

3702 var keyvalue = part.split("=");

3703 addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.d ecodeQueryComponent(keyvalue[1]));

3704 }

3705 }

3706 unittest.expect(core.int.parse(queryMap["maxResults"].first), unittest.e quals(arg_maxResults));

3707 unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageTok en));

3708

3709

3710 var h = {

3711 "content-type" : "application/json; charset=utf-8",

3712 };

3713 var resp = convert.JSON.encode(buildUrlChannels());

3714 return new async.Future.value(common_test.stringResponse(200, h, resp));

3715 }), true);

3716 res.list(arg_adClientId, maxResults: arg_maxResults, pageToken: arg_pageTo ken).then(unittest.expectAsync(((api.UrlChannels response) {

3717 checkUrlChannels(response);

3718 })));

3719 });

3720

3721 });

3722

3723

3724 }

3725

OLD	NEW

« no previous file with comments | « generated/googleapis/test/admin/reports_v1_test.dart ('k') | generated/googleapis/test/adsense/v1_4_test.dart » ('j') | no next file with comments »