code
stringlengths 8
3.25M
| repository
stringlengths 15
175
| metadata
stringlengths 66
249
|
|---|---|---|
import 'package:flutter/material.dart';
class Constants {
static const double itemsGutter = 10;
static const double toolbarHeight = 420;
static const double toolbarWidth = 70;
static const double itemsOffset = toolbarWidth - 10;
static const int itemsInView = 7;
static const double toolbarVerticalPadding = 10;
static const double toolbarHorizontalPadding = 10;
static const Duration longPressAnimationDuration =
Duration(milliseconds: 400);
static const Duration scrollScaleAnimationDuration =
Duration(milliseconds: 700);
static const Curve longPressAnimationCurve = Curves.easeOutSine;
static const Curve scrollScaleAnimationCurve = Curves.ease;
}
|
flutter_cool_toolbar/lib/constants.dart/0
|
{'file_path': 'flutter_cool_toolbar/lib/constants.dart', 'repo_id': 'flutter_cool_toolbar', 'token_count': 187}
|
import 'dart:math';
import 'dart:ui';
import 'package:flutter/material.dart';
class DistortedPolygonsGrid extends StatelessWidget {
const DistortedPolygonsGrid({
super.key,
this.maxSideLength = 80,
this.strokeWidth = 1,
this.gap = 30,
this.maxCornersOffset = 20,
this.saturation = 0.7,
this.lightness = 0.5,
this.enableRepetition = true,
this.enableColors = false,
this.minRepetition = 10,
});
final double maxSideLength;
final double strokeWidth;
final double gap;
final double maxCornersOffset;
final double saturation;
final double lightness;
final bool enableRepetition;
final bool enableColors;
final int minRepetition;
@override
Widget build(BuildContext context) {
return ColoredBox(
color: Colors.black,
child: SizedBox.expand(
child: Padding(
padding: const EdgeInsets.all(20),
child: CustomPaint(
painter: RecursiveSquaresCustomPainter(
maxSideLength: maxSideLength,
strokeWidth: strokeWidth,
gap: gap,
maxCornersOffset: maxCornersOffset,
saturation: saturation,
lightness: lightness,
enableRepetition: enableRepetition,
enableColors: enableColors,
minRepetition: minRepetition,
),
),
),
),
);
}
}
class RecursiveSquaresCustomPainter extends CustomPainter {
RecursiveSquaresCustomPainter({
this.maxSideLength = 80,
this.strokeWidth = 2,
this.gap = 10,
this.maxCornersOffset = 20,
this.enableRepetition = true,
this.enableColors = false,
this.saturation = 0.7,
this.lightness = 0.5,
this.minRepetition = 10,
});
final double maxSideLength;
final double strokeWidth;
final double gap;
final double maxCornersOffset;
final double saturation;
final double lightness;
final bool enableRepetition;
final bool enableColors;
final int minRepetition;
static final Random random = Random();
@override
void paint(Canvas canvas, Size size) {
final paint = Paint()
..color = Colors.black
..style = PaintingStyle.stroke
..strokeWidth = strokeWidth;
final xCount = ((size.width + gap) / (maxSideLength + gap)).floor();
final yCount = ((size.height + gap) / (maxSideLength + gap)).floor();
final contentSize = Size(
(xCount * maxSideLength) + ((xCount - 1) * gap),
(yCount * maxSideLength) + ((yCount - 1) * gap),
);
final offset = Offset(
(size.width - contentSize.width) / 2,
(size.height - contentSize.height) / 2,
);
final totalCount = xCount * yCount;
canvas.save();
canvas.translate(offset.dx, offset.dy);
for (int index = 0; index < totalCount; index++) {
int i = index ~/ yCount;
int j = index % yCount;
Offset topLeft = Offset(
i * (maxSideLength + gap),
j * (maxSideLength + gap),
); // add randomized offset
Offset topRight =
topLeft + Offset(maxSideLength, 0); // add randomized offset
Offset bottomRight = topLeft +
Offset(maxSideLength, maxSideLength); // add randomized offset
Offset bottomLeft =
topLeft + Offset(0, maxSideLength); // add randomized offset
final repetition =
enableRepetition ? random.nextInt(10) + minRepetition : 1;
for (int count = 0; count < repetition; count++) {
if (enableColors) {
paint.color = HSLColor.fromAHSL(
1,
random.nextInt(360).toDouble(),
saturation,
lightness,
).toColor();
}
// add randomized offset to each point
topLeft += _randomOffsetFromRange(maxCornersOffset);
topRight += _randomOffsetFromRange(maxCornersOffset);
bottomRight += _randomOffsetFromRange(maxCornersOffset);
bottomLeft += _randomOffsetFromRange(maxCornersOffset);
canvas.drawPoints(
PointMode.polygon,
[
topLeft,
topRight,
bottomRight,
bottomLeft,
topLeft,
],
paint,
);
}
}
canvas.restore();
}
Offset _randomOffsetFromRange(double maxOffset, [double? minOffset]) {
minOffset ??= -maxOffset;
return Offset(
minOffset + random.nextDouble() * (maxOffset - minOffset),
minOffset + random.nextDouble() * (maxOffset - minOffset),
);
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) {
return true;
}
}
|
flutter_generative_art/lib/vera_molnar/distorted_polygons_grid.dart/0
|
{'file_path': 'flutter_generative_art/lib/vera_molnar/distorted_polygons_grid.dart', 'repo_id': 'flutter_generative_art', 'token_count': 1889}
|
import 'package:flutter/widgets.dart';
extension RenderBoxRectExtension<T extends State> on GlobalKey<T> {
Rect get rect {
final renderBox = currentContext!.findRenderObject() as RenderBox;
return renderBox.localToGlobal(Offset.zero) & renderBox.size;
}
}
extension ShiftExtension on Offset {
Offset shift(double delta) => translate(delta, delta);
}
// https://stackoverflow.com/a/55088673/8236404
double Function(double input) interpolate({
double inputMin = 0,
double inputMax = 1,
double outputMin = 0,
double outputMax = 1,
}) {
assert(inputMin != inputMax || outputMin != outputMax);
final diff = (outputMax - outputMin) / (inputMax - inputMin);
return (input) => ((input - inputMin) * diff) + outputMin;
}
extension MixGradientColor on List<Color> {
Color mix(double min, double max, double value) =>
Color.lerp(first, last, interpolate(inputMin: min, inputMax: max)(value))!;
}
|
flutter_guild_demo/lib/utils.dart/0
|
{'file_path': 'flutter_guild_demo/lib/utils.dart', 'repo_id': 'flutter_guild_demo', 'token_count': 303}
|
// ignore_for_file: public_member_api_docs
import 'package:built_collection/built_collection.dart';
import 'package:built_value/built_value.dart';
import 'package:built_value/serializer.dart';
import 'package:built_value/standard_json_plugin.dart';
import 'package:meta/meta.dart';
part 'models.g.dart';
/// json serializer to build models
@SerializersFor([
PlanetPageModel,
PlanetModel,
])
final Serializers serializers =
(_$serializers.toBuilder()..addPlugin(StandardJsonPlugin())).build();
@immutable
abstract class PlanetPageModel
implements Built<PlanetPageModel, PlanetPageModelBuilder> {
factory PlanetPageModel([
void Function(PlanetPageModelBuilder) updates,
]) = _$PlanetPageModel;
const PlanetPageModel._();
static Serializer<PlanetPageModel> get serializer =>
_$planetPageModelSerializer;
String? get next;
String? get previous;
BuiltList<PlanetModel> get results;
}
@immutable
abstract class PlanetModel implements Built<PlanetModel, PlanetModelBuilder> {
factory PlanetModel([
void Function(PlanetModelBuilder) updates,
]) = _$PlanetModel;
const PlanetModel._();
static Serializer<PlanetModel> get serializer => _$planetModelSerializer;
String get name;
}
|
flutter_hooks/packages/flutter_hooks/example/lib/star_wars/models.dart/0
|
{'file_path': 'flutter_hooks/packages/flutter_hooks/example/lib/star_wars/models.dart', 'repo_id': 'flutter_hooks', 'token_count': 371}
|
part of 'hooks.dart';
/// Creates a [ExpansionTileController] that will be disposed automatically.
///
/// See also:
/// - [ExpansionTileController]
ExpansionTileController useExpansionTileController({List<Object?>? keys}) {
return use(_ExpansionTileControllerHook(keys: keys));
}
class _ExpansionTileControllerHook extends Hook<ExpansionTileController> {
const _ExpansionTileControllerHook({List<Object?>? keys}) : super(keys: keys);
@override
HookState<ExpansionTileController, Hook<ExpansionTileController>>
createState() => _ExpansionTileControllerHookState();
}
class _ExpansionTileControllerHookState
extends HookState<ExpansionTileController, _ExpansionTileControllerHook> {
final controller = ExpansionTileController();
@override
String get debugLabel => 'useExpansionTileController';
@override
ExpansionTileController build(BuildContext context) => controller;
}
|
flutter_hooks/packages/flutter_hooks/lib/src/expansion_tile_controller.dart/0
|
{'file_path': 'flutter_hooks/packages/flutter_hooks/lib/src/expansion_tile_controller.dart', 'repo_id': 'flutter_hooks', 'token_count': 252}
|
part of 'hooks.dart';
class _TextEditingControllerHookCreator {
const _TextEditingControllerHookCreator();
/// Creates a [TextEditingController] that will be disposed automatically.
///
/// The [text] parameter can be used to set the initial value of the
/// controller.
TextEditingController call({String? text, List<Object?>? keys}) {
return use(_TextEditingControllerHook(text, keys));
}
/// Creates a [TextEditingController] from the initial [value] that will
/// be disposed automatically.
TextEditingController fromValue(
TextEditingValue value, [
List<Object?>? keys,
]) {
return use(_TextEditingControllerHook.fromValue(value, keys));
}
}
/// Creates a [TextEditingController], either via an initial text or an initial
/// [TextEditingValue].
///
/// To use a [TextEditingController] with an optional initial text, use:
/// ```dart
/// final controller = useTextEditingController(text: 'initial text');
/// ```
///
/// To use a [TextEditingController] with an optional initial value, use:
/// ```dart
/// final controller = useTextEditingController
/// .fromValue(TextEditingValue.empty);
/// ```
///
/// Changing the text or initial value after the widget has been built has no
/// effect whatsoever. To update the value in a callback, for instance after a
/// button was pressed, use the [TextEditingController.text] or
/// [TextEditingController.value] setters. To have the [TextEditingController]
/// reflect changing values, you can use [useEffect]. This example will update
/// the [TextEditingController.text] whenever a provided [ValueListenable]
/// changes:
/// ```dart
/// final controller = useTextEditingController();
/// final update = useValueListenable(myTextControllerUpdates);
///
/// useEffect(() {
/// controller.text = update;
/// }, [update]);
/// ```
///
/// See also:
/// - [TextEditingController], which this hook creates.
const useTextEditingController = _TextEditingControllerHookCreator();
class _TextEditingControllerHook extends Hook<TextEditingController> {
const _TextEditingControllerHook(
this.initialText, [
List<Object?>? keys,
]) : initialValue = null,
super(keys: keys);
const _TextEditingControllerHook.fromValue(
TextEditingValue this.initialValue, [
List<Object?>? keys,
]) : initialText = null,
super(keys: keys);
final String? initialText;
final TextEditingValue? initialValue;
@override
_TextEditingControllerHookState createState() {
return _TextEditingControllerHookState();
}
}
class _TextEditingControllerHookState
extends HookState<TextEditingController, _TextEditingControllerHook> {
late final _controller = hook.initialValue != null
? TextEditingController.fromValue(hook.initialValue)
: TextEditingController(text: hook.initialText);
@override
TextEditingController build(BuildContext context) => _controller;
@override
void dispose() => _controller.dispose();
@override
String get debugLabel => 'useTextEditingController';
}
|
flutter_hooks/packages/flutter_hooks/lib/src/text_controller.dart/0
|
{'file_path': 'flutter_hooks/packages/flutter_hooks/lib/src/text_controller.dart', 'repo_id': 'flutter_hooks', 'token_count': 899}
|
import 'package:flutter/widgets.dart';
import 'package:flutter_hooks/flutter_hooks.dart';
import 'mock.dart';
void main() {
testWidgets('useCallback', (tester) async {
late int Function() fn;
await tester.pumpWidget(
HookBuilder(builder: (context) {
fn = useCallback<int Function()>(() => 42, []);
return Container();
}),
);
expect(fn(), 42);
late int Function() fn2;
await tester.pumpWidget(
HookBuilder(builder: (context) {
fn2 = useCallback<int Function()>(() => 42, []);
return Container();
}),
);
expect(fn2, fn);
late int Function() fn3;
await tester.pumpWidget(
HookBuilder(builder: (context) {
fn3 = useCallback<int Function()>(() => 21, [42]);
return Container();
}),
);
expect(fn3, isNot(fn));
expect(fn3(), 21);
});
testWidgets(
'should return same function when keys are not specified',
(tester) async {
late Function fn1;
late Function fn2;
await tester.pumpWidget(
HookBuilder(
key: const Key('hook_builder'),
builder: (context) {
fn1 = useCallback(() {});
return Container();
},
),
);
await tester.pumpWidget(
HookBuilder(
key: const Key('hook_builder'),
builder: (context) {
fn2 = useCallback(() {});
return Container();
},
),
);
expect(fn1, same(fn2));
},
);
}
|
flutter_hooks/packages/flutter_hooks/test/use_callback_test.dart/0
|
{'file_path': 'flutter_hooks/packages/flutter_hooks/test/use_callback_test.dart', 'repo_id': 'flutter_hooks', 'token_count': 698}
|
import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_hooks/flutter_hooks.dart';
import 'mock.dart';
void main() {
testWidgets('debugFillProperties', (tester) async {
await tester.pumpWidget(
HookBuilder(builder: (context) {
useReducer<int?, int?>(
(state, action) => 42,
initialAction: null,
initialState: null,
);
return const SizedBox();
}),
);
final element = tester.element(find.byType(HookBuilder));
expect(
element
.toDiagnosticsNode(style: DiagnosticsTreeStyle.offstage)
.toStringDeep(),
equalsIgnoringHashCodes(
'HookBuilder\n'
' │ useReducer: 42\n'
' └SizedBox(renderObject: RenderConstrainedBox#00000)\n',
),
);
});
group('useReducer', () {
testWidgets('supports null initial state', (tester) async {
Store<Object?, Object?>? store;
await tester.pumpWidget(
HookBuilder(
builder: (context) {
store = useReducer(
(state, action) => state,
initialAction: null,
initialState: null,
);
return Container();
},
),
);
expect(store!.state, isNull);
});
testWidgets('supports null state after dispatch', (tester) async {
Store<int?, int?>? store;
await tester.pumpWidget(
HookBuilder(
builder: (context) {
store = useReducer(
(state, action) => action,
initialAction: 0,
initialState: null,
);
return Container();
},
),
);
expect(store?.state, 0);
store!.dispatch(null);
expect(store!.state, null);
});
testWidgets('initialize the state even "state" is never read',
(tester) async {
final reducer = MockReducer();
await tester.pumpWidget(
HookBuilder(
builder: (context) {
useReducer<int?, String?>(
reducer,
initialAction: '',
initialState: 0,
);
return Container();
},
),
);
verify(reducer(null, null)).called(1);
verifyNoMoreInteractions(reducer);
});
testWidgets('basic', (tester) async {
final reducer = MockReducer();
Store<int?, String?>? store;
Future<void> pump() {
return tester.pumpWidget(
HookBuilder(
builder: (context) {
store = useReducer(
reducer,
initialAction: null,
initialState: null,
);
return Container();
},
),
);
}
when(reducer(null, null)).thenReturn(0);
await pump();
final element = tester.firstElement(find.byType(HookBuilder));
verify(reducer(null, null)).called(1);
verifyNoMoreInteractions(reducer);
expect(store!.state, 0);
await pump();
verifyNoMoreInteractions(reducer);
expect(store!.state, 0);
when(reducer(0, 'foo')).thenReturn(1);
store!.dispatch('foo');
verify(reducer(0, 'foo')).called(1);
verifyNoMoreInteractions(reducer);
expect(element.dirty, true);
await pump();
when(reducer(1, 'bar')).thenReturn(1);
store!.dispatch('bar');
verify(reducer(1, 'bar')).called(1);
verifyNoMoreInteractions(reducer);
expect(element.dirty, false);
});
testWidgets('dispatch during build works', (tester) async {
Store<int?, int?>? store;
await tester.pumpWidget(
HookBuilder(
builder: (context) {
store = useReducer<int?, int?>(
(state, action) => action,
initialAction: 0,
initialState: null,
)..dispatch(42);
return Container();
},
),
);
expect(store!.state, 42);
});
testWidgets('first reducer call receive initialAction and initialState',
(tester) async {
final reducer = MockReducer();
when(reducer(0, 'Foo')).thenReturn(42);
await tester.pumpWidget(
HookBuilder(
builder: (context) {
final result = useReducer<int?, String?>(
reducer,
initialAction: 'Foo',
initialState: 0,
).state;
return Text('$result', textDirection: TextDirection.ltr);
},
),
);
expect(find.text('42'), findsOneWidget);
});
});
}
class MockReducer extends Mock {
int? call(int? state, String? action) {
return super.noSuchMethod(
Invocation.getter(#call),
returnValue: 0,
) as int?;
}
}
|
flutter_hooks/packages/flutter_hooks/test/use_reducer_test.dart/0
|
{'file_path': 'flutter_hooks/packages/flutter_hooks/test/use_reducer_test.dart', 'repo_id': 'flutter_hooks', 'token_count': 2325}
|
export 'github_user.dart';
export 'search_result_error.dart';
export 'search_result_item.dart';
export 'search_result.dart';
|
flutter_hub/github_repository/lib/src/models/models.dart/0
|
{'file_path': 'flutter_hub/github_repository/lib/src/models/models.dart', 'repo_id': 'flutter_hub', 'token_count': 44}
|
import 'package:equatable/equatable.dart';
abstract class GithubSearchEvent extends Equatable {
GithubSearchEvent([List props = const []]) : super(props);
}
class FetchInitialProjects extends GithubSearchEvent {
@override
String toString() => 'FetchInitialProjects';
}
class FetchInitialProfiles extends GithubSearchEvent {
@override
String toString() => 'FetchInitialProfiles';
}
class ProjectTextChanged extends GithubSearchEvent {
final String text;
ProjectTextChanged({this.text}) : super([text]);
@override
String toString() => 'ProjectTextChanged { text: $text }';
}
class ProfileTextChanged extends GithubSearchEvent {
final String text;
ProfileTextChanged({this.text}) : super([text]);
@override
String toString() => 'ProfileTextChanged { text: $text }';
}
|
flutter_hub/lib/github_search_bloc/github_search_event.dart/0
|
{'file_path': 'flutter_hub/lib/github_search_bloc/github_search_event.dart', 'repo_id': 'flutter_hub', 'token_count': 229}
|
library reddit_repository;
export 'src/reddit_repository.dart';
export 'src/reddit_cache.dart';
export 'src/reddit_client.dart';
export 'src/models/models.dart';
|
flutter_hub/reddit_repository/lib/reddit_repository.dart/0
|
{'file_path': 'flutter_hub/reddit_repository/lib/reddit_repository.dart', 'repo_id': 'flutter_hub', 'token_count': 59}
|
import 'platform_web.dart' if (dart.library.io) 'platform_io.dart';
/// Class to check which is the current platform allow the compilation from web/mobile/desktop
abstract class PlatformCheck {
static bool get isWeb => currentPlatform == PlatformCheckType.Web;
static bool get isMacOS => currentPlatform == PlatformCheckType.MacOS;
static bool get isWindows => currentPlatform == PlatformCheckType.Windows;
static bool get isLinux => currentPlatform == PlatformCheckType.Linux;
static bool get isAndroid => currentPlatform == PlatformCheckType.Android;
static bool get isIOS => currentPlatform == PlatformCheckType.IOS;
}
enum PlatformCheckType { Web, Windows, Linux, MacOS, Android, Fuchsia, IOS }
|
flutter_keyboard_actions/lib/external/platform_check/platform_check.dart/0
|
{'file_path': 'flutter_keyboard_actions/lib/external/platform_check/platform_check.dart', 'repo_id': 'flutter_keyboard_actions', 'token_count': 187}
|
import 'package:flutter/material.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
// This widget is the root of your application.
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
// This is the theme of your application.
//
// Try running your application with "flutter run". You'll see the
// application has a blue toolbar. Then, without quitting the app, try
// changing the primarySwatch below to Colors.green and then invoke
// "hot reload" (press "r" in the console where you ran "flutter run",
// or press Run > Flutter Hot Reload in IntelliJ). Notice that the
// counter didn't reset back to zero; the application is not restarted.
primarySwatch: Colors.blue,
),
home: MyHomePage(title: 'Flutter Demo Home Page'),
);
}
}
class MyHomePage extends StatefulWidget {
MyHomePage({Key key, this.title}) : super(key: key);
// This widget is the home page of your application. It is stateful, meaning
// that it has a State object (defined below) that contains fields that affect
// how it looks.
// This class is the configuration for the state. It holds the values (in this
// case the title) provided by the parent (in this case the App widget) and
// used by the build method of the State. Fields in a Widget subclass are
// always marked "final".
final String title;
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
void _incrementCounter() {
setState(() {
// This call to setState tells the Flutter framework that something has
// changed in this State, which causes it to rerun the build method below
// so that the display can reflect the updated values. If we changed
// _counter without calling setState(), then the build method would not be
// called again, and so nothing would appear to happen.
_counter++;
});
}
@override
Widget build(BuildContext context) {
// This method is rerun every time setState is called, for instance as done
// by the _incrementCounter method above.
//
// The Flutter framework has been optimized to make rerunning build methods
// fast, so that you can just rebuild anything that needs updating rather
// than having to individually change instances of widgets.
return Scaffold(
appBar: AppBar(
// Here we take the value from the MyHomePage object that was created by
// the App.build method, and use it to set our appbar title.
title: Text(widget.title),
),
body: Center(
// Center is a layout widget. It takes a single child and positions it
// in the middle of the parent.
child: Column(
// Column is also layout widget. It takes a list of children and
// arranges them vertically. By default, it sizes itself to fit its
// children horizontally, and tries to be as tall as its parent.
//
// Invoke "debug paint" (press "p" in the console where you ran
// "flutter run", or select "Toggle Debug Paint" from the Flutter tool
// window in IntelliJ) to see the wireframe for each widget.
//
// Column has various properties to control how it sizes itself and
// how it positions its children. Here we use mainAxisAlignment to
// center the children vertically; the main axis here is the vertical
// axis because Columns are vertical (the cross axis would be
// horizontal).
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text(
'You have pushed the button this many times:',
),
Text(
'$_counter',
style: Theme.of(context).textTheme.display1,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
), // This trailing comma makes auto-formatting nicer for build methods.
);
}
}
|
flutter_launcher_icons/example/lib/main.dart/0
|
{'file_path': 'flutter_launcher_icons/example/lib/main.dart', 'repo_id': 'flutter_launcher_icons', 'token_count': 1482}
|
import 'package:flutter/material.dart';
import 'custom_tweens/scale_tween.dart';
class LoadKitScalingWave extends StatefulWidget {
const LoadKitScalingWave({
super.key,
this.itemBuilder,
this.color = Colors.black,
this.size = 50.0,
this.itemCount = 7,
this.controller,
}) : assert(itemCount > 2, "Item count should not be less than 2");
final IndexedWidgetBuilder? itemBuilder;
final Color color;
final double size;
final int itemCount;
final AnimationController? controller;
@override
State<LoadKitScalingWave> createState() => _LoadKitScalingWaveState();
}
class _LoadKitScalingWaveState extends State<LoadKitScalingWave>
with TickerProviderStateMixin {
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = widget.controller ??
AnimationController(
vsync: this,
duration: const Duration(seconds: 2),
);
_controller.repeat();
}
@override
void dispose() {
if (widget.controller == null) {
_controller.dispose();
}
super.dispose();
}
Widget _buildItem(int index) => widget.itemBuilder != null
? widget.itemBuilder!(context, index)
: Container(
decoration: BoxDecoration(
color: widget.color,
borderRadius: BorderRadius.circular(40),
),
);
@override
Widget build(BuildContext context) {
return Center(
child: Row(
crossAxisAlignment: CrossAxisAlignment.center,
mainAxisAlignment: MainAxisAlignment.center,
mainAxisSize: MainAxisSize.min,
children: List.generate(widget.itemCount, (i) {
return SizedBox.fromSize(
size: Size(widget.size / (widget.itemCount * 0.6), widget.size),
child: ScaleTransition(
alignment: Alignment.center,
scale: OverScaleTween(
begin: 0,
end: 1,
scale: List.generate(widget.itemCount, (index) {
int newIndex = index;
return (newIndex * 0.06);
})[i],
).animate(_controller),
child: _buildItem(i),
),
);
}),
),
);
}
}
|
flutter_loadkit/lib/src/loadkit_scaling_wave.dart/0
|
{'file_path': 'flutter_loadkit/lib/src/loadkit_scaling_wave.dart', 'repo_id': 'flutter_loadkit', 'token_count': 981}
|
name: Format, Analyze and Test
on:
push:
branches:
- master
pull_request:
branches:
- master
schedule:
# runs the CI weekly
- cron: "0 0 * * 0"
jobs:
default_run:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-java@v3
with:
distribution: 'zulu'
java-version: '17'
- uses: subosito/flutter-action@v2
with:
channel: 'stable'
flutter-version: '3.10.5'
cache: true
cache-key: 'flutter-:os:-:channel:-:version:-:arch:-:hash:'
cache-path: '${{ runner.tool_cache }}/flutter/:channel:-:version:-:arch:'
- run: flutter pub get
- run: dart format --set-exit-if-changed -l 120 lib -l 120 example
- run: flutter analyze lib example
- run: flutter test --no-pub --coverage
- name: Upload coverage to codecov
uses: codecov/codecov-action@v1
with:
fail_ci_if_error: true
|
flutter_offline/.github/workflows/main.yml/0
|
{'file_path': 'flutter_offline/.github/workflows/main.yml', 'repo_id': 'flutter_offline', 'token_count': 469}
|
import 'package:flutter/material.dart';
import 'package:flutter_offline/flutter_offline.dart';
class Demo3 extends StatelessWidget {
const Demo3({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return OfflineBuilder(
debounceDuration: Duration.zero,
connectivityBuilder: (
BuildContext context,
ConnectivityResult connectivity,
Widget child,
) {
if (connectivity == ConnectivityResult.none) {
return Container(
color: Colors.white70,
child: const Center(
child: Text(
'Oops, \n\nWe experienced a Delayed Offline!',
style: TextStyle(color: Colors.black),
),
),
);
}
return child;
},
child: const Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Text(
'There are no bottons to push :)',
),
Text(
'Just turn off your internet.',
),
Text(
'This one has a bit of a delay.',
),
],
),
),
);
}
}
|
flutter_offline/example/lib/widgets/demo_3.dart/0
|
{'file_path': 'flutter_offline/example/lib/widgets/demo_3.dart', 'repo_id': 'flutter_offline', 'token_count': 616}
|
import 'package:flutter/material.dart';
import 'package:webview_flutter/webview_flutter.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
home: Builder(
builder: (context) => Scaffold(
appBar: AppBar(title: Text('Example')),
body: WebView(
initialUrl: 'https://google.com',
javascriptMode: JavascriptMode.unrestricted,
),
floatingActionButton: FloatingActionButton(
child: Icon(Icons.add),
onPressed: () {
showSearch(
context: context,
delegate: MockSearch(),
);
},
),
),
),
);
}
}
class MockSearch extends SearchDelegate {
@override
List<Widget> buildActions(BuildContext context) {
return [];
}
@override
Widget buildLeading(BuildContext context) {
return IconButton(
icon: Icon(Icons.close),
onPressed: () => close(
context,
null,
),
);
}
@override
Widget buildResults(BuildContext context) {
return Container();
}
@override
Widget buildSuggestions(BuildContext context) {
return Container();
}
}
|
flutter_platform_view_error/lib/main.dart/0
|
{'file_path': 'flutter_platform_view_error/lib/main.dart', 'repo_id': 'flutter_platform_view_error', 'token_count': 565}
|
import 'package:flutter/material.dart';
import 'package:flutter_playlist_animation/utils/animation_manager.dart';
import 'package:flutter_playlist_animation/utils/library_data.dart';
import 'package:flutter_playlist_animation/widgets/image_wrapper.dart';
import 'package:flutter_playlist_animation/widgets/song_action_buttons.dart';
import 'package:flutter_playlist_animation/widgets/song_list_item.dart';
class PlaylistPage extends StatefulWidget {
const PlaylistPage({
super.key,
required this.routeAnimation,
required this.image,
required this.heroTag,
});
final Animation<double> routeAnimation;
final String image;
final String heroTag;
@override
State<PlaylistPage> createState() => _PlaylistPageState();
}
class _PlaylistPageState extends State<PlaylistPage> {
late final Animation<double> appBarOffsetAnimation;
late final Animation<Offset> contentOffsetAnimation;
@override
void initState() {
appBarOffsetAnimation = Tween(begin: -100.0, end: 0.0).animate(
CurvedAnimation(
parent: widget.routeAnimation,
curve: const Interval(0.5, 1, curve: Curves.easeOut),
),
);
contentOffsetAnimation = Tween<Offset>(
begin: const Offset(0, 1),
end: const Offset(0, 0),
).animate(
CurvedAnimation(
parent: widget.routeAnimation,
curve: const Interval(0.5, 1, curve: Curves.easeOut),
),
);
super.initState();
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: Column(
children: [
AnimatedBuilder(
animation: appBarOffsetAnimation,
builder: (context, child) {
return Transform.translate(
offset: Offset(0, appBarOffsetAnimation.value),
child: AppBar(),
);
},
),
Expanded(
child: CustomScrollView(
slivers: [
SliverAppBar(
expandedHeight: 240,
automaticallyImplyLeading: false,
floating: true,
pinned: true,
flexibleSpace: Container(
margin: const EdgeInsets.only(bottom: 20),
child: Center(
child: Hero(
tag: widget.heroTag,
child: Transform(
transform: AnimationManager.endTransformMatrix,
alignment: Alignment.center,
child: ImageWrapper(image: widget.image),
),
),
),
),
),
SliverPadding(
padding: const EdgeInsets.symmetric(horizontal: 20),
sliver: SliverToBoxAdapter(
child: SlideTransition(
position: contentOffsetAnimation,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
const Center(
child: Text(
'Acoustic',
style: TextStyle(
fontSize: 22,
fontWeight: FontWeight.w700,
),
),
),
const SizedBox(height: 20),
const SongActionButtons(),
const SizedBox(height: 20),
const Text(
'Upcoming songs',
style: TextStyle(fontSize: 22),
),
ListView.builder(
shrinkWrap: true,
padding: EdgeInsets.only(
top: 10,
bottom:
MediaQuery.of(context).padding.bottom + 20,
),
physics: const NeverScrollableScrollPhysics(),
itemCount: LibraryData.playlistImages.length,
itemBuilder: (context, index) => SongListItem(
image: LibraryData.playlistImages[index],
),
),
],
),
),
),
),
],
),
)
],
),
);
}
}
|
flutter_playlist_animation/lib/pages/playlist_page.dart/0
|
{'file_path': 'flutter_playlist_animation/lib/pages/playlist_page.dart', 'repo_id': 'flutter_playlist_animation', 'token_count': 2646}
|
name: flutter_scale_aware
description: A new Flutter package project.
version: 0.0.1
author: Jeremiah Ogbomo <jeremiahogbomo@gmail.com>
homepage: https://github.com/jogboms/flutter_screen_aware
environment:
sdk: '>=2.12.0 <3.0.0'
dependencies:
flutter:
sdk: flutter
dev_dependencies:
flutter_test:
sdk: flutter
pedantic: ^1.11.0
test_coverage:
git:
url: https://github.com/timsneath/test-coverage.git
|
flutter_scale_aware/pubspec.yaml/0
|
{'file_path': 'flutter_scale_aware/pubspec.yaml', 'repo_id': 'flutter_scale_aware', 'token_count': 181}
|
// ignore_for_file: prefer_const_constructors
import 'dart:ui';
import 'package:flutter/material.dart';
import 'package:flutter_services_binding/flutter_services_binding.dart';
import 'package:flutter_test/flutter_test.dart';
class MyApp extends StatelessWidget {
const MyApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return MaterialApp();
}
}
void main() {
group('FlutterServicesBinding', () {
test('.ensureInitialized creates an instance', () {
expect(FlutterServicesBinding.ensureInitialized(), isNotNull);
});
test('.ensureInitialized returns existing instance', () {
final instanceA = FlutterServicesBinding.ensureInitialized();
final instanceB = FlutterServicesBinding.ensureInitialized();
expect(instanceA, equals(instanceB));
});
test('.platformDispatcher returns an instance', () {
expect(
FlutterServicesBinding.ensureInitialized().platformDispatcher,
equals(PlatformDispatcher.instance),
);
});
test('.initServiceExtensions does nothing', () {
FlutterServicesBinding.ensureInitialized().initServiceExtensions();
});
test('.lockEvents completes', () {
expect(
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().lockEvents(() async {}),
completes,
);
});
test('.locked returns false', () {
expect(
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().locked,
isFalse,
);
});
test('.unlocked does nothing', () {
FlutterServicesBinding.ensureInitialized().unlocked();
});
test('.reassembleApplication completes', () {
expect(
FlutterServicesBinding.ensureInitialized().reassembleApplication(),
completes,
);
});
test('.performReassemble completes', () {
expect(
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().performReassemble(),
completes,
);
});
test('.registerSignalServiceExtension does nothing', () {
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().registerSignalServiceExtension(
name: 'name',
callback: () async {},
);
});
test('.registerBoolServiceExtension does nothing', () {
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().registerBoolServiceExtension(
name: 'name',
getter: () async => true,
setter: (_) async {},
);
});
test('.registerNumericServiceExtension does nothing', () {
FlutterServicesBinding.ensureInitialized()
// ignore: invalid_use_of_protected_member
.registerNumericServiceExtension(
name: 'name',
getter: () async => 0,
setter: (_) async {},
);
});
test('.registerStringServiceExtension does nothing', () {
FlutterServicesBinding.ensureInitialized()
// ignore: invalid_use_of_protected_member
.registerStringServiceExtension(
name: 'name',
getter: () async => '',
setter: (_) async {},
);
});
test('.registerServiceExtension does nothing', () {
FlutterServicesBinding.ensureInitialized()
// ignore: invalid_use_of_protected_member
.registerServiceExtension(
name: 'name',
callback: (_) async => <String, dynamic>{},
);
});
test('.postEvent does nothing', () {
// ignore: invalid_use_of_protected_member
FlutterServicesBinding.ensureInitialized().postEvent(
'eventKind',
<String, dynamic>{},
);
});
test('.toString returns correct value', () {
// ignore: invalid_use_of_protected_member
expect(
FlutterServicesBinding.ensureInitialized().toString(),
equals('<FlutterServicesBinding>'),
);
});
});
}
|
flutter_services_binding/test/src/flutter_services_binding_test.dart/0
|
{'file_path': 'flutter_services_binding/test/src/flutter_services_binding_test.dart', 'repo_id': 'flutter_services_binding', 'token_count': 1534}
|
library flutter_spinkit;
export 'src/chasing_dots.dart';
export 'src/circle.dart';
export 'src/cube_grid.dart';
export 'src/dancing_square.dart';
export 'src/double_bounce.dart';
export 'src/dual_ring.dart';
export 'src/fading_circle.dart';
export 'src/fading_cube.dart';
export 'src/fading_four.dart';
export 'src/fading_grid.dart';
export 'src/folding_cube.dart';
export 'src/hour_glass.dart';
export 'src/piano_wave.dart';
export 'src/pouring_hour_glass.dart';
export 'src/pouring_hour_glass_refined.dart';
export 'src/pulse.dart';
export 'src/pulsing_grid.dart';
export 'src/pumping_heart.dart';
export 'src/ring.dart';
export 'src/ripple.dart';
export 'src/rotating_circle.dart';
export 'src/rotating_plain.dart';
export 'src/spinning_circle.dart';
export 'src/spinning_lines.dart';
export 'src/square_circle.dart';
export 'src/three_bounce.dart';
export 'src/three_in_out.dart';
export 'src/wandering_cubes.dart';
export 'src/wave.dart';
export 'src/wave_spinner.dart';
|
flutter_spinkit/lib/flutter_spinkit.dart/0
|
{'file_path': 'flutter_spinkit/lib/flutter_spinkit.dart', 'repo_id': 'flutter_spinkit', 'token_count': 395}
|
import 'package:flutter/material.dart';
class FakeBox extends SizedBox {
const FakeBox({Key? key}) : super(key: key);
}
Widget fakeBoxBuilder(BuildContext _, int index) => const FakeBox();
Widget createWidgetsApp(Widget widget) {
return WidgetsApp(
color: Colors.grey[900]!,
home: Center(child: widget),
pageRouteBuilder: <T>(settings, builder) => MaterialPageRoute<T>(
settings: settings,
builder: builder,
),
);
}
Widget createMaterialApp(Widget widget) {
return MaterialApp(theme: ThemeData.dark(), home: Center(child: widget));
}
|
flutter_spinkit/test/helpers.dart/0
|
{'file_path': 'flutter_spinkit/test/helpers.dart', 'repo_id': 'flutter_spinkit', 'token_count': 192}
|
import 'package:flutter/material.dart';
import 'package:flutter_spinkit/flutter_spinkit.dart';
import 'package:flutter_test/flutter_test.dart';
import 'helpers.dart';
void main() {
group('ThreeBounce', () {
testWidgets(
'needs either color or itemBuilder',
(WidgetTester tester) async {
expect(() => SpinKitThreeBounce(), throwsAssertionError);
expect(
() => SpinKitThreeBounce(
color: Colors.white,
itemBuilder: fakeBoxBuilder,
),
throwsAssertionError,
);
},
);
testWidgets('needs color to be non-null', (WidgetTester tester) async {
expect(() => SpinKitThreeBounce(color: null), throwsAssertionError);
});
testWidgets(
'needs itemBuilder to be non-null',
(WidgetTester tester) async {
expect(
() => SpinKitThreeBounce(itemBuilder: null),
throwsAssertionError,
);
},
);
testWidgets('works with color', (WidgetTester tester) async {
await tester.pumpWidget(
createMaterialApp(const SpinKitThreeBounce(color: Colors.white)),
);
expect(find.byType(SpinKitThreeBounce), findsOneWidget);
expect(find.byType(DecoratedBox), findsWidgets);
tester.verifyTickersWereDisposed();
});
testWidgets('works with itemBuilder', (WidgetTester tester) async {
await tester.pumpWidget(
createMaterialApp(
const SpinKitThreeBounce(itemBuilder: fakeBoxBuilder),
),
);
expect(find.byType(SpinKitThreeBounce), findsOneWidget);
expect(find.byType(FakeBox), findsWidgets);
tester.verifyTickersWereDisposed();
});
testWidgets('works without Material', (WidgetTester tester) async {
await tester.pumpWidget(
createWidgetsApp(const SpinKitThreeBounce(color: Colors.white)),
);
expect(find.byType(SpinKitThreeBounce), findsOneWidget);
expect(find.byType(DecoratedBox), findsWidgets);
tester.verifyTickersWereDisposed();
});
});
}
|
flutter_spinkit/test/three_bounce_test.dart/0
|
{'file_path': 'flutter_spinkit/test/three_bounce_test.dart', 'repo_id': 'flutter_spinkit', 'token_count': 858}
|
import 'package:flutter/material.dart';
import 'package:flutter_super/src/instance.dart';
/// A stateful widget that represents the root of the Super framework.
final class SuperApp extends StatefulWidget {
/// Creates a SuperApp widget.
///
/// The [child] parameter is required and represents the main content
/// of the app.
///
/// The [mocks] parameter is an optional list of objects used for
/// mocking dependencies during testing.
/// The `mocks` property provides a way to inject mock objects into the
/// application's dependency graph during testing.
/// These mock objects can replace real dependencies, such as database
/// connections or network clients,
/// allowing for controlled and predictable testing scenarios.
///
/// **Note:** When using the `mocks` property, make sure to provide
/// instantiated mock objects, not just their types.
/// For example, instead of `[MockAuthRepo]`, use `[MockAuthRepo()]`
/// to ensure that the mock object is used.
/// Adding the type without instantiating the mock object will result
/// in the mock not being utilized.
///
/// It is recommended to use the `mocks` property sparingly and only
/// when necessary for testing purposes.
/// In most cases, the application should rely on the actual
/// dependencies to ensure accurate behavior.
///
/// The [testMode] parameter is an optional boolean value that enables
/// or disables test mode.
/// When [testMode] is set to `true`, the Super framework is activated
/// in test mode.
/// Test mode can be used to enable additional testing features or
/// behaviors specific to the Super framework.
/// By default, test mode is set to `false`.
///
/// The [autoDispose] parameter is an optional boolean value that
/// determines whether the Super framework should automatically
/// dispose of controllers, dependencies, and other resources
/// when they are no longer needed.
/// By default, [autoDispose] is set to `true`, enabling automatic disposal.
/// Set [autoDispose] to `false` if you want to manually handle the
/// disposal of resources in your application.
///
/// Example usage:
///
/// ```dart
/// SuperApp(
/// mocks: [
/// MockAuthRepo(),
/// MockDatabase(),
/// ],
/// testMode: true,
/// child: const MyApp(),
/// );
/// ```
const SuperApp({
required this.child,
super.key,
this.mocks,
this.testMode = false,
this.autoDispose = true,
});
/// The main content widget of the app.
final Widget child;
/// An optional list of objects used for mocking dependencies during testing.
final List<Object>? mocks;
/// An optional boolean value that enables or disables test mode
/// for the Super framework.
///
/// When [testMode] is set to `true`, the Super framework is
/// activated in test mode.
/// Test mode can be used to enable additional testing features
/// or behaviors specific to the Super framework.
/// By default, test mode is set to `false`.
final bool testMode;
/// An optional boolean value that determines whether the Super framework
/// should automatically dispose of controllers, dependencies, and other
/// resources when they are no longer needed.
///
/// By default, [autoDispose] is set to `true`, enabling automatic disposal.
/// Set [autoDispose] to `false` if you want to manually handle the
/// disposal of resources in your application.
///
/// When [autoDispose] is `true`, the Super framework will automatically
/// dispose of controllers, dependencies, and other resources when
/// the associated widgets are removed from the widget tree.
///
/// When [autoDispose] is `false`, it is the responsibility of the
/// developer to manually dispose of resources using appropriate
/// methods provided by the Super framework.
///
/// Example usage:
///
/// ```dart
/// SuperApp(
/// child: MyApp(),
/// autoDispose: false,
/// );
/// ```
final bool autoDispose;
@override
State<SuperApp> createState() => _SuperAppState();
}
class _SuperAppState extends State<SuperApp> {
@override
void initState() {
super.initState();
// Activate the Super framework
InstanceManager.activate(
autoDispose: widget.autoDispose,
mocks: widget.mocks,
testMode: widget.testMode,
);
}
@override
void dispose() {
// Deactivate the Super framework
InstanceManager.deactivate('super');
super.dispose();
}
@override
Widget build(BuildContext context) {
// Return the child widget as the main content of the app.
return widget.child;
}
}
|
flutter_super/lib/src/framework.dart/0
|
{'file_path': 'flutter_super/lib/src/framework.dart', 'repo_id': 'flutter_super', 'token_count': 1283}
|
import 'package:flutter/material.dart';
import 'package:flutter_super/src/core/typedefs.dart';
import 'package:flutter_super/src/rx/rx.dart';
/// A widget that calls the listener callback when the given rx object changes.
///
/// The [SuperListener] widget listens to changes in the provided rx object
/// and calls the [listener] callback when the rx object changes its value.
///
/// The [listener] callback is called once when the rx object changes
/// its value.
///
/// The [child] parameter is an optional child widget to be rendered by
/// this widget.
///
/// The [listenWhen] parameter is an optional condition that determines whether
/// the [listener] should be called when the rx object changes. If
/// [listenWhen] evaluates to `true`, the [listener]
/// will be called; otherwise, it will be skipped.
///
/// Example usage:
/// ```dart
/// SuperListener<int>(
/// listen: () => controller.count;
/// listenWhen: (count) => count > 5,
/// listener: (context) {
/// // Handle the state change here
/// }, // Only call the listener if count is greater than 5
/// child: Text('Counter'),
/// )
/// ```
///
/// **Note:** You need to make use of an [Rx] object value in the
/// listen parameter, otherwise, it will result in an error.
class SuperListener<T> extends StatefulWidget {
/// Creates a widget that rebuilds when the given rx object changes.
///
/// The [listener] callback is called once when the rx object changes
/// its value.
///
/// The [child] parameter is an optional child widget to be rendered by
/// this widget.
///
/// The [listenWhen] parameter is an optional condition that determines
/// whether the [listener] should be called when the rx object changes.
/// If [listenWhen] evaluates to `true`, the [listener] will be called;
/// otherwise, it will be skipped.
const SuperListener({
required this.listener,
required this.listen,
super.key,
this.child,
this.listenWhen,
});
/// An optional child widget to be rendered by this widget.
final Widget? child;
/// Called once when the rx changes value.
final RxCallback listener;
/// The value of the [Rx] object to listen to.
final T Function() listen;
/// An optional condition that determines whether the [listener]
/// should be called when the rx object changes. If [listenWhen]
/// evaluates to `true`, the [listener] will be called; otherwise,
/// it will be skipped. The [listenWhen] callback receives the previous
/// and current values of the rx object as arguments.
final bool Function(T state)? listenWhen;
@override
State<SuperListener<T>> createState() => _SuperListenerState<T>();
}
class _SuperListenerState<T> extends State<SuperListener<T>> {
MergeRx? _rx;
late T _listen;
late BuildContext _context;
@override
void dispose() {
_rx?.removeListener(_handleChange);
super.dispose();
}
void _handleChange() {
_listen = widget.listen();
if (widget.listenWhen != null && !widget.listenWhen!(_listen)) return;
widget.listener(_context);
}
@override
Widget build(BuildContext context) {
_context = context;
_rx?.removeListener(_handleChange);
RxListener.listen();
_listen = widget.listen();
_rx = RxListener.listenedRx();
_rx?.addListener(_handleChange);
if (widget.child != null) {
return widget.child!;
} else {
return const SizedBox.shrink();
}
}
}
|
flutter_super/lib/src/widgets/super_listener.dart/0
|
{'file_path': 'flutter_super/lib/src/widgets/super_listener.dart', 'repo_id': 'flutter_super', 'token_count': 1051}
|
import 'package:flutter_super/flutter_super.dart';
import 'package:flutter_test/flutter_test.dart';
class User {}
void main() {
group('RxTExt', () {
test('RxTExt - T', () {
final value = User();
final rxValue = value.rx;
expect(rxValue.value, equals(value));
});
test('RxTExt - String', () {
const value = 'Hello';
final rxValue = value.rx;
expect(rxValue.value, equals(value));
});
test('RxTExt - Int', () {
const value = 6;
final rxValue = value.rx;
expect(rxValue.value, equals(value));
});
test('RxTExt - Double', () {
const value = 3.14;
final rxValue = value.rx;
expect(rxValue.value, equals(value));
});
test('RxTExt - Bool', () {
const value = true;
final rxValue = value.rx;
expect(rxValue.value, equals(value));
});
});
group('RxSetExt', () {
test('RxSetExt', () {
final set = {1, 2, 3};
final rxSet = set.rx;
expect(rxSet, equals(set));
});
});
group('RxMapExt', () {
test('RxMapExt', () {
final map = {1: 'One', 2: 'Two', 3: 'Three'};
final rxMap = map.rx;
expect(rxMap, equals(map));
});
});
group('RxListExt', () {
test('RxListExt', () {
final list = [1, 2, 3];
final rxList = list.rx;
expect(rxList, equals(list));
});
});
}
|
flutter_super/test/src/utilities/rx_test.dart/0
|
{'file_path': 'flutter_super/test/src/utilities/rx_test.dart', 'repo_id': 'flutter_super', 'token_count': 626}
|
import 'package:flutter/material.dart';
enum SwiperControllerEvent {
PREV_INDEX,
NEXT_INDEX,
MOVE_INDEX,
START_AUTOPLAY,
STOP_AUTOPLAY
}
class SwiperController extends ChangeNotifier {
int index;
bool animation;
bool autoplay;
SwiperControllerEvent _event;
SwiperControllerEvent get event => _event;
SwiperController();
///move to index
void move(int index, {bool animation: true}) {
_event = SwiperControllerEvent.MOVE_INDEX;
this.index = index;
this.animation = animation;
notifyListeners();
}
/// goto next index
void next({bool animation: true}) {
_event = SwiperControllerEvent.NEXT_INDEX;
this.animation = animation;
notifyListeners();
}
/// goto previous index
void previous({bool animation: true}) {
_event = SwiperControllerEvent.PREV_INDEX;
this.animation = animation;
notifyListeners();
}
void startAutoplay() {
_event = SwiperControllerEvent.START_AUTOPLAY;
this.autoplay = true;
notifyListeners();
}
void stopAutoplay() {
_event = SwiperControllerEvent.STOP_AUTOPLAY;
this.autoplay = false;
notifyListeners();
}
}
|
flutter_swiper/lib/src/swiper_controller.dart/0
|
{'file_path': 'flutter_swiper/lib/src/swiper_controller.dart', 'repo_id': 'flutter_swiper', 'token_count': 408}
|
name: text_view
description: A new text_view plugin.
version: 0.0.1
author:
homepage:
environment:
sdk: ">=2.0.0-dev.68.0 <3.0.0"
dependencies:
flutter:
sdk: flutter
# For information on the generic Dart part of this file, see the
# following page: https://www.dartlang.org/tools/pub/pubspec
# The following section is specific to Flutter.
flutter:
plugin:
androidPackage: angelov.felix.textview
pluginClass: TextViewPlugin
# To add assets to your plugin package, add an assets section, like this:
# assets:
# - images/a_dot_burr.jpeg
# - images/a_dot_ham.jpeg
#
# For details regarding assets in packages, see
# https://flutter.io/assets-and-images/#from-packages
#
# An image asset can refer to one or more resolution-specific "variants", see
# https://flutter.io/assets-and-images/#resolution-aware.
# To add custom fonts to your plugin package, add a fonts section here,
# in this "flutter" section. Each entry in this list should have a
# "family" key with the font family name, and a "fonts" key with a
# list giving the asset and other descriptors for the font. For
# example:
# fonts:
# - family: Schyler
# fonts:
# - asset: fonts/Schyler-Regular.ttf
# - asset: fonts/Schyler-Italic.ttf
# style: italic
# - family: Trajan Pro
# fonts:
# - asset: fonts/TrajanPro.ttf
# - asset: fonts/TrajanPro_Bold.ttf
# weight: 700
#
# For details regarding fonts in packages, see
# https://flutter.io/custom-fonts/#from-packages
|
flutter_text_view_plugin/pubspec.yaml/0
|
{'file_path': 'flutter_text_view_plugin/pubspec.yaml', 'repo_id': 'flutter_text_view_plugin', 'token_count': 569}
|
part of 'bloc.dart';
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
class _CompleteChanged extends TodoEvent {
final bool complete;
const _CompleteChanged(this.complete);
@override
List<Object> get props => [complete];
@override
String toString() => 'CompleteChanged { completed: $complete }';
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
mixin CompleteChanged on _TodoBloc {
@override
Stream<TodoState> mapEventToState(TodoEvent event) async* {
if (event is _CompleteChanged && state is TodoLoadSuccess) {
yield TodoLoadSuccess(
(state as TodoLoadSuccess).todo.copyWith(complete: event.complete),
dirty: true,
);
} else {
yield* super.mapEventToState(event);
}
}
void todoToggled(bool complete) => add(_CompleteChanged(complete));
}
|
flutter_todos/lib/blocs/todo/event_completed_changed.dart/0
|
{'file_path': 'flutter_todos/lib/blocs/todo/event_completed_changed.dart', 'repo_id': 'flutter_todos', 'token_count': 333}
|
blank_issues_enabled: false
|
flutterfire_cli/.github/ISSUE_TEMPLATE/config.yml/0
|
{'file_path': 'flutterfire_cli/.github/ISSUE_TEMPLATE/config.yml', 'repo_id': 'flutterfire_cli', 'token_count': 8}
|
import '../packages/flutterfire_cli/bin/flutterfire.dart' as flutterfire;
// This allows us to use FlutterFire CLI during development.
void main(List<String> arguments) {
if (arguments.contains('--help')) {
// ignore_for_file: avoid_print
print('------------------------------------------------------------------');
print(
'| You are running a local development version of FlutterFire CLI. |',
);
print('------------------------------------------------------------------');
print('');
}
flutterfire.main(arguments);
}
|
flutterfire_cli/bin/flutterfire_dev.dart/0
|
{'file_path': 'flutterfire_cli/bin/flutterfire_dev.dart', 'repo_id': 'flutterfire_cli', 'token_count': 157}
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:bloc_concurrency/bloc_concurrency.dart';
import 'package:equatable/equatable.dart';
import 'package:fluttersaurus/search/models/suggestion.dart';
import 'package:fluttersaurus/search/search.dart';
import 'package:stream_transform/stream_transform.dart';
import 'package:thesaurus_repository/thesaurus_repository.dart';
part 'search_event.dart';
part 'search_state.dart';
EventTransformer<E> _restartableDebounce<E>() {
return (events, mapper) {
return restartable<E>()(
events.debounce(const Duration(milliseconds: 350)),
mapper,
);
};
}
class SearchBloc extends Bloc<SearchEvent, SearchState> {
SearchBloc(this._thesaurusRepository) : super(const SearchState.initial()) {
on<SearchTermChanged>(
_onSearchTermChanged,
transformer: _restartableDebounce(),
);
}
final ThesaurusRepository _thesaurusRepository;
Future<void> _onSearchTermChanged(
SearchTermChanged event,
Emitter<SearchState> emit,
) async {
if (event.term.isEmpty) return emit(const SearchState.initial());
if (state.status != SearchStatus.success) emit(const SearchState.loading());
try {
final results = await _thesaurusRepository.search(term: event.term);
final suggestions = results.map(Suggestion.new).toList();
emit(SearchState.success(suggestions));
} catch (_) {
emit(const SearchState.failure());
}
}
}
|
fluttersaurus/lib/search/bloc/search_bloc.dart/0
|
{'file_path': 'fluttersaurus/lib/search/bloc/search_bloc.dart', 'repo_id': 'fluttersaurus', 'token_count': 520}
|
export 'cubit/synonyms_cubit.dart';
export 'models/models.dart';
export 'view/view.dart';
|
fluttersaurus/lib/synonyms/synonyms.dart/0
|
{'file_path': 'fluttersaurus/lib/synonyms/synonyms.dart', 'repo_id': 'fluttersaurus', 'token_count': 37}
|
import 'package:json_annotation/json_annotation.dart';
part 'word.g.dart';
/// {@template word}
/// Word returned by the Datamuse API.
/// Each [Word] contains the [word] itself as well as a [score].
/// {@endtemplate}
@JsonSerializable(createToJson: false)
class Word {
/// {@macro word}
const Word(this.word, this.score, [this.tags = const <Tag>[]]);
/// Converts a [Map<String, dynamic>] into a [Word] instance.
factory Word.fromJson(Map<String, dynamic> json) => _$WordFromJson(json);
/// The word itself.
final String word;
/// The score -- higher means closer match.
final int score;
/// One or more part-of-speech codes.
@JsonKey(defaultValue: <Tag>[], unknownEnumValue: Tag.unknown)
final List<Tag> tags;
}
/// Part-of-speech codes which are associated with words.
enum Tag {
/// Synonym
@JsonValue('syn')
synonym,
/// Noun
@JsonValue('n')
noun,
/// Verb
@JsonValue('v')
verb,
/// Adjective
@JsonValue('adj')
adjective,
/// Adverb
@JsonValue('adv')
adverb,
/// Proper Noun
@JsonValue('prop')
properNoun,
/// Antonym
@JsonValue('ant')
antonym,
/// Unknown
@JsonValue('u')
unknown,
}
|
fluttersaurus/packages/datamuse_api/lib/src/models/word.dart/0
|
{'file_path': 'fluttersaurus/packages/datamuse_api/lib/src/models/word.dart', 'repo_id': 'fluttersaurus', 'token_count': 420}
|
import 'dart:async';
import 'dart:html' hide Body;
import 'package:forge2d/forge2d_browser.dart' hide Timer;
/// An abstract class for any Demo of the Forge2D library.
abstract class Demo {
/// All of the bodies in a simulation.
List<Body> bodies = <Body>[];
/// The default canvas width and height.
static const int canvasWidth = 900;
static const int canvasHeight = 600;
/// Scale of the viewport.
static const double viewportScale = 10.0;
/// The gravity vector's y value.
static const double _gravity = -10.0;
/// The timestep and iteration numbers.
static const double timeStep = 1 / 60;
/// The physics world.
final World world;
// For timing the world.step call. It is kept running but reset and polled
// every frame to minimize overhead.
final Stopwatch _stopwatch;
final double _viewportScale;
/// The drawing canvas.
late final CanvasElement canvas;
/// The canvas rendering context.
late final CanvasRenderingContext2D ctx;
/// The transform abstraction layer between the world and drawing canvas.
late final ViewportTransform viewport;
/// The debug drawing tool.
late final DebugDraw debugDraw;
/// Frame count for fps
int frameCount = 0;
/// HTML element used to display the FPS counter
late final Element fpsCounter;
/// Microseconds for world step update
int? elapsedUs;
/// HTML element used to display the world step time
late final Element worldStepTime;
Demo(String name, [Vector2? gravity, this._viewportScale = viewportScale])
: world = World(gravity ?? Vector2(0.0, _gravity)),
_stopwatch = Stopwatch()..start() {
world.setAllowSleep(true);
querySelector('#title')?.innerHtml = name;
}
/// Advances the world forward by timestep seconds.
void step(num timestamp) {
_stopwatch.reset();
world.stepDt(timeStep);
elapsedUs = _stopwatch.elapsedMicroseconds;
// Clear the animation panel and draw new frame.
ctx.clearRect(0, 0, canvasWidth, canvasHeight);
world.drawDebugData();
frameCount++;
window.requestAnimationFrame(step);
}
/// Creates the canvas and readies the demo for animation. Must be called
/// before calling runAnimation.
void initializeAnimation() {
// Setup the canvas.
canvas = (Element.tag('canvas') as CanvasElement)
..width = canvasWidth
..height = canvasHeight;
document.body?.nodes.add(canvas);
ctx = canvas.context2D;
// Create the viewport transform with the center at extents.
final extents = Vector2(canvasWidth / 2, canvasHeight / 2);
viewport = CanvasViewportTransform(extents, extents)
..scale = _viewportScale;
// Create our canvas drawing tool to give to the world.
debugDraw = CanvasDraw(viewport, ctx);
// Have the world draw itself for debugging purposes.
world.debugDraw = debugDraw;
fpsCounter = querySelector('#fps-counter')!;
worldStepTime = querySelector('#world-step-time')!;
Timer.periodic(const Duration(seconds: 1), (Timer t) {
fpsCounter.innerHtml = frameCount.toString();
frameCount = 0;
});
Timer.periodic(const Duration(milliseconds: 200), (Timer t) {
if (elapsedUs == null) {
return;
}
worldStepTime.innerHtml = '${elapsedUs! / 1000} ms';
});
}
void initialize();
/// Starts running the demo as an animation using an animation scheduler.
void runAnimation() {
window.requestAnimationFrame(step);
}
}
|
forge2d/packages/forge2d/example/web/demo.dart/0
|
{'file_path': 'forge2d/packages/forge2d/example/web/demo.dart', 'repo_id': 'forge2d', 'token_count': 1098}
|
import 'package:forge2d/forge2d.dart';
/// Implement this class to get contact information. You can use these results
/// for things like sounds and game logic. You can also get contact results by
/// traversing the contact lists after the time step. However, you might miss
/// some contacts because continuous physics leads to sub-stepping.
/// Additionally you may receive multiple callbacks for the same contact in a
/// single time step.
/// You should strive to make your callbacks efficient because there may be
/// many callbacks per time step.
/// Warning: You cannot create/destroy Forge2D entities inside these callbacks.
abstract class ContactListener {
/// Called when two fixtures begin to touch.
void beginContact(Contact contact) {}
/// Called when two fixtures cease to touch.
void endContact(Contact contact) {}
/// This is called after a contact is updated. This allows you to inspect a
/// contact before it goes to the solver. If you are careful, you can modify
/// the contact manifold (e.g. disable contact).
/// A copy of the old manifold is provided so that you can detect changes.
/// Note: this is called only for awake bodies.
/// Note: this is called even when the number of contact points is zero.
/// Note: this is not called for sensors.
/// Note: if you set the number of contact points to zero, you will not
/// get an EndContact callback. However, you may get a BeginContact callback
/// the next step.
/// Note: the oldManifold parameter is pooled, so it will be the same object
/// for every callback for each thread.
void preSolve(Contact contact, Manifold oldManifold) {}
/// This lets you inspect a contact after the solver is finished. This is
/// useful for inspecting impulses.
/// Note: the contact manifold does not include time of impact impulses, which
/// can be arbitrarily large if the sub-step is small. Hence the impulse is
/// provided explicitly in a separate data structure.
/// Note: this is only called for contacts that are touching, solid, and
/// awake.
/// [impulse] this is usually a pooled variable, so it will be modified after
/// this call
void postSolve(Contact contact, ContactImpulse impulse) {}
}
|
forge2d/packages/forge2d/lib/src/callbacks/contact_listener.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/callbacks/contact_listener.dart', 'repo_id': 'forge2d', 'token_count': 538}
|
import 'package:forge2d/forge2d.dart';
class DynamicTreeNode {
final int id;
DynamicTreeNode(this.id);
/// Enlarged AABB
final AABB aabb = AABB();
Object? userData;
DynamicTreeNode? parent;
DynamicTreeNode? child1;
DynamicTreeNode? child2;
int height = 0;
}
|
forge2d/packages/forge2d/lib/src/collision/broadphase/dynamic_tree_node.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/collision/broadphase/dynamic_tree_node.dart', 'repo_id': 'forge2d', 'token_count': 103}
|
import 'package:forge2d/forge2d.dart';
/// A shape is used for collision detection. You can create a shape however you
/// like. Shapes used for simulation in World are created automatically when a
/// [Fixture] is created. Shapes may encapsulate a one or more child shapes.
abstract class Shape {
final ShapeType shapeType;
double radius = 0.0;
Shape(this.shapeType);
/// Get the number of child primitives
int get childCount;
/// Test a point for containment in this shape. This only works for convex
/// shapes.
///
/// [xf] should be the shape world transform.
/// [point] should be in world coordinates.
bool testPoint(Transform xf, Vector2 point);
/// Cast a ray against a child shape.
///
/// [output] is the ray-cast results.
/// [input] the ray-cast input parameters.
/// [transform] to be applied to the shape.
/// [childIndex] the child shape index
/// Returns true if the child shape is hit.
bool raycast(
RayCastOutput output,
RayCastInput input,
Transform transform,
int childIndex,
);
/// Given a transform, compute the associated axis aligned bounding box for a
/// child shape.
void computeAABB(AABB aabb, Transform xf, int childIndex);
/// Compute the mass properties of this shape using its dimensions and
/// density. The inertia tensor is computed about the local origin.
/// [density] should be in kilograms per meter squared.
void computeMass(MassData massData, double density);
/// Compute the distance from the current shape to the specified point.
/// This only works for convex shapes.
///
/// [xf] is the shape world transform.
/// [p] is a point in world coordinates.
/// [normalOut] returns the direction in which the distance increases.
/// Returns the distance from the current shape.
double computeDistanceToOut(
Transform xf,
Vector2 p,
int childIndex,
Vector2 normalOut,
);
Shape clone();
}
|
forge2d/packages/forge2d/lib/src/collision/shapes/shape.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/collision/shapes/shape.dart', 'repo_id': 'forge2d', 'token_count': 538}
|
import 'package:forge2d/forge2d.dart';
/// Delegate of World.
class ContactManager implements PairCallback {
BroadPhase broadPhase;
final List<Contact> contacts = [];
ContactFilter? contactFilter;
ContactListener? contactListener;
ContactManager(this.broadPhase) {
contactFilter = ContactFilter();
}
/// Broad-phase callback.
@override
void addPair(FixtureProxy proxyUserDataA, FixtureProxy proxyUserDataB) {
final proxyA = proxyUserDataA;
final proxyB = proxyUserDataB;
final fixtureA = proxyA.fixture;
final fixtureB = proxyB.fixture;
final indexA = proxyA.childIndex;
final indexB = proxyB.childIndex;
final bodyA = fixtureA.body;
final bodyB = fixtureB.body;
// Are the fixtures on the same body?
if (bodyA == bodyB) {
return;
}
// Check whether a contact already exists
for (final contact in bodyB.contacts) {
if (contact.containsBody(bodyA)) {
if (contact.representsArguments(fixtureA, indexA, fixtureB, indexB)) {
// A contact already exists.
return;
}
}
}
// Does a joint override collision? is at least one body dynamic?
if (!bodyB.shouldCollide(bodyA)) {
return;
}
// Check user filtering.
if (contactFilter?.shouldCollide(fixtureA, fixtureB) == false) {
return;
}
final contact = Contact.init(fixtureA, indexA, fixtureB, indexB);
// Insert into the world.
contacts.add(contact);
// Connect to island graph.
// Connect to ths bodies
bodyA.contacts.add(contact);
bodyB.contacts.add(contact);
// Wake up the bodies
if (!fixtureA.isSensor && !fixtureB.isSensor) {
bodyA.setAwake(true);
bodyB.setAwake(true);
}
}
void findNewContacts() {
broadPhase.updatePairs(this);
}
void destroy(Contact c) {
final fixtureA = c.fixtureA;
final fixtureB = c.fixtureB;
if (c.isTouching()) {
contactListener?.endContact(c);
}
contacts.remove(c);
c.bodyA.contacts.remove(c);
c.bodyB.contacts.remove(c);
if (c.manifold.pointCount > 0 && !fixtureA.isSensor && !fixtureB.isSensor) {
fixtureA.body.setAwake(true);
fixtureB.body.setAwake(true);
}
}
/// This is the top level collision call for the time step. Here all the
/// narrow phase collision is processed for the world contact list.
void collide() {
final contactRemovals = <Contact>[];
// Update awake contacts.
for (final c in contacts) {
final fixtureA = c.fixtureA;
final fixtureB = c.fixtureB;
final indexA = c.indexA;
final indexB = c.indexB;
final bodyA = fixtureA.body;
final bodyB = fixtureB.body;
// is this contact flagged for filtering?
if ((c.flags & Contact.filterFlag) == Contact.filterFlag) {
// Should these bodies collide?
if (!bodyB.shouldCollide(bodyA)) {
contactRemovals.add(c);
continue;
}
// Check user filtering.
if (contactFilter?.shouldCollide(fixtureA, fixtureB) == false) {
contactRemovals.add(c);
continue;
}
// Clear the filtering flag.
c.flags &= ~Contact.filterFlag;
}
final activeA = bodyA.isAwake && bodyA.bodyType != BodyType.static;
final activeB = bodyB.isAwake && bodyB.bodyType != BodyType.static;
// At least one body must be awake and it must be dynamic or kinematic.
if (activeA == false && activeB == false) {
continue;
}
final proxyIdA = fixtureA.proxies[indexA].proxyId;
final proxyIdB = fixtureB.proxies[indexB].proxyId;
// Here we destroy contacts that cease to overlap in the broad-phase.
if (!broadPhase.testOverlap(proxyIdA, proxyIdB)) {
contactRemovals.add(c);
continue;
}
// The contact persists.
c.update(contactListener);
}
contactRemovals.forEach(destroy);
}
}
|
forge2d/packages/forge2d/lib/src/dynamics/contact_manager.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/dynamics/contact_manager.dart', 'repo_id': 'forge2d', 'token_count': 1558}
|
import 'package:forge2d/forge2d.dart';
/// Used to create a [Fixture].
///
/// You can reuse fixture definitions safely.
class FixtureDef {
FixtureDef(
this.shape, {
this.userData,
this.friction = 0,
this.restitution = 0,
this.density = 1,
this.isSensor = false,
Filter? filter,
}) : filter = filter ?? Filter();
/// The [Shape], this must be set.
///
/// The [Shape] will be [Shape.clone]d, so you can create the shape on the
/// stack.
Shape shape;
/// Use this to store application specific fixture data.
Object? userData;
/// The friction coefficient, usually in the range [0,1].
double friction;
/// The restitution (elasticity) usually in the range [0,1].
double restitution;
/// The density, usually in kg/m^2.
double density;
/// A sensor shape collects contact information but never generates a
/// collision response.
bool isSensor;
/// Contact filtering data.
Filter filter;
}
|
forge2d/packages/forge2d/lib/src/dynamics/fixture_def.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/dynamics/fixture_def.dart', 'repo_id': 'forge2d', 'token_count': 300}
|
import 'package:forge2d/forge2d.dart';
/// Motor joint definition.
class MotorJointDef<A extends Body, B extends Body> extends JointDef<A, B> {
/// Position of bodyB minus the position of bodyA, in bodyA's frame, in
/// meters.
final Vector2 linearOffset = Vector2.zero();
/// The bodyB angle minus bodyA angle in radians.
double angularOffset = 0.0;
/// The maximum motor force in N.
double maxForce = 1.0;
/// The maximum motor torque in N-m.
double maxTorque = 1.0;
/// Position correction factor in the range [0,1].
double correctionFactor = 0.3;
void initialize(A bodyA, B bodyB) {
this.bodyA = bodyA;
this.bodyB = bodyB;
final xB = bodyB.position;
linearOffset.setFrom(bodyA.localPoint(xB));
final angleA = bodyA.angle;
final angleB = bodyB.angle;
angularOffset = angleB - angleA;
}
}
|
forge2d/packages/forge2d/lib/src/dynamics/joints/motor_joint_def.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/dynamics/joints/motor_joint_def.dart', 'repo_id': 'forge2d', 'token_count': 292}
|
import 'package:forge2d/forge2d.dart';
class SolverData {
late TimeStep step;
late List<Position> positions;
late List<Velocity> velocities;
}
|
forge2d/packages/forge2d/lib/src/dynamics/solver_data.dart/0
|
{'file_path': 'forge2d/packages/forge2d/lib/src/dynamics/solver_data.dart', 'repo_id': 'forge2d', 'token_count': 53}
|
import 'package:forge2d/forge2d.dart';
import 'package:test/test.dart';
void main() {
group('BodyDef', () {
test('can be instantiated', () {
expect(BodyDef(), isA<BodyDef>());
});
});
}
|
forge2d/packages/forge2d/test/dynamics/body_def_test.dart/0
|
{'file_path': 'forge2d/packages/forge2d/test/dynamics/body_def_test.dart', 'repo_id': 'forge2d', 'token_count': 84}
|
import 'package:forge2d/forge2d.dart';
import 'package:mocktail/mocktail.dart';
import 'package:test/test.dart';
import '../../helpers/helpers.dart';
void main() {
group('MouseJoint', () {
test('can be instantiated', () {
final world = World();
final jointDef = MouseJointDef()
..bodyA = Body(BodyDef(), world)
..bodyB = Body(BodyDef(), world);
expect(MouseJoint(jointDef), isA<MouseJoint>());
});
group('render', () {
late World world;
late DebugDraw debugDraw;
setUp(() {
world = World();
debugDraw = MockDebugDraw();
registerFallbackValue(Vector2.zero());
registerFallbackValue(Color3i.black());
});
test('does nothing', () {
final joint = MouseJoint(
MouseJointDef()
..bodyA = (Body(BodyDef(), world))
..bodyB = (Body(BodyDef(), world)),
);
joint.render(debugDraw);
verifyNever<void>(() => debugDraw.drawSegment(any(), any(), any()));
});
});
});
}
|
forge2d/packages/forge2d/test/dynamics/joints/mouse_joint_test.dart/0
|
{'file_path': 'forge2d/packages/forge2d/test/dynamics/joints/mouse_joint_test.dart', 'repo_id': 'forge2d', 'token_count': 456}
|
name: forge2d_workspace
environment:
sdk: ">=3.0.0 <4.0.0"
dev_dependencies:
melos: ^3.2.0
|
forge2d/pubspec.yaml/0
|
{'file_path': 'forge2d/pubspec.yaml', 'repo_id': 'forge2d', 'token_count': 51}
|
name: _internal
description: A new Flutter project.
publish_to: none
environment:
sdk: ">=2.14.0 <3.0.0"
dependencies:
freezed_annotation: ^2.4.1
dev_dependencies:
build_runner:
freezed: ^2.4.5
|
freezed/packages/_internal/pubspec.yaml/0
|
{'file_path': 'freezed/packages/_internal/pubspec.yaml', 'repo_id': 'freezed', 'token_count': 88}
|
name: example
description: A new Flutter project.
publish_to: none
environment:
sdk: ">=2.17.0 <3.0.0"
dependencies:
flutter:
sdk: flutter
freezed_annotation:
path: ../../freezed_annotation
json_annotation: ^4.6.0
dev_dependencies:
freezed:
path: ../
json_serializable: ^6.3.2
build_runner:
flutter_test:
sdk: flutter
dependency_overrides:
freezed:
path: ../
freezed_annotation:
path: ../../freezed_annotation
|
freezed/packages/freezed/example/pubspec.yaml/0
|
{'file_path': 'freezed/packages/freezed/example/pubspec.yaml', 'repo_id': 'freezed', 'token_count': 197}
|
import 'package:analyzer/dart/element/element.dart';
extension LibraryHasImport on LibraryElement {
LibraryElement? findTransitiveExportWhere(
bool Function(LibraryElement library) visitor,
) {
if (visitor(this)) return this;
final visitedLibraries = <LibraryElement>{};
LibraryElement? visitLibrary(LibraryElement library) {
if (!visitedLibraries.add(library)) return null;
if (visitor(library)) return library;
for (final export in library.exportedLibraries) {
final result = visitLibrary(export);
if (result != null) return result;
}
return null;
}
for (final import in exportedLibraries) {
final result = visitLibrary(import);
if (result != null) return result;
}
return null;
}
bool anyTransitiveExport(
bool Function(LibraryElement library) visitor,
) {
return findTransitiveExportWhere(visitor) != null;
}
}
|
freezed/packages/freezed/lib/src/tools/imports.dart/0
|
{'file_path': 'freezed/packages/freezed/lib/src/tools/imports.dart', 'repo_id': 'freezed', 'token_count': 315}
|
export 'package:freezed_annotation/freezed_annotation.dart';
|
freezed/packages/freezed/test/integration/export_freezed_annotation.dart/0
|
{'file_path': 'freezed/packages/freezed/test/integration/export_freezed_annotation.dart', 'repo_id': 'freezed', 'token_count': 20}
|
import 'package:freezed_annotation/freezed_annotation.dart';
import './slow_2.dart';
import 'slow_3.dart';
part 'slow_1.freezed.dart';
@freezed
class Root with _$Root {
const factory Root.a(A a) = _A;
const factory Root.b(B b) = _B;
const factory Root.c(A a) = _C;
const factory Root.d(B b) = _D;
const factory Root.e(A a) = _E;
const factory Root.f(A a) = _F;
const factory Root.g(B b) = _G;
const factory Root.h(A a) = _H;
const factory Root.i(B b) = _I;
const factory Root.j(A a) = _J;
const factory Root.k(B b) = _K;
const factory Root.l(A a) = _L;
const factory Root.m(B b) = _M;
}
|
freezed/packages/freezed/test/integration/slow_1.dart/0
|
{'file_path': 'freezed/packages/freezed/test/integration/slow_1.dart', 'repo_id': 'freezed', 'token_count': 266}
|
import 'package:analyzer/dart/analysis/results.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:build_test/build_test.dart';
import 'package:test/test.dart';
void main() {
test('has no issue', () async {
final main = await resolveSources(
{
'freezed|test/integration/typedef_parameter.dart': useAssetReader,
},
(r) => r.libraries.firstWhere(
(element) => element.source.toString().contains('typedef_parameter')),
);
final errorResult = await main.session.getErrors(
'/freezed/test/integration/typedef_parameter_test.freezed.dart')
as ErrorsResult;
expect(errorResult.errors, isEmpty);
});
test('generates correct typedefs', () async {
final main = await resolveSources(
{
'freezed|test/integration/typedef_parameter.dart': useAssetReader,
},
(r) => r.libraries.firstWhere(
(element) => element.source.toString().contains('typedef_parameter')),
);
var freezedClass = main.topLevelElements
.whereType<ClassElement>()
.firstWhere((element) => element.name == '_ClassWithTypedef');
var constructor =
freezedClass.constructors.firstWhere((element) => element.name == '');
var a = constructor.parameters.first.type;
expect(a, isA<FunctionType>());
expect(a.alias!.element.name, equals('MyTypedef'));
var b = constructor.parameters[1].type;
expect(b, isA<FunctionType>());
expect(b.alias!.element.name, equals('MyTypedef'));
expect(b.nullabilitySuffix, equals(NullabilitySuffix.question));
var c = constructor.parameters[2].type;
expect(c, isA<FunctionType>());
expect(c.alias!.element.name, equals('ExternalTypedef'));
var d = constructor.parameters[3].type;
expect(d, isA<FunctionType>());
expect(d.alias!.element.name, equals('ExternalTypedefTwo'));
var e = constructor.parameters[4].type;
expect(e, isA<FunctionType>());
expect(e.alias!.element.name, equals('GenericTypedef'));
expect(e.alias!.typeArguments.toString(), equals('[int, bool]'));
});
}
|
freezed/packages/freezed/test/typedef_parameter_test.dart/0
|
{'file_path': 'freezed/packages/freezed/test/typedef_parameter_test.dart', 'repo_id': 'freezed', 'token_count': 852}
|
import 'package:build_verify/build_verify.dart';
import 'package:test/test.dart';
void main() {
test('ensure_build', () {
expectBuildClean(
packageRelativeDirectory: 'packages/freezed_lint',
);
});
}
|
freezed/packages/freezed_lint/test/ensure_build_test.dart/0
|
{'file_path': 'freezed/packages/freezed_lint/test/ensure_build_test.dart', 'repo_id': 'freezed', 'token_count': 85}
|
part of 'authentication_bloc.dart';
abstract class AuthenticationState extends Equatable {
@override
List<Object> get props => [];
@override
bool get stringify => true;
}
class AuthenticationUnknown extends AuthenticationState {}
class AuthenticationAuthenticated extends AuthenticationState {}
class AuthenticationUnauthenticated extends AuthenticationState {}
|
fresh/packages/fresh_dio/example/lib/authentication/bloc/authentication_state.dart/0
|
{'file_path': 'fresh/packages/fresh_dio/example/lib/authentication/bloc/authentication_state.dart', 'repo_id': 'fresh', 'token_count': 85}
|
import 'package:json_annotation/json_annotation.dart';
part 'photos_response.g.dart';
@JsonSerializable(createToJson: false)
class Photo {
const Photo(this.albumId, this.id, this.title, this.url, this.thumbnailUrl);
factory Photo.fromJson(Map<String, dynamic> json) => _$PhotoFromJson(json);
final int albumId;
final int id;
final String title;
final String url;
final String thumbnailUrl;
}
|
fresh/packages/fresh_dio/example/packages/jsonplaceholder_client/lib/src/models/photos_response.dart/0
|
{'file_path': 'fresh/packages/fresh_dio/example/packages/jsonplaceholder_client/lib/src/models/photos_response.dart', 'repo_id': 'fresh', 'token_count': 139}
|
export 'package:fresh/fresh.dart'
show
AuthenticationStatus,
InMemoryTokenStorage,
OAuth2Token,
RevokeTokenException,
TokenHeaderBuilder,
TokenStorage;
export 'src/fresh_link.dart';
|
fresh/packages/fresh_graphql/lib/fresh_graphql.dart/0
|
{'file_path': 'fresh/packages/fresh_graphql/lib/fresh_graphql.dart', 'repo_id': 'fresh', 'token_count': 102}
|
targets:
$default:
builders:
functional_widget:
enabled: true
generate_for:
include:
- example/lib/*
builders:
functional_widget:
import: 'package:functional_widget/builder.dart'
builder_factories: ['functionalWidget']
build_extensions: { '.dart': ['.functional_widget.g.part'] }
auto_apply: dependents
build_to: cache
applies_builders: ['source_gen|combining_builder']
|
functional_widget/packages/functional_widget/build.yaml/0
|
{'file_path': 'functional_widget/packages/functional_widget/build.yaml', 'repo_id': 'functional_widget', 'token_count': 256}
|
// ignore_for_file: unused_field
import 'package:functional_widget_annotation/functional_widget_annotation.dart';
import 'fake_flutter.dart';
@swidget
Widget intTest(int a) => Container();
@swidget
Widget doubleTest(double a) => Container();
@swidget
Widget stringTest(String a) => Container();
enum _Foo { a, b }
@swidget
Widget enumTest(_Foo a) => Container();
@swidget
Widget objectTest(Object a) => Container();
typedef Typedef<T> = void Function(T);
@swidget
Widget typedefTest<T>(Typedef a) => Container();
@swidget
Widget functionTest(void Function() a) => Container();
@swidget
Widget dynamicTest(dynamic a) => Container();
|
functional_widget/packages/functional_widget/test/src/diagnostics.dart/0
|
{'file_path': 'functional_widget/packages/functional_widget/test/src/diagnostics.dart', 'repo_id': 'functional_widget', 'token_count': 209}
|
name: Tests
on:
push:
branches:
- main
pull_request:
# Declare default permissions as read only.
permissions: read-all
jobs:
unit-test:
name: Unit tests on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
steps:
# Set up Flutter.
- name: Clone Flutter repository with master channel
uses: subosito/flutter-action@2783a3f08e1baf891508463f8c6653c258246225
with:
channel: master
- run: flutter doctor -v
# Checkout gallery code and get packages.
- name: Checkout gallery code
uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- run: flutter pub get
# Analyze, check formatting, and run unit tests.
- run: flutter analyze
- name: Ensure the Dart code is formatted correctly
run: dart format --set-exit-if-changed .
- name: Run Flutter unit tests
run: flutter test
benchmark-test:
name: Benchmark tests
runs-on: ubuntu-latest
steps:
# Set up Flutter.
- name: Clone Flutter repository with master channel
uses: subosito/flutter-action@2783a3f08e1baf891508463f8c6653c258246225
with:
channel: master
- run: flutter doctor -v
# Checkout gallery code and get packages.
- name: Checkout gallery code
uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- run: flutter pub get
- run: flutter test test_benchmarks
golden-test:
name: Golden tests
runs-on: macos-latest
steps:
# Set up Flutter.
- name: Clone Flutter repository with master channel
uses: subosito/flutter-action@2783a3f08e1baf891508463f8c6653c258246225
with:
channel: master
- run: flutter doctor -v
# Checkout gallery code and get packages.
- name: Checkout gallery code
uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- run: flutter pub get
# Run the golden tests and upload failed test artifacts.
- run: flutter test test_goldens
- name: Upload goldens if tests fail
uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392
if: failure()
with:
name: goldens
path: test_goldens/failures/
|
gallery/.github/workflows/test.yml/0
|
{'file_path': 'gallery/.github/workflows/test.yml', 'repo_id': 'gallery', 'token_count': 1025}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter/cupertino.dart';
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
// BEGIN cupertinoTextFieldDemo
class CupertinoTextFieldDemo extends StatelessWidget {
const CupertinoTextFieldDemo({super.key});
@override
Widget build(BuildContext context) {
final localizations = GalleryLocalizations.of(context)!;
return CupertinoPageScaffold(
navigationBar: CupertinoNavigationBar(
automaticallyImplyLeading: false,
middle: Text(localizations.demoCupertinoTextFieldTitle),
),
child: SafeArea(
child: ListView(
restorationId: 'text_field_demo_list_view',
padding: const EdgeInsets.all(16),
children: [
Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: CupertinoTextField(
textInputAction: TextInputAction.next,
restorationId: 'email_address_text_field',
placeholder: localizations.demoTextFieldEmail,
keyboardType: TextInputType.emailAddress,
clearButtonMode: OverlayVisibilityMode.editing,
autocorrect: false,
),
),
Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: CupertinoTextField(
textInputAction: TextInputAction.next,
restorationId: 'login_password_text_field',
placeholder: localizations.rallyLoginPassword,
clearButtonMode: OverlayVisibilityMode.editing,
obscureText: true,
autocorrect: false,
),
),
// Disabled text field
Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: CupertinoTextField(
enabled: false,
textInputAction: TextInputAction.next,
restorationId: 'login_password_text_field_disabled',
placeholder: localizations.rallyLoginPassword,
clearButtonMode: OverlayVisibilityMode.editing,
obscureText: true,
autocorrect: false,
),
),
CupertinoTextField(
textInputAction: TextInputAction.done,
restorationId: 'pin_number_text_field',
prefix: const Icon(
CupertinoIcons.padlock_solid,
size: 28,
),
padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 12),
clearButtonMode: OverlayVisibilityMode.editing,
keyboardType: TextInputType.number,
decoration: const BoxDecoration(
border: Border(
bottom: BorderSide(
width: 0,
color: CupertinoColors.inactiveGray,
),
),
),
placeholder: localizations.demoCupertinoTextFieldPIN,
),
],
),
),
);
}
}
// END
|
gallery/lib/demos/cupertino/cupertino_text_field_demo.dart/0
|
{'file_path': 'gallery/lib/demos/cupertino/cupertino_text_field_demo.dart', 'repo_id': 'gallery', 'token_count': 1586}
|
export 'package:gallery/demos/material/app_bar_demo.dart';
export 'package:gallery/demos/material/banner_demo.dart';
export 'package:gallery/demos/material/bottom_app_bar_demo.dart';
export 'package:gallery/demos/material/bottom_navigation_demo.dart';
export 'package:gallery/demos/material/bottom_sheet_demo.dart';
export 'package:gallery/demos/material/button_demo.dart';
export 'package:gallery/demos/material/cards_demo.dart';
export 'package:gallery/demos/material/chip_demo.dart';
export 'package:gallery/demos/material/data_table_demo.dart';
export 'package:gallery/demos/material/dialog_demo.dart';
export 'package:gallery/demos/material/divider_demo.dart';
export 'package:gallery/demos/material/grid_list_demo.dart';
export 'package:gallery/demos/material/list_demo.dart';
export 'package:gallery/demos/material/menu_demo.dart';
export 'package:gallery/demos/material/navigation_drawer.dart';
export 'package:gallery/demos/material/navigation_rail_demo.dart';
export 'package:gallery/demos/material/picker_demo.dart';
export 'package:gallery/demos/material/progress_indicator_demo.dart';
export 'package:gallery/demos/material/selection_controls_demo.dart';
export 'package:gallery/demos/material/sliders_demo.dart';
export 'package:gallery/demos/material/snackbar_demo.dart';
export 'package:gallery/demos/material/tabs_demo.dart';
export 'package:gallery/demos/material/text_field_demo.dart';
export 'package:gallery/demos/material/tooltip_demo.dart';
|
gallery/lib/demos/material/material_demos.dart/0
|
{'file_path': 'gallery/lib/demos/material/material_demos.dart', 'repo_id': 'gallery', 'token_count': 516}
|
// Copyright 2019 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:animations/animations.dart';
import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
// BEGIN sharedXAxisTransitionDemo
class SharedXAxisTransitionDemo extends StatefulWidget {
const SharedXAxisTransitionDemo({super.key});
@override
State<SharedXAxisTransitionDemo> createState() =>
_SharedXAxisTransitionDemoState();
}
class _SharedXAxisTransitionDemoState extends State<SharedXAxisTransitionDemo> {
bool _isLoggedIn = false;
void _toggleLoginStatus() {
setState(() {
_isLoggedIn = !_isLoggedIn;
});
}
@override
Widget build(BuildContext context) {
final localizations = GalleryLocalizations.of(context)!;
return Scaffold(
resizeToAvoidBottomInset: false,
appBar: AppBar(
automaticallyImplyLeading: false,
title: Column(
children: [
Text(localizations.demoSharedXAxisTitle),
Text(
'(${localizations.demoSharedXAxisDemoInstructions})',
style: Theme.of(context)
.textTheme
.titleSmall!
.copyWith(color: Colors.white),
),
],
),
),
body: SafeArea(
child: Column(
children: [
Expanded(
child: PageTransitionSwitcher(
duration: const Duration(milliseconds: 300),
reverse: !_isLoggedIn,
transitionBuilder: (
child,
animation,
secondaryAnimation,
) {
return SharedAxisTransition(
animation: animation,
secondaryAnimation: secondaryAnimation,
transitionType: SharedAxisTransitionType.horizontal,
child: child,
);
},
child: _isLoggedIn ? const _CoursePage() : const _SignInPage(),
),
),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 15, vertical: 20),
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
TextButton(
onPressed: _isLoggedIn ? _toggleLoginStatus : null,
child: Text(localizations.demoSharedXAxisBackButtonText),
),
ElevatedButton(
onPressed: _isLoggedIn ? null : _toggleLoginStatus,
child: Text(localizations.demoSharedXAxisNextButtonText),
),
],
),
),
],
),
),
);
}
}
class _CoursePage extends StatelessWidget {
const _CoursePage();
@override
Widget build(BuildContext context) {
final localizations = GalleryLocalizations.of(context)!;
return ListView(
children: [
const SizedBox(height: 16),
Text(
localizations.demoSharedXAxisCoursePageTitle,
style: Theme.of(context).textTheme.headlineSmall,
textAlign: TextAlign.center,
),
const SizedBox(height: 10),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 10),
child: Text(
localizations.demoSharedXAxisCoursePageSubtitle,
style: const TextStyle(
fontSize: 12,
color: Colors.grey,
),
textAlign: TextAlign.center,
),
),
_CourseSwitch(
course: localizations.demoSharedXAxisArtsAndCraftsCourseTitle),
_CourseSwitch(course: localizations.demoSharedXAxisBusinessCourseTitle),
_CourseSwitch(
course: localizations.demoSharedXAxisIllustrationCourseTitle),
_CourseSwitch(course: localizations.demoSharedXAxisDesignCourseTitle),
_CourseSwitch(course: localizations.demoSharedXAxisCulinaryCourseTitle),
],
);
}
}
class _CourseSwitch extends StatefulWidget {
const _CourseSwitch({
this.course,
});
final String? course;
@override
_CourseSwitchState createState() => _CourseSwitchState();
}
class _CourseSwitchState extends State<_CourseSwitch> {
bool _isCourseBundled = true;
@override
Widget build(BuildContext context) {
final localizations = GalleryLocalizations.of(context);
final subtitle = _isCourseBundled
? localizations!.demoSharedXAxisBundledCourseSubtitle
: localizations!.demoSharedXAxisIndividualCourseSubtitle;
return SwitchListTile(
title: Text(widget.course!),
subtitle: Text(subtitle),
value: _isCourseBundled,
onChanged: (newValue) {
setState(() {
_isCourseBundled = newValue;
});
},
);
}
}
class _SignInPage extends StatelessWidget {
const _SignInPage();
@override
Widget build(BuildContext context) {
final localizations = GalleryLocalizations.of(context);
return LayoutBuilder(
builder: (context, constraints) {
final maxHeight = constraints.maxHeight;
const spacing = SizedBox(height: 10);
return Container(
constraints: const BoxConstraints(maxWidth: 400),
child: Column(
crossAxisAlignment: CrossAxisAlignment.center,
children: [
SizedBox(height: maxHeight / 10),
Image.asset(
'placeholders/avatar_logo.png',
package: 'flutter_gallery_assets',
width: 80,
height: 80,
),
spacing,
Text(
localizations!.demoSharedXAxisSignInWelcomeText,
style: Theme.of(context).textTheme.headlineSmall,
),
spacing,
Text(
localizations.demoSharedXAxisSignInSubtitleText,
style: const TextStyle(
fontSize: 12,
color: Colors.grey,
),
),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Padding(
padding: const EdgeInsetsDirectional.only(
top: 40,
start: 10,
end: 10,
bottom: 10,
),
child: TextField(
decoration: InputDecoration(
suffixIcon: const Icon(
Icons.visibility,
size: 20,
color: Colors.black54,
),
labelText:
localizations.demoSharedXAxisSignInTextFieldLabel,
border: const OutlineInputBorder(),
),
),
),
TextButton(
onPressed: () {},
child: Text(
localizations.demoSharedXAxisForgotEmailButtonText,
),
),
spacing,
TextButton(
onPressed: () {},
child: Text(
localizations.demoSharedXAxisCreateAccountButtonText,
),
),
],
),
],
),
);
},
);
}
}
// END sharedXAxisTransitionDemo
|
gallery/lib/demos/reference/motion_demo_shared_x_axis_transition.dart/0
|
{'file_path': 'gallery/lib/demos/reference/motion_demo_shared_x_axis_transition.dart', 'repo_id': 'gallery', 'token_count': 3989}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:collection';
import 'package:collection/collection.dart';
import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
import 'package:flutter_localized_locales/flutter_localized_locales.dart';
import 'package:gallery/constants.dart';
import 'package:gallery/data/gallery_options.dart';
import 'package:gallery/layout/adaptive.dart';
import 'package:gallery/pages/about.dart' as about;
import 'package:gallery/pages/home.dart';
import 'package:gallery/pages/settings_list_item.dart';
import 'package:url_launcher/url_launcher.dart';
enum _ExpandableSetting {
textScale,
textDirection,
locale,
platform,
theme,
}
class SettingsPage extends StatefulWidget {
const SettingsPage({
super.key,
required this.animationController,
});
final AnimationController animationController;
@override
State<SettingsPage> createState() => _SettingsPageState();
}
class _SettingsPageState extends State<SettingsPage> {
_ExpandableSetting? _expandedSettingId;
late Animation<double> _staggerSettingsItemsAnimation;
void onTapSetting(_ExpandableSetting settingId) {
setState(() {
if (_expandedSettingId == settingId) {
_expandedSettingId = null;
} else {
_expandedSettingId = settingId;
}
});
}
void _closeSettingId(AnimationStatus status) {
if (status == AnimationStatus.dismissed) {
setState(() {
_expandedSettingId = null;
});
}
}
@override
void initState() {
super.initState();
// When closing settings, also shrink expanded setting.
widget.animationController.addStatusListener(_closeSettingId);
_staggerSettingsItemsAnimation = CurvedAnimation(
parent: widget.animationController,
curve: const Interval(
0.4,
1.0,
curve: Curves.ease,
),
);
}
@override
void dispose() {
super.dispose();
widget.animationController.removeStatusListener(_closeSettingId);
}
/// Given a [Locale], returns a [DisplayOption] with its native name for a
/// title and its name in the currently selected locale for a subtitle. If the
/// native name can't be determined, it is omitted. If the locale can't be
/// determined, the locale code is used.
DisplayOption _getLocaleDisplayOption(BuildContext context, Locale? locale) {
final localeCode = locale.toString();
final localeName = LocaleNames.of(context)!.nameOf(localeCode);
if (localeName != null) {
final localeNativeName =
LocaleNamesLocalizationsDelegate.nativeLocaleNames[localeCode];
return localeNativeName != null
? DisplayOption(localeNativeName, subtitle: localeName)
: DisplayOption(localeName);
} else {
// gsw, fil, and es_419 aren't in flutter_localized_countries' dataset
// so we handle them separately
switch (localeCode) {
case 'gsw':
return DisplayOption('Schwiizertüütsch', subtitle: 'Swiss German');
case 'fil':
return DisplayOption('Filipino', subtitle: 'Filipino');
case 'es_419':
return DisplayOption(
'español (Latinoamérica)',
subtitle: 'Spanish (Latin America)',
);
}
}
return DisplayOption(localeCode);
}
/// Create a sorted — by native name – map of supported locales to their
/// intended display string, with a system option as the first element.
LinkedHashMap<Locale, DisplayOption> _getLocaleOptions() {
var localeOptions = LinkedHashMap.of({
systemLocaleOption: DisplayOption(
GalleryLocalizations.of(context)!.settingsSystemDefault +
(deviceLocale != null
? ' - ${_getLocaleDisplayOption(context, deviceLocale).title}'
: ''),
),
});
var supportedLocales =
List<Locale>.from(GalleryLocalizations.supportedLocales);
supportedLocales.removeWhere((locale) => locale == deviceLocale);
final displayLocales = Map<Locale, DisplayOption>.fromIterable(
supportedLocales,
value: (dynamic locale) =>
_getLocaleDisplayOption(context, locale as Locale?),
).entries.toList()
..sort((l1, l2) => compareAsciiUpperCase(l1.value.title, l2.value.title));
localeOptions.addAll(LinkedHashMap.fromEntries(displayLocales));
return localeOptions;
}
@override
Widget build(BuildContext context) {
final colorScheme = Theme.of(context).colorScheme;
final options = GalleryOptions.of(context);
final isDesktop = isDisplayDesktop(context);
final localizations = GalleryLocalizations.of(context)!;
final settingsListItems = [
SettingsListItem<double?>(
title: localizations.settingsTextScaling,
selectedOption: options.textScaleFactor(
context,
useSentinel: true,
),
optionsMap: LinkedHashMap.of({
systemTextScaleFactorOption: DisplayOption(
localizations.settingsSystemDefault,
),
0.8: DisplayOption(
localizations.settingsTextScalingSmall,
),
1.0: DisplayOption(
localizations.settingsTextScalingNormal,
),
2.0: DisplayOption(
localizations.settingsTextScalingLarge,
),
3.0: DisplayOption(
localizations.settingsTextScalingHuge,
),
}),
onOptionChanged: (newTextScale) => GalleryOptions.update(
context,
options.copyWith(textScaleFactor: newTextScale),
),
onTapSetting: () => onTapSetting(_ExpandableSetting.textScale),
isExpanded: _expandedSettingId == _ExpandableSetting.textScale,
),
SettingsListItem<CustomTextDirection?>(
title: localizations.settingsTextDirection,
selectedOption: options.customTextDirection,
optionsMap: LinkedHashMap.of({
CustomTextDirection.localeBased: DisplayOption(
localizations.settingsTextDirectionLocaleBased,
),
CustomTextDirection.ltr: DisplayOption(
localizations.settingsTextDirectionLTR,
),
CustomTextDirection.rtl: DisplayOption(
localizations.settingsTextDirectionRTL,
),
}),
onOptionChanged: (newTextDirection) => GalleryOptions.update(
context,
options.copyWith(customTextDirection: newTextDirection),
),
onTapSetting: () => onTapSetting(_ExpandableSetting.textDirection),
isExpanded: _expandedSettingId == _ExpandableSetting.textDirection,
),
SettingsListItem<Locale?>(
title: localizations.settingsLocale,
selectedOption: options.locale == deviceLocale
? systemLocaleOption
: options.locale,
optionsMap: _getLocaleOptions(),
onOptionChanged: (newLocale) {
if (newLocale == systemLocaleOption) {
newLocale = deviceLocale;
}
GalleryOptions.update(
context,
options.copyWith(locale: newLocale),
);
},
onTapSetting: () => onTapSetting(_ExpandableSetting.locale),
isExpanded: _expandedSettingId == _ExpandableSetting.locale,
),
SettingsListItem<TargetPlatform?>(
title: localizations.settingsPlatformMechanics,
selectedOption: options.platform,
optionsMap: LinkedHashMap.of({
TargetPlatform.android: DisplayOption('Android'),
TargetPlatform.iOS: DisplayOption('iOS'),
TargetPlatform.macOS: DisplayOption('macOS'),
TargetPlatform.linux: DisplayOption('Linux'),
TargetPlatform.windows: DisplayOption('Windows'),
}),
onOptionChanged: (newPlatform) => GalleryOptions.update(
context,
options.copyWith(platform: newPlatform),
),
onTapSetting: () => onTapSetting(_ExpandableSetting.platform),
isExpanded: _expandedSettingId == _ExpandableSetting.platform,
),
SettingsListItem<ThemeMode?>(
title: localizations.settingsTheme,
selectedOption: options.themeMode,
optionsMap: LinkedHashMap.of({
ThemeMode.system: DisplayOption(
localizations.settingsSystemDefault,
),
ThemeMode.dark: DisplayOption(
localizations.settingsDarkTheme,
),
ThemeMode.light: DisplayOption(
localizations.settingsLightTheme,
),
}),
onOptionChanged: (newThemeMode) => GalleryOptions.update(
context,
options.copyWith(themeMode: newThemeMode),
),
onTapSetting: () => onTapSetting(_ExpandableSetting.theme),
isExpanded: _expandedSettingId == _ExpandableSetting.theme,
),
ToggleSetting(
text: GalleryLocalizations.of(context)!.settingsSlowMotion,
value: options.timeDilation != 1.0,
onChanged: (isOn) => GalleryOptions.update(
context,
options.copyWith(timeDilation: isOn ? 5.0 : 1.0),
),
),
];
return Material(
color: colorScheme.secondaryContainer,
child: Padding(
padding: isDesktop
? EdgeInsets.zero
: const EdgeInsets.only(
bottom: galleryHeaderHeight,
),
// Remove ListView top padding as it is already accounted for.
child: MediaQuery.removePadding(
removeTop: isDesktop,
context: context,
child: ListView(
children: [
if (isDesktop)
const SizedBox(height: firstHeaderDesktopTopPadding),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 32),
child: ExcludeSemantics(
child: Header(
color: Theme.of(context).colorScheme.onSurface,
text: localizations.settingsTitle,
),
),
),
if (isDesktop)
...settingsListItems
else ...[
_AnimateSettingsListItems(
animation: _staggerSettingsItemsAnimation,
children: settingsListItems,
),
const SizedBox(height: 16),
Divider(thickness: 2, height: 0, color: colorScheme.outline),
const SizedBox(height: 12),
const SettingsAbout(),
const SettingsFeedback(),
const SizedBox(height: 12),
Divider(thickness: 2, height: 0, color: colorScheme.outline),
const SettingsAttribution(),
],
],
),
),
),
);
}
}
class SettingsAbout extends StatelessWidget {
const SettingsAbout({super.key});
@override
Widget build(BuildContext context) {
return _SettingsLink(
title: GalleryLocalizations.of(context)!.settingsAbout,
icon: Icons.info_outline,
onTap: () {
about.showAboutDialog(context: context);
},
);
}
}
class SettingsFeedback extends StatelessWidget {
const SettingsFeedback({super.key});
@override
Widget build(BuildContext context) {
return _SettingsLink(
title: GalleryLocalizations.of(context)!.settingsFeedback,
icon: Icons.feedback,
onTap: () async {
final url =
Uri.parse('https://github.com/flutter/gallery/issues/new/choose/');
if (await canLaunchUrl(url)) {
await launchUrl(url);
}
},
);
}
}
class SettingsAttribution extends StatelessWidget {
const SettingsAttribution({super.key});
@override
Widget build(BuildContext context) {
final isDesktop = isDisplayDesktop(context);
final verticalPadding = isDesktop ? 0.0 : 28.0;
return MergeSemantics(
child: Padding(
padding: EdgeInsetsDirectional.only(
start: isDesktop ? 24 : 32,
end: isDesktop ? 0 : 32,
top: verticalPadding,
bottom: verticalPadding,
),
child: SelectableText(
GalleryLocalizations.of(context)!.settingsAttribution,
style: Theme.of(context).textTheme.bodyLarge!.copyWith(
fontSize: 12,
color: Theme.of(context).colorScheme.onSecondary,
),
textAlign: isDesktop ? TextAlign.end : TextAlign.start,
),
),
);
}
}
class _SettingsLink extends StatelessWidget {
final String title;
final IconData? icon;
final GestureTapCallback? onTap;
const _SettingsLink({
required this.title,
this.icon,
this.onTap,
});
@override
Widget build(BuildContext context) {
final textTheme = Theme.of(context).textTheme;
final colorScheme = Theme.of(context).colorScheme;
final isDesktop = isDisplayDesktop(context);
return InkWell(
onTap: onTap,
child: Padding(
padding: EdgeInsets.symmetric(
horizontal: isDesktop ? 24 : 32,
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(
icon,
color: colorScheme.onSecondary.withOpacity(0.5),
size: 24,
),
Flexible(
child: Padding(
padding: const EdgeInsetsDirectional.only(
start: 16,
top: 12,
bottom: 12,
),
child: Text(
title,
style: textTheme.titleSmall!.apply(
color: colorScheme.onSecondary,
),
textAlign: isDesktop ? TextAlign.end : TextAlign.start,
),
),
),
],
),
),
);
}
}
/// Animate the settings list items to stagger in from above.
class _AnimateSettingsListItems extends StatelessWidget {
const _AnimateSettingsListItems({
required this.animation,
required this.children,
});
final Animation<double> animation;
final List<Widget> children;
@override
Widget build(BuildContext context) {
const dividingPadding = 4.0;
final dividerTween = Tween<double>(
begin: 0,
end: dividingPadding,
);
return Padding(
padding: const EdgeInsets.symmetric(vertical: 16.0),
child: Column(
children: [
for (Widget child in children)
AnimatedBuilder(
animation: animation,
builder: (context, child) {
return Padding(
padding: EdgeInsets.only(
top: dividerTween.animate(animation).value,
),
child: child,
);
},
child: child,
),
],
),
);
}
}
|
gallery/lib/pages/settings.dart/0
|
{'file_path': 'gallery/lib/pages/settings.dart', 'repo_id': 'gallery', 'token_count': 6483}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
import 'package:gallery/data/gallery_options.dart';
import 'package:gallery/studies/crane/model/formatters.dart';
abstract class Destination {
const Destination({
required this.id,
required this.destination,
required this.assetSemanticLabel,
required this.imageAspectRatio,
});
final int id;
final String destination;
final String assetSemanticLabel;
final double imageAspectRatio;
String get assetName;
String subtitle(BuildContext context);
String subtitleSemantics(BuildContext context) => subtitle(context);
@override
String toString() => '$destination (id=$id)';
}
class FlyDestination extends Destination {
const FlyDestination({
required super.id,
required super.destination,
required super.assetSemanticLabel,
required this.stops,
super.imageAspectRatio = 1,
this.duration,
});
final int stops;
final Duration? duration;
@override
String get assetName => 'crane/destinations/fly_$id.jpg';
@override
String subtitle(BuildContext context) {
final stopsText = GalleryLocalizations.of(context)!.craneFlyStops(stops);
if (duration == null) {
return stopsText;
} else {
final textDirection = GalleryOptions.of(context).resolvedTextDirection();
final durationText =
formattedDuration(context, duration!, abbreviated: true);
return textDirection == TextDirection.ltr
? '$stopsText · $durationText'
: '$durationText · $stopsText';
}
}
@override
String subtitleSemantics(BuildContext context) {
final stopsText = GalleryLocalizations.of(context)!.craneFlyStops(stops);
if (duration == null) {
return stopsText;
} else {
final durationText =
formattedDuration(context, duration!, abbreviated: false);
return '$stopsText, $durationText';
}
}
}
class SleepDestination extends Destination {
const SleepDestination({
required super.id,
required super.destination,
required super.assetSemanticLabel,
required this.total,
super.imageAspectRatio = 1,
});
final int total;
@override
String get assetName => 'crane/destinations/sleep_$id.jpg';
@override
String subtitle(BuildContext context) {
return GalleryLocalizations.of(context)!.craneSleepProperties(total);
}
}
class EatDestination extends Destination {
const EatDestination({
required super.id,
required super.destination,
required super.assetSemanticLabel,
required this.total,
super.imageAspectRatio = 1,
});
final int total;
@override
String get assetName => 'crane/destinations/eat_$id.jpg';
@override
String subtitle(BuildContext context) {
return GalleryLocalizations.of(context)!.craneEatRestaurants(total);
}
}
|
gallery/lib/studies/crane/model/destination.dart/0
|
{'file_path': 'gallery/lib/studies/crane/model/destination.dart', 'repo_id': 'gallery', 'token_count': 1005}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
import 'package:gallery/data/gallery_options.dart';
import 'package:gallery/layout/adaptive.dart';
import 'package:gallery/layout/text_scale.dart';
import 'package:gallery/studies/rally/tabs/accounts.dart';
import 'package:gallery/studies/rally/tabs/bills.dart';
import 'package:gallery/studies/rally/tabs/budgets.dart';
import 'package:gallery/studies/rally/tabs/overview.dart';
import 'package:gallery/studies/rally/tabs/settings.dart';
const int tabCount = 5;
const int turnsToRotateRight = 1;
const int turnsToRotateLeft = 3;
class HomePage extends StatefulWidget {
const HomePage({super.key});
@override
State<HomePage> createState() => _HomePageState();
}
class _HomePageState extends State<HomePage>
with SingleTickerProviderStateMixin, RestorationMixin {
late TabController _tabController;
RestorableInt tabIndex = RestorableInt(0);
@override
String get restorationId => 'home_page';
@override
void restoreState(RestorationBucket? oldBucket, bool initialRestore) {
registerForRestoration(tabIndex, 'tab_index');
_tabController.index = tabIndex.value;
}
@override
void initState() {
super.initState();
_tabController = TabController(length: tabCount, vsync: this)
..addListener(() {
// Set state to make sure that the [_RallyTab] widgets get updated when changing tabs.
setState(() {
tabIndex.value = _tabController.index;
});
});
}
@override
void dispose() {
_tabController.dispose();
tabIndex.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
final theme = Theme.of(context);
final isDesktop = isDisplayDesktop(context);
Widget tabBarView;
if (isDesktop) {
final isTextDirectionRtl =
GalleryOptions.of(context).resolvedTextDirection() ==
TextDirection.rtl;
final verticalRotation =
isTextDirectionRtl ? turnsToRotateLeft : turnsToRotateRight;
final revertVerticalRotation =
isTextDirectionRtl ? turnsToRotateRight : turnsToRotateLeft;
tabBarView = Row(
children: [
Container(
width: 150 + 50 * (cappedTextScale(context) - 1),
alignment: Alignment.topCenter,
padding: const EdgeInsets.symmetric(vertical: 32),
child: Column(
children: [
const SizedBox(height: 24),
ExcludeSemantics(
child: SizedBox(
height: 80,
child: Image.asset(
'logo.png',
package: 'rally_assets',
),
),
),
const SizedBox(height: 24),
// Rotate the tab bar, so the animation is vertical for desktops.
RotatedBox(
quarterTurns: verticalRotation,
child: _RallyTabBar(
tabs: _buildTabs(
context: context, theme: theme, isVertical: true)
.map(
(widget) {
// Revert the rotation on the tabs.
return RotatedBox(
quarterTurns: revertVerticalRotation,
child: widget,
);
},
).toList(),
tabController: _tabController,
),
),
],
),
),
Expanded(
// Rotate the tab views so we can swipe up and down.
child: RotatedBox(
quarterTurns: verticalRotation,
child: TabBarView(
controller: _tabController,
children: _buildTabViews().map(
(widget) {
// Revert the rotation on the tab views.
return RotatedBox(
quarterTurns: revertVerticalRotation,
child: widget,
);
},
).toList(),
),
),
),
],
);
} else {
tabBarView = Column(
children: [
_RallyTabBar(
tabs: _buildTabs(context: context, theme: theme),
tabController: _tabController,
),
Expanded(
child: TabBarView(
controller: _tabController,
children: _buildTabViews(),
),
),
],
);
}
return ApplyTextOptions(
child: Scaffold(
body: SafeArea(
// For desktop layout we do not want to have SafeArea at the top and
// bottom to display 100% height content on the accounts view.
top: !isDesktop,
bottom: !isDesktop,
child: Theme(
// This theme effectively removes the default visual touch
// feedback for tapping a tab, which is replaced with a custom
// animation.
data: theme.copyWith(
splashColor: Colors.transparent,
highlightColor: Colors.transparent,
),
child: FocusTraversalGroup(
policy: OrderedTraversalPolicy(),
child: tabBarView,
),
),
),
),
);
}
List<Widget> _buildTabs(
{required BuildContext context,
required ThemeData theme,
bool isVertical = false}) {
final localizations = GalleryLocalizations.of(context)!;
return [
_RallyTab(
theme: theme,
iconData: Icons.pie_chart,
title: localizations.rallyTitleOverview,
tabIndex: 0,
tabController: _tabController,
isVertical: isVertical,
),
_RallyTab(
theme: theme,
iconData: Icons.attach_money,
title: localizations.rallyTitleAccounts,
tabIndex: 1,
tabController: _tabController,
isVertical: isVertical,
),
_RallyTab(
theme: theme,
iconData: Icons.money_off,
title: localizations.rallyTitleBills,
tabIndex: 2,
tabController: _tabController,
isVertical: isVertical,
),
_RallyTab(
theme: theme,
iconData: Icons.table_chart,
title: localizations.rallyTitleBudgets,
tabIndex: 3,
tabController: _tabController,
isVertical: isVertical,
),
_RallyTab(
theme: theme,
iconData: Icons.settings,
title: localizations.rallyTitleSettings,
tabIndex: 4,
tabController: _tabController,
isVertical: isVertical,
),
];
}
List<Widget> _buildTabViews() {
return const [
OverviewView(),
AccountsView(),
BillsView(),
BudgetsView(),
SettingsView(),
];
}
}
class _RallyTabBar extends StatelessWidget {
const _RallyTabBar({
required this.tabs,
this.tabController,
});
final List<Widget> tabs;
final TabController? tabController;
@override
Widget build(BuildContext context) {
return FocusTraversalOrder(
order: const NumericFocusOrder(0),
child: TabBar(
// Setting isScrollable to true prevents the tabs from being
// wrapped in [Expanded] widgets, which allows for more
// flexible sizes and size animations among tabs.
isScrollable: true,
labelPadding: EdgeInsets.zero,
tabs: tabs,
controller: tabController,
// This hides the tab indicator.
indicatorColor: Colors.transparent,
),
);
}
}
class _RallyTab extends StatefulWidget {
_RallyTab({
required ThemeData theme,
IconData? iconData,
required String title,
int? tabIndex,
required TabController tabController,
required this.isVertical,
}) : titleText = Text(title, style: theme.textTheme.labelLarge),
isExpanded = tabController.index == tabIndex,
icon = Icon(iconData, semanticLabel: title);
final Text titleText;
final Icon icon;
final bool isExpanded;
final bool isVertical;
@override
_RallyTabState createState() => _RallyTabState();
}
class _RallyTabState extends State<_RallyTab>
with SingleTickerProviderStateMixin {
late Animation<double> _titleSizeAnimation;
late Animation<double> _titleFadeAnimation;
late Animation<double> _iconFadeAnimation;
late AnimationController _controller;
@override
void initState() {
super.initState();
_controller = AnimationController(
duration: const Duration(milliseconds: 200),
vsync: this,
);
_titleSizeAnimation = _controller.view;
_titleFadeAnimation = _controller.drive(CurveTween(curve: Curves.easeOut));
_iconFadeAnimation = _controller.drive(Tween<double>(begin: 0.6, end: 1));
if (widget.isExpanded) {
_controller.value = 1;
}
}
@override
void didUpdateWidget(_RallyTab oldWidget) {
super.didUpdateWidget(oldWidget);
if (widget.isExpanded) {
_controller.forward();
} else {
_controller.reverse();
}
}
@override
Widget build(BuildContext context) {
if (widget.isVertical) {
return Column(
children: [
const SizedBox(height: 18),
FadeTransition(
opacity: _iconFadeAnimation,
child: widget.icon,
),
const SizedBox(height: 12),
FadeTransition(
opacity: _titleFadeAnimation,
child: SizeTransition(
axis: Axis.vertical,
axisAlignment: -1,
sizeFactor: _titleSizeAnimation,
child: Center(child: ExcludeSemantics(child: widget.titleText)),
),
),
const SizedBox(height: 18),
],
);
}
// Calculate the width of each unexpanded tab by counting the number of
// units and dividing it into the screen width. Each unexpanded tab is 1
// unit, and there is always 1 expanded tab which is 1 unit + any extra
// space determined by the multiplier.
final width = MediaQuery.of(context).size.width;
const expandedTitleWidthMultiplier = 2;
final unitWidth = width / (tabCount + expandedTitleWidthMultiplier);
return ConstrainedBox(
constraints: const BoxConstraints(minHeight: 56),
child: Row(
children: [
FadeTransition(
opacity: _iconFadeAnimation,
child: SizedBox(
width: unitWidth,
child: widget.icon,
),
),
FadeTransition(
opacity: _titleFadeAnimation,
child: SizeTransition(
axis: Axis.horizontal,
axisAlignment: -1,
sizeFactor: _titleSizeAnimation,
child: SizedBox(
width: unitWidth * expandedTitleWidthMultiplier,
child: Center(
child: ExcludeSemantics(child: widget.titleText),
),
),
),
),
],
),
);
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
}
|
gallery/lib/studies/rally/home.dart/0
|
{'file_path': 'gallery/lib/studies/rally/home.dart', 'repo_id': 'gallery', 'token_count': 5248}
|
import 'package:flutter/material.dart';
import 'package:gallery/layout/adaptive.dart';
import 'package:gallery/studies/reply/mail_card_preview.dart';
import 'package:gallery/studies/reply/model/email_model.dart';
import 'package:gallery/studies/reply/model/email_store.dart';
import 'package:provider/provider.dart';
class MailboxBody extends StatelessWidget {
const MailboxBody({super.key});
@override
Widget build(BuildContext context) {
final isDesktop = isDisplayDesktop(context);
final isTablet = isDisplaySmallDesktop(context);
final startPadding = isTablet
? 60.0
: isDesktop
? 120.0
: 4.0;
final endPadding = isTablet
? 30.0
: isDesktop
? 60.0
: 4.0;
return Consumer<EmailStore>(
builder: (context, model, child) {
final destination = model.selectedMailboxPage;
final destinationString = destination
.toString()
.substring(destination.toString().indexOf('.') + 1);
late List<Email> emails;
switch (destination) {
case MailboxPageType.inbox:
{
emails = model.inboxEmails;
break;
}
case MailboxPageType.sent:
{
emails = model.outboxEmails;
break;
}
case MailboxPageType.starred:
{
emails = model.starredEmails;
break;
}
case MailboxPageType.trash:
{
emails = model.trashEmails;
break;
}
case MailboxPageType.spam:
{
emails = model.spamEmails;
break;
}
case MailboxPageType.drafts:
{
emails = model.draftEmails;
break;
}
}
return SafeArea(
bottom: false,
child: Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Expanded(
child: emails.isEmpty
? Center(child: Text('Empty in $destinationString'))
: ListView.separated(
itemCount: emails.length,
padding: EdgeInsetsDirectional.only(
start: startPadding,
end: endPadding,
top: isDesktop ? 28 : 0,
bottom: kToolbarHeight,
),
primary: false,
separatorBuilder: (context, index) =>
const SizedBox(height: 4),
itemBuilder: (context, index) {
var email = emails[index];
return MailPreviewCard(
id: email.id,
email: email,
isStarred: model.isEmailStarred(email.id),
onDelete: () => model.deleteEmail(email.id),
onStar: () {
int emailId = email.id;
if (model.isEmailStarred(emailId)) {
model.unstarEmail(emailId);
} else {
model.starEmail(emailId);
}
},
onStarredMailbox: model.selectedMailboxPage ==
MailboxPageType.starred,
);
},
),
),
if (isDesktop) ...[
Padding(
padding: const EdgeInsetsDirectional.only(top: 14),
child: Row(
children: [
IconButton(
key: const ValueKey('ReplySearch'),
icon: const Icon(Icons.search),
onPressed: () {
Provider.of<EmailStore>(
context,
listen: false,
).onSearchPage = true;
},
),
SizedBox(width: isTablet ? 30 : 60),
],
),
),
]
],
),
);
},
);
}
}
|
gallery/lib/studies/reply/mailbox_body.dart/0
|
{'file_path': 'gallery/lib/studies/reply/mailbox_body.dart', 'repo_id': 'gallery', 'token_count': 2739}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter_gen/gen_l10n/gallery_localizations.dart';
import 'package:gallery/studies/shrine/model/product.dart';
class ProductsRepository {
static List<Product> loadProducts(Category category) {
final allProducts = [
Product(
category: categoryAccessories,
id: 0,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductVagabondSack,
price: 120,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 1,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductStellaSunglasses,
price: 58,
assetAspectRatio: 329 / 247,
),
Product(
category: categoryAccessories,
id: 2,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductWhitneyBelt,
price: 35,
assetAspectRatio: 329 / 228,
),
Product(
category: categoryAccessories,
id: 3,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGardenStrand,
price: 98,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 4,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductStrutEarrings,
price: 34,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 5,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductVarsitySocks,
price: 12,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 6,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductWeaveKeyring,
price: 16,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 7,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGatsbyHat,
price: 40,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryAccessories,
id: 8,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductShrugBag,
price: 198,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 9,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGiltDeskTrio,
price: 58,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 10,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductCopperWireRack,
price: 18,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 11,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSootheCeramicSet,
price: 28,
assetAspectRatio: 329 / 247,
),
Product(
category: categoryHome,
id: 12,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductHurrahsTeaSet,
price: 34,
assetAspectRatio: 329 / 213,
),
Product(
category: categoryHome,
id: 13,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductBlueStoneMug,
price: 18,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 14,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductRainwaterTray,
price: 27,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 15,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductChambrayNapkins,
price: 16,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 16,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSucculentPlanters,
price: 16,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 17,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductQuartetTable,
price: 175,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryHome,
id: 18,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductKitchenQuattro,
price: 129,
assetAspectRatio: 329 / 246,
),
Product(
category: categoryClothing,
id: 19,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductClaySweater,
price: 48,
assetAspectRatio: 329 / 219,
),
Product(
category: categoryClothing,
id: 20,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSeaTunic,
price: 45,
assetAspectRatio: 329 / 221,
),
Product(
category: categoryClothing,
id: 21,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductPlasterTunic,
price: 38,
assetAspectRatio: 220 / 329,
),
Product(
category: categoryClothing,
id: 22,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductWhitePinstripeShirt,
price: 70,
assetAspectRatio: 219 / 329,
),
Product(
category: categoryClothing,
id: 23,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductChambrayShirt,
price: 70,
assetAspectRatio: 329 / 221,
),
Product(
category: categoryClothing,
id: 24,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSeabreezeSweater,
price: 60,
assetAspectRatio: 220 / 329,
),
Product(
category: categoryClothing,
id: 25,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGentryJacket,
price: 178,
assetAspectRatio: 329 / 219,
),
Product(
category: categoryClothing,
id: 26,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductNavyTrousers,
price: 74,
assetAspectRatio: 220 / 329,
),
Product(
category: categoryClothing,
id: 27,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductWalterHenleyWhite,
price: 38,
assetAspectRatio: 219 / 329,
),
Product(
category: categoryClothing,
id: 28,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSurfAndPerfShirt,
price: 48,
assetAspectRatio: 329 / 219,
),
Product(
category: categoryClothing,
id: 29,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGingerScarf,
price: 98,
assetAspectRatio: 219 / 329,
),
Product(
category: categoryClothing,
id: 30,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductRamonaCrossover,
price: 68,
assetAspectRatio: 220 / 329,
),
Product(
category: categoryClothing,
id: 31,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductChambrayShirt,
price: 38,
assetAspectRatio: 329 / 223,
),
Product(
category: categoryClothing,
id: 32,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductClassicWhiteCollar,
price: 58,
assetAspectRatio: 221 / 329,
),
Product(
category: categoryClothing,
id: 33,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductCeriseScallopTee,
price: 42,
assetAspectRatio: 329 / 219,
),
Product(
category: categoryClothing,
id: 34,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductShoulderRollsTee,
price: 27,
assetAspectRatio: 220 / 329,
),
Product(
category: categoryClothing,
id: 35,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductGreySlouchTank,
price: 24,
assetAspectRatio: 222 / 329,
),
Product(
category: categoryClothing,
id: 36,
isFeatured: false,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductSunshirtDress,
price: 58,
assetAspectRatio: 219 / 329,
),
Product(
category: categoryClothing,
id: 37,
isFeatured: true,
name: (context) =>
GalleryLocalizations.of(context)!.shrineProductFineLinesTee,
price: 58,
assetAspectRatio: 219 / 329,
),
];
if (category == categoryAll) {
return allProducts;
} else {
return allProducts.where((p) => p.category == category).toList();
}
}
}
|
gallery/lib/studies/shrine/model/products_repository.dart/0
|
{'file_path': 'gallery/lib/studies/shrine/model/products_repository.dart', 'repo_id': 'gallery', 'token_count': 5034}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:test/test.dart';
import '../tool/l10n_cli/l10n_cli.dart';
import 'utils.dart';
void main() {
test('verify intl_en_US.xml is up to date', () async {
final currentXml = readEnglishXml();
final newXml = await generateXmlFromArb();
expect(standardizeLineEndings(currentXml), standardizeLineEndings(newXml),
reason: 'intl_en_US.xml is not up to date. '
'Did you forget to run `flutter pub run grinder l10n`?');
});
}
|
gallery/test/l10n_test.dart/0
|
{'file_path': 'gallery/test/l10n_test.dart', 'repo_id': 'gallery', 'token_count': 231}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:convert' show JsonEncoder;
import 'package:flutter/material.dart';
import 'package:flutter_driver/driver_extension.dart';
import 'package:gallery/data/demos.dart';
import 'package:gallery/main.dart' show GalleryApp;
// See transitions_perf_test.dart for how to run this test.
Future<String> _handleMessages(String? message) async {
switch (message) {
case 'demoDescriptions':
final demoDescriptions = Demos.allDescriptions();
return const JsonEncoder.withIndent(' ').convert(demoDescriptions);
case 'isTestingCraneOnly':
return const String.fromEnvironment('onlyCrane', defaultValue: 'false');
case 'isTestingReplyOnly':
return const String.fromEnvironment('onlyReply', defaultValue: 'false');
default:
throw 'unknown message';
}
}
void main() {
enableFlutterDriverExtension(handler: _handleMessages);
runApp(const GalleryApp(isTestMode: true));
}
|
gallery/test_driver/transitions_perf.dart/0
|
{'file_path': 'gallery/test_driver/transitions_perf.dart', 'repo_id': 'gallery', 'token_count': 363}
|
// Copyright 2019 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:gallery/main.dart';
import 'package:gallery/studies/shrine/supplemental/product_card.dart';
import 'testing/precache_images.dart';
import 'testing/util.dart';
void main() {
group('mobile', () {
testWidgets(
'shrine displays shopping cart correctly',
(tester) async {
await setUpBinding(tester, size: mobileSize);
await pumpWidgetWithImages(
tester,
const GalleryApp(initialRoute: '/shrine'),
shrineAssets,
);
await tester.pumpAndSettle();
await tester.tap(
find.byWidgetPredicate(
(widget) => widget is Text && widget.data == 'NEXT',
),
);
await tester.pumpAndSettle();
await tester.tap(find.byType(MobileProductCard).first);
await tester.tap(find.byType(MobileProductCard).at(1));
await tester.pumpAndSettle();
await expectLater(
find.byType(GalleryApp),
matchesGoldenFile('goldens/shrine_mobile.png'),
);
},
);
});
group('desktop', () {
testWidgets(
'shrine displays shopping cart correctly',
(tester) async {
await setUpBinding(tester, size: desktopSize);
await pumpWidgetWithImages(
tester,
const GalleryApp(initialRoute: '/shrine'),
shrineAssets,
);
await tester.pumpAndSettle();
await tester.tap(
find.byWidgetPredicate(
(widget) => widget is Text && widget.data == 'NEXT',
),
);
await tester.pumpAndSettle();
await tester.tap(find.byType(DesktopProductCard).first);
await tester.tap(find.byType(DesktopProductCard).at(1));
await tester.pumpAndSettle();
await expectLater(
find.byType(GalleryApp),
matchesGoldenFile('goldens/shrine_desktop.png'),
);
},
);
});
}
|
gallery/test_goldens/shrine_test.dart/0
|
{'file_path': 'gallery/test_goldens/shrine_test.dart', 'repo_id': 'gallery', 'token_count': 940}
|
export 'package:gamepads_platform_interface/api/gamepad_controller.dart';
export 'package:gamepads_platform_interface/api/gamepad_event.dart';
export 'src/gamepads.dart';
|
gamepads/packages/gamepads/lib/gamepads.dart/0
|
{'file_path': 'gamepads/packages/gamepads/lib/gamepads.dart', 'repo_id': 'gamepads', 'token_count': 59}
|
include: package:flame_lint/analysis_options.yaml
|
gamepads/packages/gamepads_windows/analysis_options.yaml/0
|
{'file_path': 'gamepads/packages/gamepads_windows/analysis_options.yaml', 'repo_id': 'gamepads', 'token_count': 15}
|
import 'dart:math';
import 'package:flame/collisions.dart';
import 'package:flame/components.dart';
import 'package:flame/extensions.dart';
import '../endless_world.dart';
/// The [Obstacle] component can represent three different types of obstacles
/// that the player can run into.
class Obstacle extends SpriteComponent with HasWorldReference<EndlessWorld> {
Obstacle.small({super.position})
: _srcSize = Vector2.all(16),
_srcPosition = Vector2.all(32),
super(
size: Vector2.all(150),
anchor: Anchor.bottomLeft,
);
Obstacle.tall({super.position})
: _srcSize = Vector2(32, 48),
_srcPosition = Vector2.zero(),
super(
size: Vector2(200, 250),
anchor: Anchor.bottomLeft,
);
Obstacle.wide({super.position})
: _srcSize = Vector2(32, 16),
_srcPosition = Vector2(48, 32),
super(
size: Vector2(200, 100),
anchor: Anchor.bottomLeft,
);
/// Generates a random obstacle of type [ObstacleType].
factory Obstacle.random({
Vector2? position,
Random? random,
bool canSpawnTall = true,
}) {
final values = canSpawnTall
? const [ObstacleType.small, ObstacleType.tall, ObstacleType.wide]
: const [ObstacleType.small, ObstacleType.wide];
final obstacleType = values.random(random);
switch (obstacleType) {
case ObstacleType.small:
return Obstacle.small(position: position);
case ObstacleType.tall:
return Obstacle.tall(position: position);
case ObstacleType.wide:
return Obstacle.wide(position: position);
}
}
final Vector2 _srcSize;
final Vector2 _srcPosition;
@override
Future<void> onLoad() async {
// Since all the obstacles reside in the same image, srcSize and srcPosition
// are used to determine what part of the image that should be used.
sprite = await Sprite.load(
'enemies/obstacles.png',
srcSize: _srcSize,
srcPosition: _srcPosition,
);
// When adding a RectangleHitbox without any arguments it automatically
// fills up the size of the component.
add(RectangleHitbox());
}
@override
void update(double dt) {
// We need to move the component to the left together with the speed that we
// have set for the world.
// `dt` here stands for delta time and it is the time, in seconds, since the
// last update ran. We need to multiply the speed by `dt` to make sure that
// the speed of the obstacles are the same no matter the refresh rate/speed
// of your device.
position.x -= world.speed * dt;
// When the component is no longer visible on the screen anymore, we
// remove it.
// The position is defined from the upper left corner of the component (the
// anchor) and the center of the world is in (0, 0), so when the components
// position plus its size in X-axis is outside of minus half the world size
// we know that it is no longer visible and it can be removed.
if (position.x + size.x < -world.size.x / 2) {
removeFromParent();
}
}
}
enum ObstacleType {
small,
tall,
wide,
}
|
games/templates/endless_runner/lib/flame_game/components/obstacle.dart/0
|
{'file_path': 'games/templates/endless_runner/lib/flame_game/components/obstacle.dart', 'repo_id': 'games', 'token_count': 1149}
|
/// An interface of persistence stores for the player's progress.
///
/// Implementations can range from simple in-memory storage through
/// local preferences to cloud saves.
abstract class PlayerProgressPersistence {
Future<List<int>> getFinishedLevels();
Future<void> saveLevelFinished(int level, int time);
Future<void> reset();
}
|
games/templates/endless_runner/lib/player_progress/persistence/player_progress_persistence.dart/0
|
{'file_path': 'games/templates/endless_runner/lib/player_progress/persistence/player_progress_persistence.dart', 'repo_id': 'games', 'token_count': 86}
|
include: package:dart_flutter_team_lints/analysis_options.yaml
analyzer:
language:
strict-casts: true
linter:
rules:
- cancel_subscriptions
- package_api_docs
- prefer_relative_imports
- test_types_in_equals
|
gcloud/analysis_options.yaml/0
|
{'file_path': 'gcloud/analysis_options.yaml', 'repo_id': 'gcloud', 'token_count': 93}
|
// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
part of '../../db.dart';
/// An implementation of [ModelDB] based on model class annotations.
///
/// The two constructors will scan loaded dart libraries for classes with a
/// [Kind] annotation.
///
/// An example on how to write a model class is:
/// @Kind
/// class Person extends db.Model {
/// @StringProperty
/// String name;
///
/// @IntProperty
/// int age;
///
/// @DateTimeProperty
/// DateTime dateOfBirth;
/// }
///
/// These classes must either extend [Model] or [ExpandoModel]. Furthermore
/// they must have an empty default constructor which can be used to construct
/// model objects when doing lookups/queries from datastore.
class ModelDBImpl implements ModelDB {
final Map<_ModelDescription, Map<String, Property>> _modelDesc2Properties =
{};
final Map<String, _ModelDescription> _kind2ModelDesc = {};
final Map<_ModelDescription, mirrors.ClassMirror> _modelDesc2ClassMirror = {};
final Map<_ModelDescription, Type> _type2ModelDesc = {};
final Map<Type, _ModelDescription> _modelDesc2Type = {};
/// Initializes a new [ModelDB] from all libraries.
///
/// This will scan all libraries for classes with a [Kind] annotation.
///
/// In case an error is encountered (e.g. two model classes with the same kind
/// name) a [StateError] will be thrown.
ModelDBImpl() {
// WARNING: This is O(n) of the source code, which is very bad!
// Would be nice to have: `currentMirrorSystem().subclassesOf(Model)`
_initialize(mirrors.currentMirrorSystem().libraries.values);
}
/// Initializes a new [ModelDB] from all libraries.
///
/// This will scan the given [librarySymbol] for classes with a [Kind]
/// annotation.
///
/// In case an error is encountered (e.g. two model classes with the same kind
/// name) a [StateError] will be thrown.
ModelDBImpl.fromLibrary(Symbol librarySymbol) {
_initialize([mirrors.currentMirrorSystem().findLibrary(librarySymbol)]);
}
/// Converts a [ds.Key] to a [Key]. The key returned will have the correct
/// id type which is either `Key<String>` or `Key<int>`.
@override
Key fromDatastoreKey(ds.Key datastoreKey) {
var namespace = Partition(datastoreKey.partition.namespace);
var key = namespace.emptyKey;
for (var element in datastoreKey.elements) {
var type = _type2ModelDesc[_kind2ModelDesc[element.kind]!];
if (type == null) {
throw StateError(
'Could not find a model associated with kind "${element.kind}". '
'Please ensure a model class was annotated with '
'`@Kind(name: "${element.kind}")`.');
}
final elementId = element.id;
if (elementId is String) {
key = key.append<String>(type, id: elementId);
} else if (elementId is int) {
key = key.append<int>(type, id: elementId);
} else {
throw StateError('Key must be either String or int, but '
'was ${elementId.runtimeType} for key ${element.kind}');
}
}
return key;
}
/// Converts a [Key] to a [ds.Key].
@override
ds.Key toDatastoreKey(Key dbKey) {
var elements = <ds.KeyElement>[];
var currentKey = dbKey;
while (!currentKey.isEmpty) {
var id = currentKey.id;
var modelDescription = _modelDescriptionForType(currentKey.type)!;
var kind = modelDescription.kindName(this);
var useIntegerId = modelDescription.useIntegerId;
if (useIntegerId && id != null && id is! int) {
throw ArgumentError('Expected an integer id property but '
'id was of type ${id.runtimeType}');
}
if (!useIntegerId && (id != null && id is! String)) {
throw ArgumentError('Expected a string id property but '
'id was of type ${id.runtimeType}');
}
elements.add(ds.KeyElement(kind, id));
currentKey = currentKey.parent!;
}
var partition = currentKey._parent as Partition;
return ds.Key(elements.reversed.toList(),
partition: ds.Partition(partition.namespace));
}
/// Converts a [Model] instance to a [ds.Entity].
@override
ds.Entity toDatastoreEntity(Model model) {
try {
var modelDescription = _modelDescriptionForType(model.runtimeType)!;
return modelDescription.encodeModel(this, model);
} catch (error, stack) {
throw ArgumentError('Error while encoding entity ($error, $stack).');
}
}
/// Converts a [ds.Entity] to a [Model] instance.
@override
T? fromDatastoreEntity<T extends Model>(ds.Entity? entity) {
if (entity == null) {
return null;
}
var key = fromDatastoreKey(entity.key);
var kind = entity.key.elements.last.kind;
var modelDescription = _kind2ModelDesc[kind];
if (modelDescription == null) {
throw StateError('Trying to deserialize entity of kind '
'$kind, but no Model class available for it.');
}
try {
return modelDescription.decodeEntity<T>(this, key, entity);
} catch (error, stack) {
throw StateError('Error while decoding entity ($error, $stack).');
}
}
/// Returns the string representation of the kind of model class [type].
///
/// If the model class `type` is not found it will throw an `ArgumentError`.
@override
String kindName(Type type) {
var kind = _modelDesc2Type[type]?.kind;
if (kind == null) {
throw ArgumentError('The class $type was not associated with a kind.');
}
return kind;
}
/// Returns the name of the property corresponding to the kind [kind] and
/// [fieldName].
@override
String? fieldNameToPropertyName(String kind, String fieldName) {
var modelDescription = _kind2ModelDesc[kind];
if (modelDescription == null) {
throw ArgumentError('The kind "$kind" is unknown.');
}
return modelDescription.fieldNameToPropertyName(fieldName);
}
/// Converts [value] according to the [Property] named [name] in [type].
@override
Object? toDatastoreValue(String kind, String fieldName, Object? value,
{bool forComparison = false}) {
var modelDescription = _kind2ModelDesc[kind];
if (modelDescription == null) {
throw ArgumentError('The kind "$kind" is unknown.');
}
return modelDescription.encodeField(this, fieldName, value,
forComparison: forComparison);
}
Iterable<_ModelDescription> get _modelDescriptions {
return _modelDesc2Type.values;
}
Map<String, Property> _propertiesForModel(
_ModelDescription modelDescription) {
return _modelDesc2Properties[modelDescription]!;
}
_ModelDescription? _modelDescriptionForType(Type? type) {
return _modelDesc2Type[type!];
}
mirrors.ClassMirror? _modelClass(_ModelDescription md) {
return _modelDesc2ClassMirror[md];
}
void _initialize(Iterable<mirrors.LibraryMirror> libraries) {
for (var lm in libraries) {
lm.declarations.values
.whereType<mirrors.ClassMirror>()
.where((d) => d.hasReflectedType)
.forEach(_tryLoadNewModelClass);
}
// Ask every [ModelDescription] to compute whatever global state it wants
// to have.
for (var modelDescription in _modelDescriptions) {
modelDescription.initialize(this);
}
// Ask every [ModelDescription] whether we should register it with a given
// kind name.
for (var modelDescription in _modelDescriptions) {
var kindName = modelDescription.kindName(this);
if (_kind2ModelDesc.containsKey(kindName)) {
throw StateError('Cannot have two ModelDescriptions '
'with the same kind ($kindName)');
}
_kind2ModelDesc[kindName] = modelDescription;
}
}
void _tryLoadNewModelClass(mirrors.ClassMirror classMirror) {
Kind? kindAnnotation;
for (var instance in classMirror.metadata) {
if ((instance.reflectee as Object).runtimeType == Kind) {
if (kindAnnotation != null) {
throw StateError(
'Cannot have more than one ModelMetadata() annotation '
'on a Model class');
}
kindAnnotation = instance.reflectee as Kind?;
}
}
if (kindAnnotation != null) {
var name = kindAnnotation.name;
var integerId = kindAnnotation.idType == IdType.Integer;
var stringId = kindAnnotation.idType == IdType.String;
// Fall back to the class name.
name ??= mirrors.MirrorSystem.getName(classMirror.simpleName);
// This constraint should be guaranteed by the Kind() const constructor.
assert((integerId && !stringId) || (!integerId && stringId));
_tryLoadNewModelClassFull(classMirror, name, integerId);
}
}
static bool _isRequiredAnnotation(mirrors.InstanceMirror annotation) {
return annotation.type.simpleName == #Required;
}
/// Returns true if a constructor invocation is valid even if the specified
/// [parameter] is omitted.
///
/// This is true for named parameters, optional parameters, and parameters
/// with a default value.
static bool _canBeOmitted(mirrors.ParameterMirror parameter) {
if (parameter.metadata.any(_isRequiredAnnotation)) {
return false;
}
return parameter.isOptional ||
parameter.isNamed ||
parameter.hasDefaultValue;
}
/// Returns true if the specified [classMirror] has a default (unnamed)
/// constructor that accepts an empty arguments list.
@visibleForTesting
static bool hasDefaultConstructor(mirrors.ClassMirror classMirror) {
for (var declaration in classMirror.declarations.values) {
if (declaration is mirrors.MethodMirror) {
if (declaration.isConstructor &&
declaration.constructorName == const Symbol('') &&
declaration.parameters.every(_canBeOmitted)) {
return true;
}
}
}
return false;
}
void _tryLoadNewModelClassFull(
mirrors.ClassMirror modelClass, String name, bool useIntegerId) {
assert(!_modelDesc2Type.containsKey(modelClass.reflectedType));
_ModelDescription modelDesc;
if (_isExpandoClass(modelClass)) {
modelDesc = _ExpandoModelDescription(name, useIntegerId);
} else {
modelDesc = _ModelDescription(name, useIntegerId);
}
_type2ModelDesc[modelDesc] = modelClass.reflectedType;
_modelDesc2Type[modelClass.reflectedType] = modelDesc;
_modelDesc2ClassMirror[modelDesc] = modelClass;
_modelDesc2Properties[modelDesc] =
_propertiesFromModelDescription(modelClass);
// Ensure we have an empty constructor.
if (!hasDefaultConstructor(modelClass)) {
throw StateError('Class ${modelClass.simpleName} does not have a default '
'constructor.');
}
}
Map<String, Property> _propertiesFromModelDescription(
mirrors.ClassMirror modelClassMirror) {
var properties = <String, Property>{};
var propertyNames = <String>{};
// Loop over all classes in the inheritance path up to the Object class.
while (modelClassMirror.superclass != null) {
var memberMap = modelClassMirror.instanceMembers;
// Loop over all declarations (which includes fields)
modelClassMirror.declarations
.forEach((Symbol fieldSymbol, mirrors.DeclarationMirror decl) {
// Look if the symbol is a getter and we have metadata attached to it.
if (memberMap.containsKey(fieldSymbol) &&
memberMap[fieldSymbol]!.isGetter) {
final propertyAnnotations = decl.metadata
.map((mirrors.InstanceMirror mirror) => mirror.reflectee)
.whereType<Property>()
.toList();
if (propertyAnnotations.length > 1) {
throw StateError(
'Cannot have more than one Property annotation on a model '
'field.');
} else if (propertyAnnotations.length == 1) {
var property = propertyAnnotations.first;
// Get a String representation of the field and the value.
var fieldName = mirrors.MirrorSystem.getName(fieldSymbol);
// Determine the name to use for the property in datastore.
var propertyName = property.propertyName;
propertyName ??= fieldName;
if (properties.containsKey(fieldName)) {
throw StateError(
'Cannot have two Property objects describing the same field '
'in a model object class hierarchy.');
}
if (propertyNames.contains(propertyName)) {
throw StateError(
'Cannot have two Property objects mapping to the same '
'datastore property name "$propertyName".');
}
properties[fieldName] = property;
propertyNames.add(propertyName);
}
}
});
modelClassMirror = modelClassMirror.superclass!;
}
return properties;
}
final _originalExpandoModelClass = mirrors.reflectClass(ExpandoModel);
final _originalModelClass = mirrors.reflectClass(Model);
bool _isExpandoClass(mirrors.ClassMirror? modelClass) {
while (modelClass != null && modelClass.superclass != modelClass) {
if (modelClass.originalDeclaration == _originalExpandoModelClass) {
return true;
} else if (modelClass.originalDeclaration == _originalModelClass) {
return false;
}
modelClass = modelClass.superclass;
}
throw StateError('This should be unreachable.');
}
}
class _ModelDescription<T extends Model> {
final HashMap<String, String> _property2FieldName = HashMap<String, String>();
final HashMap<String, String> _field2PropertyName = HashMap<String, String>();
final Set<String> _indexedProperties = <String>{};
final Set<String> _unIndexedProperties = <String>{};
final String kind;
final bool useIntegerId;
_ModelDescription(this.kind, this.useIntegerId);
void initialize(ModelDBImpl db) {
// Compute propertyName -> fieldName mapping.
db._propertiesForModel(this).forEach((String fieldName, Property prop) {
// The default of a datastore property name is the fieldName.
// It can be overridden with [Property.propertyName].
var propertyName = prop.propertyName;
propertyName ??= fieldName;
_property2FieldName[propertyName] = fieldName;
_field2PropertyName[fieldName] = propertyName;
});
// Compute properties & unindexed properties
db._propertiesForModel(this).forEach((String fieldName, Property prop) {
var propertyName = prop.propertyName;
propertyName ??= fieldName;
if (prop.indexed) {
_indexedProperties.add(propertyName);
} else {
_unIndexedProperties.add(propertyName);
}
});
}
String kindName(ModelDBImpl db) => kind;
ds.Entity encodeModel(ModelDBImpl db, T model) {
var key = db.toDatastoreKey(model.key);
var properties = <String, Object?>{};
var mirror = mirrors.reflect(model);
db._propertiesForModel(this).forEach((String fieldName, Property prop) {
_encodeProperty(db, model, mirror, properties, fieldName, prop);
});
return ds.Entity(key, properties,
unIndexedProperties: _unIndexedProperties);
}
void _encodeProperty(
ModelDBImpl db,
Model model,
mirrors.InstanceMirror mirror,
Map properties,
String fieldName,
Property prop) {
var propertyName = prop.propertyName;
propertyName ??= fieldName;
var value =
mirror.getField(mirrors.MirrorSystem.getSymbol(fieldName)).reflectee;
if (!prop.validate(db, value)) {
throw StateError('Property validation failed for '
'property $fieldName while trying to serialize entity of kind '
'${model.runtimeType}. ');
}
properties[propertyName] = prop.encodeValue(db, value);
}
H decodeEntity<H extends Model>(ModelDBImpl db, Key key, ds.Entity entity) {
// NOTE: this assumes a default constructor for the model classes!
var classMirror = db._modelClass(this)!;
var mirror = classMirror.newInstance(const Symbol(''), []);
// Set the id and the parent key
final model = mirror.reflectee as Model;
model.id = key.id;
model.parentKey = key.parent;
db._propertiesForModel(this).forEach((String fieldName, Property prop) {
_decodeProperty(db, entity, mirror, fieldName, prop);
});
return mirror.reflectee as H;
}
void _decodeProperty(ModelDBImpl db, ds.Entity entity,
mirrors.InstanceMirror mirror, String fieldName, Property prop) {
var propertyName = fieldNameToPropertyName(fieldName);
var rawValue = entity.properties[propertyName!];
var value = prop.decodePrimitiveValue(db, rawValue);
if (!prop.validate(db, value)) {
throw StateError('Property validation failed while '
'trying to deserialize entity of kind '
'${entity.key.elements.last.kind} (property name: $propertyName)');
}
try {
mirror.setField(mirrors.MirrorSystem.getSymbol(fieldName), value);
// ignore: avoid_catching_errors
} on TypeError catch (error) {
throw StateError(
'Error trying to set property "${prop.propertyName}" '
'to $value for field "$fieldName": $error',
);
}
}
String? fieldNameToPropertyName(String fieldName) {
return _field2PropertyName[fieldName];
}
String? propertyNameToFieldName(ModelDBImpl db, String propertySearchName) {
return _property2FieldName[propertySearchName];
}
Object? encodeField(ModelDBImpl db, String fieldName, Object? value,
{bool enforceFieldExists = true, bool forComparison = false}) {
var property = db._propertiesForModel(this)[fieldName];
if (property != null) {
return property.encodeValue(db, value, forComparison: forComparison);
}
if (enforceFieldExists) {
throw ArgumentError(
'A field named "$fieldName" does not exist in kind "$kind".');
}
return null;
}
}
// NOTE/TODO:
// Currently expanded properties are only
// * decoded if there are no clashes in [usedNames]
// * encoded if there are no clashes in [usedNames]
// We might want to throw an error if there are clashes, because otherwise
// - we may end up removing properties after a read-write cycle
// - we may end up dropping added properties in a write
// ([usedNames] := [realFieldNames] + [realPropertyNames])
class _ExpandoModelDescription extends _ModelDescription<ExpandoModel> {
late Set<String> realFieldNames;
late Set<String> realPropertyNames;
late Set<String> usedNames;
_ExpandoModelDescription(String kind, bool useIntegerId)
: super(kind, useIntegerId);
@override
void initialize(ModelDBImpl db) {
super.initialize(db);
realFieldNames = Set<String>.from(_field2PropertyName.keys);
realPropertyNames = Set<String>.from(_property2FieldName.keys);
usedNames = <String>{}
..addAll(realFieldNames)
..addAll(realPropertyNames);
}
@override
ds.Entity encodeModel(ModelDBImpl db, ExpandoModel model) {
var entity = super.encodeModel(db, model);
var properties = entity.properties;
model.additionalProperties.forEach((String key, Object? value) {
// NOTE: All expanded properties will be indexed.
if (!usedNames.contains(key)) {
properties[key] = value;
}
});
return entity;
}
@override
T decodeEntity<T extends Model>(ModelDBImpl db, Key key, ds.Entity entity) {
var model = super.decodeEntity(db, key, entity) as ExpandoModel;
var properties = entity.properties;
properties.forEach((String key, Object? value) {
if (!usedNames.contains(key)) {
model.additionalProperties[key] = value;
}
});
// TODO: check if there is a more elegant solution than this
return model as T;
}
@override
String fieldNameToPropertyName(String fieldName) {
var propertyName = super.fieldNameToPropertyName(fieldName);
// If the ModelDescription doesn't know about [fieldName], it's an
// expanded property, where propertyName == fieldName.
propertyName ??= fieldName;
return propertyName;
}
@override
String propertyNameToFieldName(ModelDBImpl db, String propertyName) {
var fieldName = super.propertyNameToFieldName(db, propertyName);
// If the ModelDescription doesn't know about [propertyName], it's an
// expanded property, where propertyName == fieldName.
fieldName ??= propertyName;
return fieldName;
}
@override
Object encodeField(ModelDBImpl db, String fieldName, Object? value,
{bool enforceFieldExists = true, bool forComparison = false}) {
// The [enforceFieldExists] argument is intentionally ignored.
var primitiveValue = super.encodeField(db, fieldName, value,
enforceFieldExists: false, forComparison: forComparison);
// If superclass can't encode field, we return value here (and assume
// it's primitive)
// NOTE: Implicit assumption:
// If value != null then superclass will return != null.
// TODO: Ensure [value] is primitive in this case.
primitiveValue ??= value;
return primitiveValue!;
}
}
|
gcloud/lib/src/db/model_db_impl.dart/0
|
{'file_path': 'gcloud/lib/src/db/model_db_impl.dart', 'repo_id': 'gcloud', 'token_count': 7529}
|
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:gen_art_canvas/auth/domain/artist.dart';
import 'package:gen_art_canvas/core/data/firestore_repository.dart';
class ArtistsRepository extends FirestoreRepository<Artist> {
ArtistsRepository(this._firestore);
final FirebaseFirestore _firestore;
@override
String get collectionName => 'artists';
CollectionReference<Artist> get collection =>
_firestore.collection(collectionName).withConverter(
fromFirestore: (snapshot, _) =>
Artist.fromMap(snapshot.data()!, snapshot.id),
toFirestore: (artist, _) => artist.toMap(),
);
Future<void> addArtist({
required String uid,
required String nickname,
}) async {
await collection.doc(uid).set(
Artist(
id: uid,
nickname: nickname,
joinedAt: DateTime.now(),
),
);
}
Future<void> updateArtist({
required String id,
String? nickname,
int? createdCuboidsCount,
}) async {
await collection.doc(id).update(
{
if (nickname != null) 'nickname': nickname,
if (createdCuboidsCount != null)
'createdCuboidsCount': createdCuboidsCount,
},
);
}
Stream<List<Artist>> watchArtists() {
return collection
.snapshots()
.map((snapshot) => snapshot.docs.map((doc) => doc.data()).toList());
}
Future<Artist?> getArtist(String uid) async {
final artistDoc = await collection.doc(uid).get();
return artistDoc.data();
}
Future<void> deleteArtist(String uid) {
return collection.doc(uid).delete();
}
Stream<Artist?> watchArtist(String uid) {
return collection.doc(uid).snapshots().map((event) => event.data());
}
}
final artistsRepositoryProvider = Provider<ArtistsRepository>(
(ref) => ArtistsRepository(FirebaseFirestore.instance),
);
|
gen_art_canvas/lib/auth/data/artists_repository.dart/0
|
{'file_path': 'gen_art_canvas/lib/auth/data/artists_repository.dart', 'repo_id': 'gen_art_canvas', 'token_count': 746}
|
import 'dart:developer';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:gen_art_canvas/auth/application/auth_service.dart';
import 'package:gen_art_canvas/auth/domain/artist.dart';
import 'package:gen_art_canvas/auth/widgets/artist_home_info.dart';
import 'package:gen_art_canvas/auth/widgets/artist_nickname_dialog.dart';
import 'package:gen_art_canvas/core/style/app_colors.dart';
import 'package:gen_art_canvas/cuboids/application/cuboids_service.dart';
import 'package:gen_art_canvas/cuboids/presentation/widgets/cuboids_canvas.dart';
import 'package:gen_art_canvas/cuboids/presentation/widgets/cuboids_creator_bottom_sheet.dart';
import 'package:gen_art_canvas/settings/cuboids_canvas_settings.dart';
import 'package:gen_art_canvas/settings/cuboids_canvas_settings_provider.dart';
class CuboidsCanvasHomePage extends ConsumerStatefulWidget {
const CuboidsCanvasHomePage({super.key});
@override
ConsumerState<CuboidsCanvasHomePage> createState() => _HomePageState();
}
class _HomePageState extends ConsumerState<CuboidsCanvasHomePage> {
void _showNicknameDialog(BuildContext context) {
showDialog<void>(
context: context,
builder: (context) => ArtistNicknameDialog(
onSubmit: (String nickname) {
ref
.read(authServiceProvider)
.signArtistInAnonymously(nickname: nickname);
Navigator.of(context).pop();
},
onCancel: () => Navigator.of(context).pop(),
),
);
}
void _showCreatorBottomSheet(
BuildContext context,
CuboidsCanvasSettings settings,
Artist authArtist,
) {
showModalBottomSheet<void>(
context: context,
showDragHandle: true,
isScrollControlled: true,
builder: (context) => CuboidsCreatorBottomSheet(
settings: settings,
authArtist: authArtist,
onSubmit: () => Navigator.of(context).pop(),
),
);
}
@override
Widget build(BuildContext context) {
final authArtist = ref.watch(authArtistProvider).value;
final cuboids = ref.watch(cuboidsProvider).value;
return Scaffold(
body: ref.watch(cuboidsCanvasSettingsProvider).when(
data: (CuboidsCanvasSettings settings) => Stack(
children: [
CuboidsCanvas(
settings: settings,
initialGap: MediaQuery.of(context).size.width * 0.02,
cuboids: cuboids?.reversed.toList() ?? [],
),
if (authArtist != null)
Positioned(
top: MediaQuery.of(context).padding.top + 5,
left: 10,
child: ArtistHomeInfo(
authArtist,
onSignOut: () =>
ref.watch(authServiceProvider).signArtistOut(),
),
),
Positioned(
left: 0,
right: 0,
bottom: 0,
child: Center(
child: InkWell(
onTap: authArtist == null
? () => _showNicknameDialog(context)
: () => _showCreatorBottomSheet(
context,
settings,
authArtist,
),
child: Container(
padding: const EdgeInsets.symmetric(
horizontal: 20,
vertical: 10,
),
decoration: BoxDecoration(
color: AppColors.firebaseDarkGrey,
borderRadius: const BorderRadius.only(
topRight: Radius.circular(25),
topLeft: Radius.circular(25),
),
boxShadow: [
BoxShadow(
blurRadius: 10,
color: Colors.black.withOpacity(0.5),
),
],
),
child: const Text('Start Creating'),
),
),
),
),
],
),
error: (e, _) {
log('Error fetching cuboids canvas settings');
log(e.toString());
return const Center(child: Text('An error occurred!'));
},
loading: () => const Center(child: CircularProgressIndicator()),
),
);
}
}
|
gen_art_canvas/lib/cuboids/presentation/pages/cuboids_canvas_home_page.dart/0
|
{'file_path': 'gen_art_canvas/lib/cuboids/presentation/pages/cuboids_canvas_home_page.dart', 'repo_id': 'gen_art_canvas', 'token_count': 2511}
|
export 'view/glow_stuff_page.dart';
export 'widgets/widgets.dart';
|
glow_stuff_with_flutter/lib/glow_stuff/glow_stuff.dart/0
|
{'file_path': 'glow_stuff_with_flutter/lib/glow_stuff/glow_stuff.dart', 'repo_id': 'glow_stuff_with_flutter', 'token_count': 27}
|
name: file_test_package
description: Pubspec used for unittesting of the discoveryapis_generator package.
publish_to: none
environment:
sdk: ^3.0.0
dependencies:
_discoveryapis_commons: ^1.0.0
http: any
dev_dependencies:
dart_flutter_team_lints: ^2.0.0
dependency_overrides:
_discoveryapis_commons:
path: ../discoveryapis_commons
|
googleapis.dart/_test/pubspec.yaml/0
|
{'file_path': 'googleapis.dart/_test/pubspec.yaml', 'repo_id': 'googleapis.dart', 'token_count': 136}
|
// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:meta/meta.dart';
import 'api_requester.dart';
import 'multipart_media_uploader.dart';
import 'request_impl.dart';
import 'requests.dart' as client_requests;
// TODO: Buffer less if we know the content length in advance.
/// Does media uploads using the resumable upload protocol.
class ResumableMediaUploader {
final http.Client _httpClient;
final client_requests.Media _uploadMedia;
final Uri _uri;
final String? _body;
final String _method;
final client_requests.ResumableUploadOptions _options;
final Map<String, String> _requestHeaders;
ResumableMediaUploader(
this._httpClient,
this._uploadMedia,
this._body,
this._uri,
this._method,
this._options,
this._requestHeaders,
);
/// Returns the final [http.StreamedResponse] if the upload succeed and
/// completes with an error otherwise.
///
/// The returned response stream has not been listened to.
Future<http.StreamedResponse> upload() async {
final uploadUri = await _startSession();
late StreamSubscription subscription;
final completer = Completer<http.StreamedResponse>();
var completed = false;
final chunkStack = ChunkStack(_options.chunkSize);
subscription = _uploadMedia.stream.listen((List<int> bytes) {
chunkStack.addBytes(bytes);
// Upload all but the last chunk.
// The final send will be done in the [onDone] handler.
final hasPartialChunk = chunkStack.hasPartialChunk;
if (chunkStack.length > 1 ||
(chunkStack.length == 1 && hasPartialChunk)) {
// Pause the input stream.
subscription.pause();
// Upload all chunks except the last one.
Iterable<ResumableChunk> fullChunks;
if (hasPartialChunk) {
fullChunks = chunkStack.removeSublist(0, chunkStack.length);
} else {
fullChunks = chunkStack.removeSublist(0, chunkStack.length - 1);
}
Future.forEach(
fullChunks,
(ResumableChunk c) => _uploadChunkDrained(uploadUri, c),
).then((_) {
// All chunks uploaded, we can continue consuming data.
subscription.resume();
}).onError((Object error, StackTrace stack) {
subscription.cancel();
completed = true;
completer.completeError(error, stack);
});
}
}, onError: (Object error, StackTrace stack) {
subscription.cancel();
if (!completed) {
completed = true;
completer.completeError(error, stack);
}
}, onDone: () {
if (!completed) {
chunkStack.finalize();
ResumableChunk lastChunk;
if (chunkStack.length == 1) {
lastChunk = chunkStack.removeSublist(0, chunkStack.length).first;
} else {
completer.completeError(StateError(
'Resumable uploads need to result in at least one non-empty '
'chunk at the end.'));
return;
}
final end = lastChunk.endOfChunk;
// Validate that we have the correct number of bytes if length was
// specified.
if (_uploadMedia.length != null) {
if (end < _uploadMedia.length!) {
completer.completeError(client_requests.ApiRequestError(
'Received less bytes than indicated by [Media.length].'));
return;
} else if (end > _uploadMedia.length!) {
completer.completeError(client_requests.ApiRequestError(
'Received more bytes than indicated by [Media.length].'));
return;
}
}
// Upload last chunk and *do not drain the response* but complete
// with it.
_uploadChunkResumable(uploadUri, lastChunk, lastChunk: true)
.then(completer.complete)
.onError(completer.completeError);
}
});
return completer.future;
}
/// Starts a resumable upload.
///
/// Returns the [Uri] which should be used for uploading all content.
Future<Uri> _startSession() async {
var length = 0;
List<int>? bytes;
if (_body != null) {
bytes = utf8.encode(_body!);
length = bytes.length;
}
final bodyStream =
bytes == null ? const Stream<List<int>>.empty() : Stream.value(bytes);
final headers = {
..._requestHeaders,
'content-type': contentTypeJsonUtf8,
'content-length': '$length',
'x-upload-content-type': _uploadMedia.contentType,
'x-upload-content-length': '${_uploadMedia.length}',
};
final request =
RequestImpl(_method, _uri, stream: bodyStream, headers: headers);
final response = await _httpClient.send(request);
await validateResponse(response);
await response.stream.drain<void>();
final uploadUri = response.headers['location'];
if (response.statusCode != 200 || uploadUri == null) {
throw client_requests.ApiRequestError(
'Invalid response for resumable upload attempt '
'(status was: ${response.statusCode})',
);
}
return Uri.parse(uploadUri);
}
/// Uploads [chunk], retries upon server errors. The response stream will be
/// drained.
Future _uploadChunkDrained(Uri uri, ResumableChunk chunk) async {
final response = await _uploadChunkResumable(uri, chunk);
await response.stream.drain<void>();
}
/// Does repeated attempts to upload [chunk].
Future<http.StreamedResponse> _uploadChunkResumable(
Uri uri,
ResumableChunk chunk, {
bool lastChunk = false,
}) {
Future<http.StreamedResponse> tryUpload(int attemptsLeft) async {
final response = await _uploadChunk(uri, chunk, lastChunk: lastChunk);
final status = response.statusCode;
if (attemptsLeft > 0 &&
(status == 500 || (502 <= status && status < 504))) {
await response.stream.drain<void>();
// Delay the next attempt. Default backoff function is exponential
final failedAttempts = _options.numberOfAttempts - attemptsLeft;
final duration = _options.backoffFunction(failedAttempts);
if (duration == null) {
throw client_requests.DetailedApiRequestError(
status,
'Resumable upload: Uploading a chunk resulted in status '
'$status. Maximum number of retries reached.');
}
await Future<void>.delayed(duration);
return tryUpload(attemptsLeft - 1);
} else if (!lastChunk && status != 308) {
await response.stream.drain<void>();
throw client_requests.DetailedApiRequestError(
status,
'Resumable upload: Uploading a chunk resulted in status '
'$status instead of 308.',
);
} else if (lastChunk && status != 201 && status != 200) {
await response.stream.drain<void>();
throw client_requests.DetailedApiRequestError(
status,
'Resumable upload: Uploading a chunk resulted in status '
'$status instead of 200 or 201.',
);
} else {
return response;
}
}
return tryUpload(_options.numberOfAttempts - 1);
}
/// Uploads [chunk] to [uri] and ensures the upload was successful.
///
/// Returns [http.StreamedResponse] or completes with an error if
/// the upload did not succeed.
///
/// The response stream will not be listened to.
Future<http.StreamedResponse> _uploadChunk(
Uri uri,
ResumableChunk chunk, {
bool lastChunk = false,
}) {
// If [uploadMedia.length] is null, we do not know the length.
var mediaTotalLength = _uploadMedia.length?.toString();
if (mediaTotalLength == null || lastChunk) {
if (lastChunk) {
mediaTotalLength = '${chunk.endOfChunk}';
} else {
mediaTotalLength = '*';
}
}
final headers = {
..._requestHeaders,
'content-type': _uploadMedia.contentType,
'content-length': '${chunk.length}',
'content-range':
'bytes ${chunk.offset}-${chunk.endOfChunk - 1}/$mediaTotalLength',
};
final stream = Stream.fromIterable(chunk.byteArrays);
final request = RequestImpl('PUT', uri, stream: stream, headers: headers);
return _httpClient.send(request);
}
}
/// Represents a stack of [ResumableChunk]s.
@visibleForTesting
class ChunkStack {
final int _chunkSize;
final List<ResumableChunk> _chunkStack = [];
// Currently accumulated data.
List<List<int>> _byteArrays = [];
int _length = 0;
int _offset = 0;
bool _finalized = false;
ChunkStack(this._chunkSize);
/// Whether data for a not-yet-finished [ResumableChunk] is present.
///
/// A call to `finalize` will create a [ResumableChunk] of this data.
bool get hasPartialChunk => _length > 0;
/// The number of chunks in this [ChunkStack].
int get length => _chunkStack.length;
/// The total number of bytes which have been converted to [ResumableChunk]s.
/// Can only be called once this [ChunkStack] has been finalized.
int get totalByteLength {
if (!_finalized) {
throw StateError('ChunkStack has not been finalized yet.');
}
return _offset;
}
/// Returns the chunks [from] ... [to] and deletes it from the stack.
List<ResumableChunk> removeSublist(int from, int to) {
final sublist = _chunkStack.sublist(from, to);
_chunkStack.removeRange(from, to);
return sublist;
}
/// Adds [bytes] to the buffer. If the buffer is larger than the given chunk
/// size a new [ResumableChunk] will be created.
void addBytes(List<int> bytes) {
if (_finalized) {
throw StateError('ChunkStack has already been finalized.');
}
final remaining = _chunkSize - _length;
if (bytes.length >= remaining) {
final left = bytes.sublist(0, remaining);
final right = bytes.sublist(remaining);
_byteArrays.add(left);
_length += left.length;
_chunkStack.add(ResumableChunk(_byteArrays, _offset, _length));
_byteArrays = [];
_offset += _length;
_length = 0;
addBytes(right);
} else if (bytes.isNotEmpty) {
_byteArrays.add(bytes);
_length += bytes.length;
}
}
/// Finalizes this [ChunkStack] and creates the last chunk (may have less
/// bytes than the chunk size, but not zero).
void finalize() {
if (_finalized) {
throw StateError('ChunkStack has already been finalized.');
}
_finalized = true;
if (_length > 0) {
_chunkStack.add(ResumableChunk(_byteArrays, _offset, _length));
_offset += _length;
}
}
}
/// Represents a chunk of data that will be transferred in one http request.
@visibleForTesting
class ResumableChunk {
final List<List<int>> byteArrays;
final int offset;
final int length;
/// Index of the next byte after this chunk.
int get endOfChunk => offset + length;
ResumableChunk(this.byteArrays, this.offset, this.length);
}
|
googleapis.dart/discoveryapis_commons/lib/src/resumable_media_uploader.dart/0
|
{'file_path': 'googleapis.dart/discoveryapis_commons/lib/src/resumable_media_uploader.dart', 'repo_id': 'googleapis.dart', 'token_count': 4240}
|
import 'dart_api_library.dart';
import 'dart_resources.dart';
import 'dart_schemas.dart';
import 'generated_googleapis/discovery/v1.dart';
import 'namer.dart';
import 'utils.dart';
abstract class BaseApiLibrary {
DartSchemaTypeDB get schemaDB;
DartApiClass get apiClass;
final ApiLibraryNamer namer;
final RestDescription description;
late final DartApiImports imports;
BaseApiLibrary(this.description, String apiClassSuffix,
{bool useCorePrefixes = true})
: namer = ApiLibraryNamer(apiClassSuffix: apiClassSuffix) {
imports = DartApiImports.fromNamer(namer, useCorePrefixes: useCorePrefixes);
}
String libraryHeader();
String get librarySource {
final sink = StringBuffer();
final schemas = generateSchemas(schemaDB.dartClassTypes);
final resources = generateResources(apiClass);
sink.write(libraryHeader());
if (resources.isNotEmpty) {
sink.write('$resources\n$schemas');
} else {
sink.write(schemas);
}
return formatSource(sink.toString());
}
}
|
googleapis.dart/discoveryapis_generator/lib/src/base_api_library.dart/0
|
{'file_path': 'googleapis.dart/discoveryapis_generator/lib/src/base_api_library.dart', 'repo_id': 'googleapis.dart', 'token_count': 374}
|
// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
String requestHeadersField(String? packageVersion) => packageVersion == null
? '''
/// Request headers used by all libraries in this package
final requestHeaders = {
'user-agent': 'google-api-dart-client/unknown',
'x-goog-api-client': 'gl-dart/\${commons.dartVersion}',
};'''
: '''
/// Request headers used by all libraries in this package
final requestHeaders = {
'user-agent': 'google-api-dart-client/$packageVersion',
'x-goog-api-client': 'gl-dart/\${commons.dartVersion} gdcl/$packageVersion',
};''';
|
googleapis.dart/discoveryapis_generator/lib/src/shared_output.dart/0
|
{'file_path': 'googleapis.dart/discoveryapis_generator/lib/src/shared_output.dart', 'repo_id': 'googleapis.dart', 'token_count': 232}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Google Analytics API - v3
///
/// Views and manages your Google Analytics data.
///
/// For more information, see <https://developers.google.com/analytics/>
///
/// Create an instance of [AnalyticsApi] to access these resources:
///
/// - [DataResource]
/// - [DataGaResource]
/// - [DataMcfResource]
/// - [DataRealtimeResource]
/// - [ManagementResource]
/// - [ManagementAccountSummariesResource]
/// - [ManagementAccountUserLinksResource]
/// - [ManagementAccountsResource]
/// - [ManagementClientIdResource]
/// - [ManagementCustomDataSourcesResource]
/// - [ManagementCustomDimensionsResource]
/// - [ManagementCustomMetricsResource]
/// - [ManagementExperimentsResource]
/// - [ManagementFiltersResource]
/// - [ManagementGoalsResource]
/// - [ManagementProfileFilterLinksResource]
/// - [ManagementProfileUserLinksResource]
/// - [ManagementProfilesResource]
/// - [ManagementRemarketingAudienceResource]
/// - [ManagementSegmentsResource]
/// - [ManagementUnsampledReportsResource]
/// - [ManagementUploadsResource]
/// - [ManagementWebPropertyAdWordsLinksResource]
/// - [ManagementWebpropertiesResource]
/// - [ManagementWebpropertyUserLinksResource]
/// - [MetadataResource]
/// - [MetadataColumnsResource]
/// - [ProvisioningResource]
/// - [UserDeletionResource]
/// - [UserDeletionUserDeletionRequestResource]
library analytics_v3;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show
ApiRequestError,
ByteRange,
DetailedApiRequestError,
DownloadOptions,
Media,
PartialDownloadOptions,
ResumableUploadOptions,
UploadOptions;
/// Views and manages your Google Analytics data.
class AnalyticsApi {
/// View and manage your Google Analytics data
static const analyticsScope = 'https://www.googleapis.com/auth/analytics';
/// Edit Google Analytics management entities
static const analyticsEditScope =
'https://www.googleapis.com/auth/analytics.edit';
/// Manage Google Analytics Account users by email address
static const analyticsManageUsersScope =
'https://www.googleapis.com/auth/analytics.manage.users';
/// View Google Analytics user permissions
static const analyticsManageUsersReadonlyScope =
'https://www.googleapis.com/auth/analytics.manage.users.readonly';
/// Create a new Google Analytics account along with its default property and
/// view
static const analyticsProvisionScope =
'https://www.googleapis.com/auth/analytics.provision';
/// View your Google Analytics data
static const analyticsReadonlyScope =
'https://www.googleapis.com/auth/analytics.readonly';
/// Manage Google Analytics user deletion requests
static const analyticsUserDeletionScope =
'https://www.googleapis.com/auth/analytics.user.deletion';
final commons.ApiRequester _requester;
DataResource get data => DataResource(_requester);
ManagementResource get management => ManagementResource(_requester);
MetadataResource get metadata => MetadataResource(_requester);
ProvisioningResource get provisioning => ProvisioningResource(_requester);
UserDeletionResource get userDeletion => UserDeletionResource(_requester);
AnalyticsApi(http.Client client,
{core.String rootUrl = 'https://analytics.googleapis.com/',
core.String servicePath = 'analytics/v3/'})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class DataResource {
final commons.ApiRequester _requester;
DataGaResource get ga => DataGaResource(_requester);
DataMcfResource get mcf => DataMcfResource(_requester);
DataRealtimeResource get realtime => DataRealtimeResource(_requester);
DataResource(commons.ApiRequester client) : _requester = client;
}
class DataGaResource {
final commons.ApiRequester _requester;
DataGaResource(commons.ApiRequester client) : _requester = client;
/// Returns Analytics data for a view (profile).
///
/// Request parameters:
///
/// [ids] - Unique table ID for retrieving Analytics data. Table ID is of the
/// form ga:XXXX, where XXXX is the Analytics view (profile) ID.
/// Value must have pattern `ga:\[0-9\]+`.
///
/// [startDate] - Start date for fetching Analytics data. Requests can specify
/// a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today,
/// yesterday, or 7daysAgo). The default value is 7daysAgo.
/// Value must have pattern
/// `\[0-9\]{4}-\[0-9\]{2}-\[0-9\]{2}|today|yesterday|\[0-9\]+(daysAgo)`.
///
/// [endDate] - End date for fetching Analytics data. Request can should
/// specify an end date formatted as YYYY-MM-DD, or as a relative date (e.g.,
/// today, yesterday, or 7daysAgo). The default value is yesterday.
/// Value must have pattern
/// `\[0-9\]{4}-\[0-9\]{2}-\[0-9\]{2}|today|yesterday|\[0-9\]+(daysAgo)`.
///
/// [metrics] - A comma-separated list of Analytics metrics. E.g.,
/// 'ga:sessions,ga:pageviews'. At least one metric must be specified.
/// Value must have pattern `ga:.+`.
///
/// [dimensions] - A comma-separated list of Analytics dimensions. E.g.,
/// 'ga:browser,ga:city'.
/// Value must have pattern `(ga:.+)?`.
///
/// [filters] - A comma-separated list of dimension or metric filters to be
/// applied to Analytics data.
/// Value must have pattern `ga:.+`.
///
/// [includeEmptyRows] - The response will include empty rows if this
/// parameter is set to true, the default is true
///
/// [maxResults] - The maximum number of entries to include in this feed.
///
/// [output] - The selected format for the response. Default format is JSON.
/// Possible string values are:
/// - "dataTable" : Returns the response in Google Charts Data Table format.
/// This is useful in creating visualization using Google Charts.
/// - "json" : Returns the response in standard JSON format.
///
/// [samplingLevel] - The desired sampling level.
/// Possible string values are:
/// - "DEFAULT" : Returns response with a sample size that balances speed and
/// accuracy.
/// - "FASTER" : Returns a fast response with a smaller sample size.
/// - "HIGHER_PRECISION" : Returns a more accurate response using a large
/// sample size, but this may result in the response being slower.
///
/// [segment] - An Analytics segment to be applied to data.
///
/// [sort] - A comma-separated list of dimensions or metrics that determine
/// the sort order for Analytics data.
/// Value must have pattern `(-)?ga:.+`.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GaData].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GaData> get(
core.String ids,
core.String startDate,
core.String endDate,
core.String metrics, {
core.String? dimensions,
core.String? filters,
core.bool? includeEmptyRows,
core.int? maxResults,
core.String? output,
core.String? samplingLevel,
core.String? segment,
core.String? sort,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
'ids': [ids],
'start-date': [startDate],
'end-date': [endDate],
'metrics': [metrics],
if (dimensions != null) 'dimensions': [dimensions],
if (filters != null) 'filters': [filters],
if (includeEmptyRows != null)
'include-empty-rows': ['${includeEmptyRows}'],
if (maxResults != null) 'max-results': ['${maxResults}'],
if (output != null) 'output': [output],
if (samplingLevel != null) 'samplingLevel': [samplingLevel],
if (segment != null) 'segment': [segment],
if (sort != null) 'sort': [sort],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'data/ga';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return GaData.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class DataMcfResource {
final commons.ApiRequester _requester;
DataMcfResource(commons.ApiRequester client) : _requester = client;
/// Returns Analytics Multi-Channel Funnels data for a view (profile).
///
/// Request parameters:
///
/// [ids] - Unique table ID for retrieving Analytics data. Table ID is of the
/// form ga:XXXX, where XXXX is the Analytics view (profile) ID.
/// Value must have pattern `ga:\[0-9\]+`.
///
/// [startDate] - Start date for fetching Analytics data. Requests can specify
/// a start date formatted as YYYY-MM-DD, or as a relative date (e.g., today,
/// yesterday, or 7daysAgo). The default value is 7daysAgo.
/// Value must have pattern
/// `\[0-9\]{4}-\[0-9\]{2}-\[0-9\]{2}|today|yesterday|\[0-9\]+(daysAgo)`.
///
/// [endDate] - End date for fetching Analytics data. Requests can specify a
/// start date formatted as YYYY-MM-DD, or as a relative date (e.g., today,
/// yesterday, or 7daysAgo). The default value is 7daysAgo.
/// Value must have pattern
/// `\[0-9\]{4}-\[0-9\]{2}-\[0-9\]{2}|today|yesterday|\[0-9\]+(daysAgo)`.
///
/// [metrics] - A comma-separated list of Multi-Channel Funnels metrics. E.g.,
/// 'mcf:totalConversions,mcf:totalConversionValue'. At least one metric must
/// be specified.
/// Value must have pattern `mcf:.+`.
///
/// [dimensions] - A comma-separated list of Multi-Channel Funnels dimensions.
/// E.g., 'mcf:source,mcf:medium'.
/// Value must have pattern `(mcf:.+)?`.
///
/// [filters] - A comma-separated list of dimension or metric filters to be
/// applied to the Analytics data.
/// Value must have pattern `mcf:.+`.
///
/// [maxResults] - The maximum number of entries to include in this feed.
///
/// [samplingLevel] - The desired sampling level.
/// Possible string values are:
/// - "DEFAULT" : Returns response with a sample size that balances speed and
/// accuracy.
/// - "FASTER" : Returns a fast response with a smaller sample size.
/// - "HIGHER_PRECISION" : Returns a more accurate response using a large
/// sample size, but this may result in the response being slower.
///
/// [sort] - A comma-separated list of dimensions or metrics that determine
/// the sort order for the Analytics data.
/// Value must have pattern `(-)?mcf:.+`.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [McfData].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<McfData> get(
core.String ids,
core.String startDate,
core.String endDate,
core.String metrics, {
core.String? dimensions,
core.String? filters,
core.int? maxResults,
core.String? samplingLevel,
core.String? sort,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
'ids': [ids],
'start-date': [startDate],
'end-date': [endDate],
'metrics': [metrics],
if (dimensions != null) 'dimensions': [dimensions],
if (filters != null) 'filters': [filters],
if (maxResults != null) 'max-results': ['${maxResults}'],
if (samplingLevel != null) 'samplingLevel': [samplingLevel],
if (sort != null) 'sort': [sort],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'data/mcf';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return McfData.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class DataRealtimeResource {
final commons.ApiRequester _requester;
DataRealtimeResource(commons.ApiRequester client) : _requester = client;
/// Returns real time data for a view (profile).
///
/// Request parameters:
///
/// [ids] - Unique table ID for retrieving real time data. Table ID is of the
/// form ga:XXXX, where XXXX is the Analytics view (profile) ID.
/// Value must have pattern `ga:\[0-9\]+`.
///
/// [metrics] - A comma-separated list of real time metrics. E.g.,
/// 'rt:activeUsers'. At least one metric must be specified.
/// Value must have pattern `(ga:.+)|(rt:.+)`.
///
/// [dimensions] - A comma-separated list of real time dimensions. E.g.,
/// 'rt:medium,rt:city'.
/// Value must have pattern `(ga:.+)|(rt:.+)`.
///
/// [filters] - A comma-separated list of dimension or metric filters to be
/// applied to real time data.
/// Value must have pattern `(ga:.+)|(rt:.+)`.
///
/// [maxResults] - The maximum number of entries to include in this feed.
///
/// [sort] - A comma-separated list of dimensions or metrics that determine
/// the sort order for real time data.
/// Value must have pattern `(-)?((ga:.+)|(rt:.+))`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RealtimeData].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RealtimeData> get(
core.String ids,
core.String metrics, {
core.String? dimensions,
core.String? filters,
core.int? maxResults,
core.String? sort,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
'ids': [ids],
'metrics': [metrics],
if (dimensions != null) 'dimensions': [dimensions],
if (filters != null) 'filters': [filters],
if (maxResults != null) 'max-results': ['${maxResults}'],
if (sort != null) 'sort': [sort],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'data/realtime';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return RealtimeData.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementResource {
final commons.ApiRequester _requester;
ManagementAccountSummariesResource get accountSummaries =>
ManagementAccountSummariesResource(_requester);
ManagementAccountUserLinksResource get accountUserLinks =>
ManagementAccountUserLinksResource(_requester);
ManagementAccountsResource get accounts =>
ManagementAccountsResource(_requester);
ManagementClientIdResource get clientId =>
ManagementClientIdResource(_requester);
ManagementCustomDataSourcesResource get customDataSources =>
ManagementCustomDataSourcesResource(_requester);
ManagementCustomDimensionsResource get customDimensions =>
ManagementCustomDimensionsResource(_requester);
ManagementCustomMetricsResource get customMetrics =>
ManagementCustomMetricsResource(_requester);
ManagementExperimentsResource get experiments =>
ManagementExperimentsResource(_requester);
ManagementFiltersResource get filters =>
ManagementFiltersResource(_requester);
ManagementGoalsResource get goals => ManagementGoalsResource(_requester);
ManagementProfileFilterLinksResource get profileFilterLinks =>
ManagementProfileFilterLinksResource(_requester);
ManagementProfileUserLinksResource get profileUserLinks =>
ManagementProfileUserLinksResource(_requester);
ManagementProfilesResource get profiles =>
ManagementProfilesResource(_requester);
ManagementRemarketingAudienceResource get remarketingAudience =>
ManagementRemarketingAudienceResource(_requester);
ManagementSegmentsResource get segments =>
ManagementSegmentsResource(_requester);
ManagementUnsampledReportsResource get unsampledReports =>
ManagementUnsampledReportsResource(_requester);
ManagementUploadsResource get uploads =>
ManagementUploadsResource(_requester);
ManagementWebPropertyAdWordsLinksResource get webPropertyAdWordsLinks =>
ManagementWebPropertyAdWordsLinksResource(_requester);
ManagementWebpropertiesResource get webproperties =>
ManagementWebpropertiesResource(_requester);
ManagementWebpropertyUserLinksResource get webpropertyUserLinks =>
ManagementWebpropertyUserLinksResource(_requester);
ManagementResource(commons.ApiRequester client) : _requester = client;
}
class ManagementAccountSummariesResource {
final commons.ApiRequester _requester;
ManagementAccountSummariesResource(commons.ApiRequester client)
: _requester = client;
/// Lists account summaries (lightweight tree comprised of
/// accounts/properties/profiles) to which the user has access.
///
/// Request parameters:
///
/// [maxResults] - The maximum number of account summaries to include in this
/// response, where the largest acceptable value is 1000.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [AccountSummaries].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<AccountSummaries> list({
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'management/accountSummaries';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return AccountSummaries.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementAccountUserLinksResource {
final commons.ApiRequester _requester;
ManagementAccountUserLinksResource(commons.ApiRequester client)
: _requester = client;
/// Removes a user from the given account.
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the user link for.
///
/// [linkId] - Link ID to delete the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String linkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Adds a new user to the given account.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> insert(
EntityUserLink request,
core.String accountId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists account-user links for a given account.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve the user links for.
///
/// [maxResults] - The maximum number of account-user links to include in this
/// response.
///
/// [startIndex] - An index of the first account-user link to retrieve. Use
/// this parameter as a pagination mechanism along with the max-results
/// parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLinks].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLinks> list(
core.String accountId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return EntityUserLinks.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates permissions for an existing user on the given account.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to update the account-user link for.
///
/// [linkId] - Link ID to update the account-user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> update(
EntityUserLink request,
core.String accountId,
core.String linkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementAccountsResource {
final commons.ApiRequester _requester;
ManagementAccountsResource(commons.ApiRequester client) : _requester = client;
/// Lists all accounts to which the user has access.
///
/// Request parameters:
///
/// [maxResults] - The maximum number of accounts to include in this response.
///
/// [startIndex] - An index of the first account to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Accounts].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Accounts> list({
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'management/accounts';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Accounts.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementClientIdResource {
final commons.ApiRequester _requester;
ManagementClientIdResource(commons.ApiRequester client) : _requester = client;
/// Hashes the given Client ID.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [HashClientIdResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<HashClientIdResponse> hashClientId(
HashClientIdRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'management/clientId:hashClientId';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return HashClientIdResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementCustomDataSourcesResource {
final commons.ApiRequester _requester;
ManagementCustomDataSourcesResource(commons.ApiRequester client)
: _requester = client;
/// List custom data sources to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account Id for the custom data sources to retrieve.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id for the custom data sources to retrieve.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [maxResults] - The maximum number of custom data sources to include in
/// this response.
///
/// [startIndex] - A 1-based index of the first custom data source to
/// retrieve. Use this parameter as a pagination mechanism along with the
/// max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDataSources].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDataSources> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return CustomDataSources.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementCustomDimensionsResource {
final commons.ApiRequester _requester;
ManagementCustomDimensionsResource(commons.ApiRequester client)
: _requester = client;
/// Get a custom dimension to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom dimension to retrieve.
///
/// [webPropertyId] - Web property ID for the custom dimension to retrieve.
///
/// [customDimensionId] - The ID of the custom dimension to retrieve.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDimension].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDimension> get(
core.String accountId,
core.String webPropertyId,
core.String customDimensionId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDimensions/' +
commons.escapeVariable('$customDimensionId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return CustomDimension.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new custom dimension.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom dimension to create.
///
/// [webPropertyId] - Web property ID for the custom dimension to create.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDimension].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDimension> insert(
CustomDimension request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDimensions';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return CustomDimension.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists custom dimensions to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom dimensions to retrieve.
///
/// [webPropertyId] - Web property ID for the custom dimensions to retrieve.
///
/// [maxResults] - The maximum number of custom dimensions to include in this
/// response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDimensions].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDimensions> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDimensions';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return CustomDimensions.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing custom dimension.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom dimension to update.
///
/// [webPropertyId] - Web property ID for the custom dimension to update.
///
/// [customDimensionId] - Custom dimension ID for the custom dimension to
/// update.
///
/// [ignoreCustomDataSourceLinks] - Force the update and ignore any warnings
/// related to the custom dimension being linked to a custom data source /
/// data set.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDimension].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDimension> patch(
CustomDimension request,
core.String accountId,
core.String webPropertyId,
core.String customDimensionId, {
core.bool? ignoreCustomDataSourceLinks,
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if (ignoreCustomDataSourceLinks != null)
'ignoreCustomDataSourceLinks': ['${ignoreCustomDataSourceLinks}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDimensions/' +
commons.escapeVariable('$customDimensionId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return CustomDimension.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing custom dimension.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom dimension to update.
///
/// [webPropertyId] - Web property ID for the custom dimension to update.
///
/// [customDimensionId] - Custom dimension ID for the custom dimension to
/// update.
///
/// [ignoreCustomDataSourceLinks] - Force the update and ignore any warnings
/// related to the custom dimension being linked to a custom data source /
/// data set.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomDimension].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomDimension> update(
CustomDimension request,
core.String accountId,
core.String webPropertyId,
core.String customDimensionId, {
core.bool? ignoreCustomDataSourceLinks,
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if (ignoreCustomDataSourceLinks != null)
'ignoreCustomDataSourceLinks': ['${ignoreCustomDataSourceLinks}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDimensions/' +
commons.escapeVariable('$customDimensionId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return CustomDimension.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementCustomMetricsResource {
final commons.ApiRequester _requester;
ManagementCustomMetricsResource(commons.ApiRequester client)
: _requester = client;
/// Get a custom metric to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom metric to retrieve.
///
/// [webPropertyId] - Web property ID for the custom metric to retrieve.
///
/// [customMetricId] - The ID of the custom metric to retrieve.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomMetric].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomMetric> get(
core.String accountId,
core.String webPropertyId,
core.String customMetricId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customMetrics/' +
commons.escapeVariable('$customMetricId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return CustomMetric.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new custom metric.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom metric to create.
///
/// [webPropertyId] - Web property ID for the custom dimension to create.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomMetric].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomMetric> insert(
CustomMetric request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customMetrics';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return CustomMetric.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists custom metrics to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom metrics to retrieve.
///
/// [webPropertyId] - Web property ID for the custom metrics to retrieve.
///
/// [maxResults] - The maximum number of custom metrics to include in this
/// response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomMetrics].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomMetrics> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customMetrics';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return CustomMetrics.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing custom metric.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom metric to update.
///
/// [webPropertyId] - Web property ID for the custom metric to update.
///
/// [customMetricId] - Custom metric ID for the custom metric to update.
///
/// [ignoreCustomDataSourceLinks] - Force the update and ignore any warnings
/// related to the custom metric being linked to a custom data source / data
/// set.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomMetric].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomMetric> patch(
CustomMetric request,
core.String accountId,
core.String webPropertyId,
core.String customMetricId, {
core.bool? ignoreCustomDataSourceLinks,
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if (ignoreCustomDataSourceLinks != null)
'ignoreCustomDataSourceLinks': ['${ignoreCustomDataSourceLinks}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customMetrics/' +
commons.escapeVariable('$customMetricId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return CustomMetric.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing custom metric.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID for the custom metric to update.
///
/// [webPropertyId] - Web property ID for the custom metric to update.
///
/// [customMetricId] - Custom metric ID for the custom metric to update.
///
/// [ignoreCustomDataSourceLinks] - Force the update and ignore any warnings
/// related to the custom metric being linked to a custom data source / data
/// set.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CustomMetric].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CustomMetric> update(
CustomMetric request,
core.String accountId,
core.String webPropertyId,
core.String customMetricId, {
core.bool? ignoreCustomDataSourceLinks,
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if (ignoreCustomDataSourceLinks != null)
'ignoreCustomDataSourceLinks': ['${ignoreCustomDataSourceLinks}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customMetrics/' +
commons.escapeVariable('$customMetricId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return CustomMetric.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementExperimentsResource {
final commons.ApiRequester _requester;
ManagementExperimentsResource(commons.ApiRequester client)
: _requester = client;
/// Delete an experiment.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the experiment belongs
///
/// [webPropertyId] - Web property ID to which the experiment belongs
///
/// [profileId] - View (Profile) ID to which the experiment belongs
///
/// [experimentId] - ID of the experiment to delete
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String experimentId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments/' +
commons.escapeVariable('$experimentId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Returns an experiment to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve the experiment for.
///
/// [webPropertyId] - Web property ID to retrieve the experiment for.
///
/// [profileId] - View (Profile) ID to retrieve the experiment for.
///
/// [experimentId] - Experiment ID to retrieve the experiment for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Experiment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Experiment> get(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String experimentId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments/' +
commons.escapeVariable('$experimentId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Experiment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new experiment.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the experiment for.
///
/// [webPropertyId] - Web property ID to create the experiment for.
///
/// [profileId] - View (Profile) ID to create the experiment for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Experiment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Experiment> insert(
Experiment request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Experiment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists experiments to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve experiments for.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property ID to retrieve experiments for.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - View (Profile) ID to retrieve experiments for.
/// Value must have pattern `\d+`.
///
/// [maxResults] - The maximum number of experiments to include in this
/// response.
///
/// [startIndex] - An index of the first experiment to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Experiments].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Experiments> list(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Experiments.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Update an existing experiment.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID of the experiment to update.
///
/// [webPropertyId] - Web property ID of the experiment to update.
///
/// [profileId] - View (Profile) ID of the experiment to update.
///
/// [experimentId] - Experiment ID of the experiment to update.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Experiment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Experiment> patch(
Experiment request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String experimentId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments/' +
commons.escapeVariable('$experimentId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return Experiment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Update an existing experiment.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID of the experiment to update.
///
/// [webPropertyId] - Web property ID of the experiment to update.
///
/// [profileId] - View (Profile) ID of the experiment to update.
///
/// [experimentId] - Experiment ID of the experiment to update.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Experiment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Experiment> update(
Experiment request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String experimentId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/experiments/' +
commons.escapeVariable('$experimentId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Experiment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementFiltersResource {
final commons.ApiRequester _requester;
ManagementFiltersResource(commons.ApiRequester client) : _requester = client;
/// Delete a filter.
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the filter for.
///
/// [filterId] - ID of the filter to be deleted.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filter].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filter> delete(
core.String accountId,
core.String filterId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters/' +
commons.escapeVariable('$filterId');
final response_ = await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
);
return Filter.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Returns filters to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve filters for.
///
/// [filterId] - Filter ID to retrieve filters for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filter].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filter> get(
core.String accountId,
core.String filterId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters/' +
commons.escapeVariable('$filterId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Filter.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new filter.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create filter for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filter].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filter> insert(
Filter request,
core.String accountId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Filter.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists all filters for an account
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve filters for.
/// Value must have pattern `\d+`.
///
/// [maxResults] - The maximum number of filters to include in this response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filters].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filters> list(
core.String accountId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Filters.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing filter.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the filter belongs.
///
/// [filterId] - ID of the filter to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filter].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filter> patch(
Filter request,
core.String accountId,
core.String filterId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters/' +
commons.escapeVariable('$filterId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return Filter.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing filter.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the filter belongs.
///
/// [filterId] - ID of the filter to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Filter].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Filter> update(
Filter request,
core.String accountId,
core.String filterId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/filters/' +
commons.escapeVariable('$filterId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Filter.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementGoalsResource {
final commons.ApiRequester _requester;
ManagementGoalsResource(commons.ApiRequester client) : _requester = client;
/// Gets a goal to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve the goal for.
///
/// [webPropertyId] - Web property ID to retrieve the goal for.
///
/// [profileId] - View (Profile) ID to retrieve the goal for.
///
/// [goalId] - Goal ID to retrieve the goal for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Goal].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Goal> get(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String goalId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/goals/' +
commons.escapeVariable('$goalId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Goal.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new goal.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the goal for.
///
/// [webPropertyId] - Web property ID to create the goal for.
///
/// [profileId] - View (Profile) ID to create the goal for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Goal].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Goal> insert(
Goal request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/goals';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Goal.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists goals to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve goals for. Can either be a specific
/// account ID or '~all', which refers to all the accounts that user has
/// access to.
///
/// [webPropertyId] - Web property ID to retrieve goals for. Can either be a
/// specific web property ID or '~all', which refers to all the web properties
/// that user has access to.
///
/// [profileId] - View (Profile) ID to retrieve goals for. Can either be a
/// specific view (profile) ID or '~all', which refers to all the views
/// (profiles) that user has access to.
///
/// [maxResults] - The maximum number of goals to include in this response.
///
/// [startIndex] - An index of the first goal to retrieve. Use this parameter
/// as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Goals].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Goals> list(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/goals';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Goals.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing goal.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to update the goal.
///
/// [webPropertyId] - Web property ID to update the goal.
///
/// [profileId] - View (Profile) ID to update the goal.
///
/// [goalId] - Index of the goal to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Goal].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Goal> patch(
Goal request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String goalId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/goals/' +
commons.escapeVariable('$goalId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return Goal.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing goal.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to update the goal.
///
/// [webPropertyId] - Web property ID to update the goal.
///
/// [profileId] - View (Profile) ID to update the goal.
///
/// [goalId] - Index of the goal to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Goal].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Goal> update(
Goal request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String goalId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/goals/' +
commons.escapeVariable('$goalId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Goal.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementProfileFilterLinksResource {
final commons.ApiRequester _requester;
ManagementProfileFilterLinksResource(commons.ApiRequester client)
: _requester = client;
/// Delete a profile filter link.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the profile filter link belongs.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id to which the profile filter link
/// belongs.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - Profile ID to which the filter link belongs.
/// Value must have pattern `\d+`.
///
/// [linkId] - ID of the profile filter link to delete.
/// Value must have pattern `\d+:\d+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks/' +
commons.escapeVariable('$linkId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Returns a single profile filter link.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve profile filter link for.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id to retrieve profile filter link for.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - Profile ID to retrieve filter link for.
/// Value must have pattern `\d+`.
///
/// [linkId] - ID of the profile filter link.
/// Value must have pattern `\d+:\d+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProfileFilterLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProfileFilterLink> get(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ProfileFilterLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new profile filter link.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create profile filter link for.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id to create profile filter link for.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - Profile ID to create filter link for.
/// Value must have pattern `\d+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProfileFilterLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProfileFilterLink> insert(
ProfileFilterLink request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return ProfileFilterLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists all profile filter links for a profile.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve profile filter links for.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id for profile filter links for. Can either
/// be a specific web property ID or '~all', which refers to all the web
/// properties that user has access to.
///
/// [profileId] - Profile ID to retrieve filter links for. Can either be a
/// specific profile ID or '~all', which refers to all the profiles that user
/// has access to.
///
/// [maxResults] - The maximum number of profile filter links to include in
/// this response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProfileFilterLinks].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProfileFilterLinks> list(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ProfileFilterLinks.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Update an existing profile filter link.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which profile filter link belongs.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id to which profile filter link belongs
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - Profile ID to which filter link belongs
/// Value must have pattern `\d+`.
///
/// [linkId] - ID of the profile filter link to be updated.
/// Value must have pattern `\d+:\d+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProfileFilterLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProfileFilterLink> patch(
ProfileFilterLink request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return ProfileFilterLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Update an existing profile filter link.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which profile filter link belongs.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id to which profile filter link belongs
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [profileId] - Profile ID to which filter link belongs
/// Value must have pattern `\d+`.
///
/// [linkId] - ID of the profile filter link to be updated.
/// Value must have pattern `\d+:\d+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProfileFilterLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProfileFilterLink> update(
ProfileFilterLink request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/profileFilterLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return ProfileFilterLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementProfileUserLinksResource {
final commons.ApiRequester _requester;
ManagementProfileUserLinksResource(commons.ApiRequester client)
: _requester = client;
/// Removes a user from the given view (profile).
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the user link for.
///
/// [webPropertyId] - Web Property ID to delete the user link for.
///
/// [profileId] - View (Profile) ID to delete the user link for.
///
/// [linkId] - Link ID to delete the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Adds a new user to the given view (profile).
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the user link for.
///
/// [webPropertyId] - Web Property ID to create the user link for.
///
/// [profileId] - View (Profile) ID to create the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> insert(
EntityUserLink request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists profile-user links for a given view (profile).
///
/// Request parameters:
///
/// [accountId] - Account ID which the given view (profile) belongs to.
///
/// [webPropertyId] - Web Property ID which the given view (profile) belongs
/// to. Can either be a specific web property ID or '~all', which refers to
/// all the web properties that user has access to.
///
/// [profileId] - View (Profile) ID to retrieve the profile-user links for.
/// Can either be a specific profile ID or '~all', which refers to all the
/// profiles that user has access to.
///
/// [maxResults] - The maximum number of profile-user links to include in this
/// response.
///
/// [startIndex] - An index of the first profile-user link to retrieve. Use
/// this parameter as a pagination mechanism along with the max-results
/// parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLinks].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLinks> list(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return EntityUserLinks.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates permissions for an existing user on the given view (profile).
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to update the user link for.
///
/// [webPropertyId] - Web Property ID to update the user link for.
///
/// [profileId] - View (Profile ID) to update the user link for.
///
/// [linkId] - Link ID to update the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> update(
EntityUserLink request,
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String linkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementProfilesResource {
final commons.ApiRequester _requester;
ManagementProfilesResource(commons.ApiRequester client) : _requester = client;
/// Deletes a view (profile).
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the view (profile) for.
///
/// [webPropertyId] - Web property ID to delete the view (profile) for.
///
/// [profileId] - ID of the view (profile) to be deleted.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Gets a view (profile) to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve the view (profile) for.
/// Value must have pattern `\[0-9\]+`.
///
/// [webPropertyId] - Web property ID to retrieve the view (profile) for.
/// Value must have pattern `UA-\[0-9\]+-\[0-9\]+`.
///
/// [profileId] - View (Profile) ID to retrieve the view (profile) for.
/// Value must have pattern `\[0-9\]+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Profile].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Profile> get(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Profile.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new view (profile).
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the view (profile) for.
///
/// [webPropertyId] - Web property ID to create the view (profile) for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Profile].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Profile> insert(
Profile request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Profile.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists views (profiles) to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID for the view (profiles) to retrieve. Can either
/// be a specific account ID or '~all', which refers to all the accounts to
/// which the user has access.
///
/// [webPropertyId] - Web property ID for the views (profiles) to retrieve.
/// Can either be a specific web property ID or '~all', which refers to all
/// the web properties to which the user has access.
///
/// [maxResults] - The maximum number of views (profiles) to include in this
/// response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Profiles].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Profiles> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Profiles.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing view (profile).
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the view (profile) belongs
///
/// [webPropertyId] - Web property ID to which the view (profile) belongs
///
/// [profileId] - ID of the view (profile) to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Profile].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Profile> patch(
Profile request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return Profile.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing view (profile).
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the view (profile) belongs
///
/// [webPropertyId] - Web property ID to which the view (profile) belongs
///
/// [profileId] - ID of the view (profile) to be updated.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Profile].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Profile> update(
Profile request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Profile.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementRemarketingAudienceResource {
final commons.ApiRequester _requester;
ManagementRemarketingAudienceResource(commons.ApiRequester client)
: _requester = client;
/// Delete a remarketing audience.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the remarketing audience belongs.
///
/// [webPropertyId] - Web property ID to which the remarketing audience
/// belongs.
///
/// [remarketingAudienceId] - The ID of the remarketing audience to delete.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String remarketingAudienceId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences/' +
commons.escapeVariable('$remarketingAudienceId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Gets a remarketing audience to which the user has access.
///
/// Request parameters:
///
/// [accountId] - The account ID of the remarketing audience to retrieve.
///
/// [webPropertyId] - The web property ID of the remarketing audience to
/// retrieve.
///
/// [remarketingAudienceId] - The ID of the remarketing audience to retrieve.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RemarketingAudience].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RemarketingAudience> get(
core.String accountId,
core.String webPropertyId,
core.String remarketingAudienceId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences/' +
commons.escapeVariable('$remarketingAudienceId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return RemarketingAudience.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Creates a new remarketing audience.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - The account ID for which to create the remarketing audience.
///
/// [webPropertyId] - Web property ID for which to create the remarketing
/// audience.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RemarketingAudience].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RemarketingAudience> insert(
RemarketingAudience request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return RemarketingAudience.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists remarketing audiences to which the user has access.
///
/// Request parameters:
///
/// [accountId] - The account ID of the remarketing audiences to retrieve.
///
/// [webPropertyId] - The web property ID of the remarketing audiences to
/// retrieve.
///
/// [maxResults] - The maximum number of remarketing audiences to include in
/// this response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [type] - null
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RemarketingAudiences].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RemarketingAudiences> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? type,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if (type != null) 'type': [type],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return RemarketingAudiences.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing remarketing audience.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - The account ID of the remarketing audience to update.
///
/// [webPropertyId] - The web property ID of the remarketing audience to
/// update.
///
/// [remarketingAudienceId] - The ID of the remarketing audience to update.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RemarketingAudience].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RemarketingAudience> patch(
RemarketingAudience request,
core.String accountId,
core.String webPropertyId,
core.String remarketingAudienceId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences/' +
commons.escapeVariable('$remarketingAudienceId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return RemarketingAudience.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing remarketing audience.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - The account ID of the remarketing audience to update.
///
/// [webPropertyId] - The web property ID of the remarketing audience to
/// update.
///
/// [remarketingAudienceId] - The ID of the remarketing audience to update.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [RemarketingAudience].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<RemarketingAudience> update(
RemarketingAudience request,
core.String accountId,
core.String webPropertyId,
core.String remarketingAudienceId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/remarketingAudiences/' +
commons.escapeVariable('$remarketingAudienceId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return RemarketingAudience.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementSegmentsResource {
final commons.ApiRequester _requester;
ManagementSegmentsResource(commons.ApiRequester client) : _requester = client;
/// Lists segments to which the user has access.
///
/// Request parameters:
///
/// [maxResults] - The maximum number of segments to include in this response.
///
/// [startIndex] - An index of the first segment to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Segments].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Segments> list({
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'management/segments';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Segments.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementUnsampledReportsResource {
final commons.ApiRequester _requester;
ManagementUnsampledReportsResource(commons.ApiRequester client)
: _requester = client;
/// Deletes an unsampled report.
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the unsampled report for.
///
/// [webPropertyId] - Web property ID to delete the unsampled reports for.
///
/// [profileId] - View (Profile) ID to delete the unsampled report for.
///
/// [unsampledReportId] - ID of the unsampled report to be deleted.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String unsampledReportId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/unsampledReports/' +
commons.escapeVariable('$unsampledReportId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Returns a single unsampled report.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve unsampled report for.
///
/// [webPropertyId] - Web property ID to retrieve unsampled reports for.
///
/// [profileId] - View (Profile) ID to retrieve unsampled report for.
///
/// [unsampledReportId] - ID of the unsampled report to retrieve.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [UnsampledReport].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<UnsampledReport> get(
core.String accountId,
core.String webPropertyId,
core.String profileId,
core.String unsampledReportId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/unsampledReports/' +
commons.escapeVariable('$unsampledReportId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return UnsampledReport.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new unsampled report.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the unsampled report for.
///
/// [webPropertyId] - Web property ID to create the unsampled report for.
///
/// [profileId] - View (Profile) ID to create the unsampled report for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [UnsampledReport].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<UnsampledReport> insert(
UnsampledReport request,
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/unsampledReports';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return UnsampledReport.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists unsampled reports to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve unsampled reports for. Must be a
/// specific account ID, ~all is not supported.
///
/// [webPropertyId] - Web property ID to retrieve unsampled reports for. Must
/// be a specific web property ID, ~all is not supported.
///
/// [profileId] - View (Profile) ID to retrieve unsampled reports for. Must be
/// a specific view (profile) ID, ~all is not supported.
///
/// [maxResults] - The maximum number of unsampled reports to include in this
/// response.
///
/// [startIndex] - An index of the first unsampled report to retrieve. Use
/// this parameter as a pagination mechanism along with the max-results
/// parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [UnsampledReports].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<UnsampledReports> list(
core.String accountId,
core.String webPropertyId,
core.String profileId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/profiles/' +
commons.escapeVariable('$profileId') +
'/unsampledReports';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return UnsampledReports.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementUploadsResource {
final commons.ApiRequester _requester;
ManagementUploadsResource(commons.ApiRequester client) : _requester = client;
/// Delete data associated with a previous upload.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account Id for the uploads to be deleted.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id for the uploads to be deleted.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [customDataSourceId] - Custom data source Id for the uploads to be
/// deleted.
/// Value must have pattern `.{22}`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> deleteUploadData(
AnalyticsDataimportDeleteUploadDataRequest request,
core.String accountId,
core.String webPropertyId,
core.String customDataSourceId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/deleteUploadData';
await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
downloadOptions: null,
);
}
/// List uploads to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account Id for the upload to retrieve.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id for the upload to retrieve.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [customDataSourceId] - Custom data source Id for upload to retrieve.
/// Value must have pattern `.{22}`.
///
/// [uploadId] - Upload Id to retrieve.
/// Value must have pattern `.{22}`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Upload].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Upload> get(
core.String accountId,
core.String webPropertyId,
core.String customDataSourceId,
core.String uploadId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/uploads/' +
commons.escapeVariable('$uploadId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Upload.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// List uploads to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account Id for the uploads to retrieve.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property Id for the uploads to retrieve.
/// Value must have pattern `UA-(\d+)-(\d+)`.
///
/// [customDataSourceId] - Custom data source Id for uploads to retrieve.
/// Value must have pattern `.{22}`.
///
/// [maxResults] - The maximum number of uploads to include in this response.
///
/// [startIndex] - A 1-based index of the first upload to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Uploads].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Uploads> list(
core.String accountId,
core.String webPropertyId,
core.String customDataSourceId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/uploads';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Uploads.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Upload data for a custom data source.
///
/// Request parameters:
///
/// [accountId] - Account Id associated with the upload.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property UA-string associated with the upload.
/// Value must have pattern `UA-\d+-\d+`.
///
/// [customDataSourceId] - Custom data source Id to which the data being
/// uploaded belongs.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// [uploadMedia] - The media to upload.
///
/// [uploadOptions] - Options for the media upload. Streaming Media without
/// the length being known ahead of time is only supported via resumable
/// uploads.
///
/// Completes with a [Upload].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Upload> uploadData(
core.String accountId,
core.String webPropertyId,
core.String customDataSourceId, {
core.String? $fields,
commons.UploadOptions uploadOptions = commons.UploadOptions.defaultOptions,
commons.Media? uploadMedia,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
core.String url_;
if (uploadMedia == null) {
url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/uploads';
} else if (uploadOptions is commons.ResumableUploadOptions) {
url_ = '/resumable/upload/analytics/v3/management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/uploads';
} else {
url_ = '/upload/analytics/v3/management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/customDataSources/' +
commons.escapeVariable('$customDataSourceId') +
'/uploads';
}
final response_ = await _requester.request(
url_,
'POST',
queryParams: queryParams_,
uploadMedia: uploadMedia,
uploadOptions: uploadOptions,
);
return Upload.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementWebPropertyAdWordsLinksResource {
final commons.ApiRequester _requester;
ManagementWebPropertyAdWordsLinksResource(commons.ApiRequester client)
: _requester = client;
/// Deletes a web property-Google Ads link.
///
/// Request parameters:
///
/// [accountId] - ID of the account which the given web property belongs to.
///
/// [webPropertyId] - Web property ID to delete the Google Ads link for.
///
/// [webPropertyAdWordsLinkId] - Web property Google Ads link ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String webPropertyAdWordsLinkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks/' +
commons.escapeVariable('$webPropertyAdWordsLinkId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Returns a web property-Google Ads link to which the user has access.
///
/// Request parameters:
///
/// [accountId] - ID of the account which the given web property belongs to.
///
/// [webPropertyId] - Web property ID to retrieve the Google Ads link for.
///
/// [webPropertyAdWordsLinkId] - Web property-Google Ads link ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityAdWordsLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityAdWordsLink> get(
core.String accountId,
core.String webPropertyId,
core.String webPropertyAdWordsLinkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks/' +
commons.escapeVariable('$webPropertyAdWordsLinkId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return EntityAdWordsLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Creates a webProperty-Google Ads link.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - ID of the Google Analytics account to create the link for.
///
/// [webPropertyId] - Web property ID to create the link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityAdWordsLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityAdWordsLink> insert(
EntityAdWordsLink request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return EntityAdWordsLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists webProperty-Google Ads links for a given web property.
///
/// Request parameters:
///
/// [accountId] - ID of the account which the given web property belongs to.
/// Value must have pattern `\d+`.
///
/// [webPropertyId] - Web property ID to retrieve the Google Ads links for.
///
/// [maxResults] - The maximum number of webProperty-Google Ads links to
/// include in this response.
///
/// [startIndex] - An index of the first webProperty-Google Ads link to
/// retrieve. Use this parameter as a pagination mechanism along with the
/// max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityAdWordsLinks].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityAdWordsLinks> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return EntityAdWordsLinks.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing webProperty-Google Ads link.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - ID of the account which the given web property belongs to.
///
/// [webPropertyId] - Web property ID to retrieve the Google Ads link for.
///
/// [webPropertyAdWordsLinkId] - Web property-Google Ads link ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityAdWordsLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityAdWordsLink> patch(
EntityAdWordsLink request,
core.String accountId,
core.String webPropertyId,
core.String webPropertyAdWordsLinkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks/' +
commons.escapeVariable('$webPropertyAdWordsLinkId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return EntityAdWordsLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing webProperty-Google Ads link.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - ID of the account which the given web property belongs to.
///
/// [webPropertyId] - Web property ID to retrieve the Google Ads link for.
///
/// [webPropertyAdWordsLinkId] - Web property-Google Ads link ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityAdWordsLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityAdWordsLink> update(
EntityAdWordsLink request,
core.String accountId,
core.String webPropertyId,
core.String webPropertyAdWordsLinkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityAdWordsLinks/' +
commons.escapeVariable('$webPropertyAdWordsLinkId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return EntityAdWordsLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementWebpropertiesResource {
final commons.ApiRequester _requester;
ManagementWebpropertiesResource(commons.ApiRequester client)
: _requester = client;
/// Gets a web property to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve the web property for.
/// Value must have pattern `\[0-9\]+`.
///
/// [webPropertyId] - ID to retrieve the web property for.
/// Value must have pattern `UA-\[0-9\]+-\[0-9\]+`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Webproperty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Webproperty> get(
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Webproperty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Create a new property if the account has fewer than 20 properties.
///
/// Web properties are visible in the Google Analytics interface only if they
/// have at least one profile.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the web property for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Webproperty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Webproperty> insert(
Webproperty request,
core.String accountId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Webproperty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists web properties to which the user has access.
///
/// Request parameters:
///
/// [accountId] - Account ID to retrieve web properties for. Can either be a
/// specific account ID or '~all', which refers to all the accounts that user
/// has access to.
///
/// [maxResults] - The maximum number of web properties to include in this
/// response.
///
/// [startIndex] - An index of the first entity to retrieve. Use this
/// parameter as a pagination mechanism along with the max-results parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Webproperties].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Webproperties> list(
core.String accountId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Webproperties.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing web property.
///
/// This method supports patch semantics.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the web property belongs
///
/// [webPropertyId] - Web property ID
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Webproperty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Webproperty> patch(
Webproperty request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId');
final response_ = await _requester.request(
url_,
'PATCH',
body: body_,
queryParams: queryParams_,
);
return Webproperty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates an existing web property.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to which the web property belongs
///
/// [webPropertyId] - Web property ID
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Webproperty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Webproperty> update(
Webproperty request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Webproperty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ManagementWebpropertyUserLinksResource {
final commons.ApiRequester _requester;
ManagementWebpropertyUserLinksResource(commons.ApiRequester client)
: _requester = client;
/// Removes a user from the given web property.
///
/// Request parameters:
///
/// [accountId] - Account ID to delete the user link for.
///
/// [webPropertyId] - Web Property ID to delete the user link for.
///
/// [linkId] - Link ID to delete the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> delete(
core.String accountId,
core.String webPropertyId,
core.String linkId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Adds a new user to the given web property.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to create the user link for.
///
/// [webPropertyId] - Web Property ID to create the user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> insert(
EntityUserLink request,
core.String accountId,
core.String webPropertyId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists webProperty-user links for a given web property.
///
/// Request parameters:
///
/// [accountId] - Account ID which the given web property belongs to.
///
/// [webPropertyId] - Web Property ID for the webProperty-user links to
/// retrieve. Can either be a specific web property ID or '~all', which refers
/// to all the web properties that user has access to.
///
/// [maxResults] - The maximum number of webProperty-user Links to include in
/// this response.
///
/// [startIndex] - An index of the first webProperty-user link to retrieve.
/// Use this parameter as a pagination mechanism along with the max-results
/// parameter.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLinks].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLinks> list(
core.String accountId,
core.String webPropertyId, {
core.int? maxResults,
core.int? startIndex,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'max-results': ['${maxResults}'],
if (startIndex != null) 'start-index': ['${startIndex}'],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityUserLinks';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return EntityUserLinks.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates permissions for an existing user on the given web property.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [accountId] - Account ID to update the account-user link for.
///
/// [webPropertyId] - Web property ID to update the account-user link for.
///
/// [linkId] - Link ID to update the account-user link for.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EntityUserLink].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EntityUserLink> update(
EntityUserLink request,
core.String accountId,
core.String webPropertyId,
core.String linkId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'management/accounts/' +
commons.escapeVariable('$accountId') +
'/webproperties/' +
commons.escapeVariable('$webPropertyId') +
'/entityUserLinks/' +
commons.escapeVariable('$linkId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return EntityUserLink.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class MetadataResource {
final commons.ApiRequester _requester;
MetadataColumnsResource get columns => MetadataColumnsResource(_requester);
MetadataResource(commons.ApiRequester client) : _requester = client;
}
class MetadataColumnsResource {
final commons.ApiRequester _requester;
MetadataColumnsResource(commons.ApiRequester client) : _requester = client;
/// Lists all columns for a report type
///
/// Request parameters:
///
/// [reportType] - Report type. Allowed Values: 'ga'. Where 'ga' corresponds
/// to the Core Reporting API
/// Value must have pattern `ga`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Columns].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Columns> list(
core.String reportType, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ =
'metadata/' + commons.escapeVariable('$reportType') + '/columns';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Columns.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ProvisioningResource {
final commons.ApiRequester _requester;
ProvisioningResource(commons.ApiRequester client) : _requester = client;
/// Creates an account ticket.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [AccountTicket].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<AccountTicket> createAccountTicket(
AccountTicket request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'provisioning/createAccountTicket';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return AccountTicket.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Provision account.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [AccountTreeResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<AccountTreeResponse> createAccountTree(
AccountTreeRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'provisioning/createAccountTree';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return AccountTreeResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class UserDeletionResource {
final commons.ApiRequester _requester;
UserDeletionUserDeletionRequestResource get userDeletionRequest =>
UserDeletionUserDeletionRequestResource(_requester);
UserDeletionResource(commons.ApiRequester client) : _requester = client;
}
class UserDeletionUserDeletionRequestResource {
final commons.ApiRequester _requester;
UserDeletionUserDeletionRequestResource(commons.ApiRequester client)
: _requester = client;
/// Insert or update a user deletion requests.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [UserDeletionRequest].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<UserDeletionRequest> upsert(
UserDeletionRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'userDeletion/userDeletionRequests:upsert';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return UserDeletionRequest.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
/// Child link for an account entry.
///
/// Points to the list of web properties for this account.
class AccountChildLink {
/// Link to the list of web properties for this account.
core.String? href;
/// Type of the child link.
///
/// Its value is "analytics#webproperties".
core.String? type;
AccountChildLink({
this.href,
this.type,
});
AccountChildLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Permissions the user has for this account.
class AccountPermissions {
/// All the permissions that the user has for this account.
///
/// These include any implied permissions (e.g., EDIT implies VIEW).
core.List<core.String>? effective;
AccountPermissions({
this.effective,
});
AccountPermissions.fromJson(core.Map json_)
: this(
effective: json_.containsKey('effective')
? (json_['effective'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (effective != null) 'effective': effective!,
};
}
/// JSON template for Analytics account entry.
class Account {
/// Child link for an account entry.
///
/// Points to the list of web properties for this account.
AccountChildLink? childLink;
/// Time the account was created.
core.DateTime? created;
/// Account ID.
core.String? id;
/// Resource type for Analytics account.
core.String? kind;
/// Account name.
core.String? name;
/// Permissions the user has for this account.
AccountPermissions? permissions;
/// Link for this account.
core.String? selfLink;
/// Indicates whether this account is starred or not.
core.bool? starred;
/// Time the account was last modified.
core.DateTime? updated;
Account({
this.childLink,
this.created,
this.id,
this.kind,
this.name,
this.permissions,
this.selfLink,
this.starred,
this.updated,
});
Account.fromJson(core.Map json_)
: this(
childLink: json_.containsKey('childLink')
? AccountChildLink.fromJson(
json_['childLink'] as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
permissions: json_.containsKey('permissions')
? AccountPermissions.fromJson(
json_['permissions'] as core.Map<core.String, core.dynamic>)
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (childLink != null) 'childLink': childLink!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (permissions != null) 'permissions': permissions!,
if (selfLink != null) 'selfLink': selfLink!,
if (starred != null) 'starred': starred!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
};
}
/// JSON template for a linked account.
class AccountRef {
/// Link for this account.
core.String? href;
/// Account ID.
core.String? id;
/// Analytics account reference.
core.String? kind;
/// Account name.
core.String? name;
AccountRef({
this.href,
this.id,
this.kind,
this.name,
});
AccountRef.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
};
}
/// An AccountSummary collection lists a summary of accounts, properties and
/// views (profiles) to which the user has access.
///
/// Each resource in the collection corresponds to a single AccountSummary.
class AccountSummaries {
/// A list of AccountSummaries.
core.List<AccountSummary>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this AccountSummary collection.
core.String? nextLink;
/// Link to previous page for this AccountSummary collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
AccountSummaries({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
AccountSummaries.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => AccountSummary.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// JSON template for an Analytics AccountSummary.
///
/// An AccountSummary is a lightweight tree comprised of properties/profiles.
class AccountSummary {
/// Account ID.
core.String? id;
/// Resource type for Analytics AccountSummary.
core.String? kind;
/// Account name.
core.String? name;
/// Indicates whether this account is starred or not.
core.bool? starred;
/// List of web properties under this account.
core.List<WebPropertySummary>? webProperties;
AccountSummary({
this.id,
this.kind,
this.name,
this.starred,
this.webProperties,
});
AccountSummary.fromJson(core.Map json_)
: this(
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
webProperties: json_.containsKey('webProperties')
? (json_['webProperties'] as core.List)
.map((value) => WebPropertySummary.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (starred != null) 'starred': starred!,
if (webProperties != null) 'webProperties': webProperties!,
};
}
/// JSON template for an Analytics account ticket.
///
/// The account ticket consists of the ticket ID and the basic information for
/// the account, property and profile.
class AccountTicket {
/// Account for this ticket.
Account? account;
/// Account ticket ID used to access the account ticket.
core.String? id;
/// Resource type for account ticket.
core.String? kind;
/// View (Profile) for the account.
Profile? profile;
/// Redirect URI where the user will be sent after accepting Terms of Service.
///
/// Must be configured in APIs console as a callback URL.
core.String? redirectUri;
/// Web property for the account.
Webproperty? webproperty;
AccountTicket({
this.account,
this.id,
this.kind,
this.profile,
this.redirectUri,
this.webproperty,
});
AccountTicket.fromJson(core.Map json_)
: this(
account: json_.containsKey('account')
? Account.fromJson(
json_['account'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profile: json_.containsKey('profile')
? Profile.fromJson(
json_['profile'] as core.Map<core.String, core.dynamic>)
: null,
redirectUri: json_.containsKey('redirectUri')
? json_['redirectUri'] as core.String
: null,
webproperty: json_.containsKey('webproperty')
? Webproperty.fromJson(
json_['webproperty'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (account != null) 'account': account!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (profile != null) 'profile': profile!,
if (redirectUri != null) 'redirectUri': redirectUri!,
if (webproperty != null) 'webproperty': webproperty!,
};
}
/// JSON template for an Analytics account tree requests.
///
/// The account tree request is used in the provisioning api to create an
/// account, property, and view (profile). It contains the basic information
/// required to make these fields.
class AccountTreeRequest {
core.String? accountName;
/// Resource type for account ticket.
core.String? kind;
core.String? profileName;
core.String? timezone;
core.String? webpropertyName;
core.String? websiteUrl;
AccountTreeRequest({
this.accountName,
this.kind,
this.profileName,
this.timezone,
this.webpropertyName,
this.websiteUrl,
});
AccountTreeRequest.fromJson(core.Map json_)
: this(
accountName: json_.containsKey('accountName')
? json_['accountName'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profileName: json_.containsKey('profileName')
? json_['profileName'] as core.String
: null,
timezone: json_.containsKey('timezone')
? json_['timezone'] as core.String
: null,
webpropertyName: json_.containsKey('webpropertyName')
? json_['webpropertyName'] as core.String
: null,
websiteUrl: json_.containsKey('websiteUrl')
? json_['websiteUrl'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountName != null) 'accountName': accountName!,
if (kind != null) 'kind': kind!,
if (profileName != null) 'profileName': profileName!,
if (timezone != null) 'timezone': timezone!,
if (webpropertyName != null) 'webpropertyName': webpropertyName!,
if (websiteUrl != null) 'websiteUrl': websiteUrl!,
};
}
/// JSON template for an Analytics account tree response.
///
/// The account tree response is used in the provisioning api to return the
/// result of creating an account, property, and view (profile).
class AccountTreeResponse {
/// The account created.
Account? account;
/// Resource type for account ticket.
core.String? kind;
/// View (Profile) for the account.
Profile? profile;
/// Web property for the account.
Webproperty? webproperty;
AccountTreeResponse({
this.account,
this.kind,
this.profile,
this.webproperty,
});
AccountTreeResponse.fromJson(core.Map json_)
: this(
account: json_.containsKey('account')
? Account.fromJson(
json_['account'] as core.Map<core.String, core.dynamic>)
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profile: json_.containsKey('profile')
? Profile.fromJson(
json_['profile'] as core.Map<core.String, core.dynamic>)
: null,
webproperty: json_.containsKey('webproperty')
? Webproperty.fromJson(
json_['webproperty'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (account != null) 'account': account!,
if (kind != null) 'kind': kind!,
if (profile != null) 'profile': profile!,
if (webproperty != null) 'webproperty': webproperty!,
};
}
/// An account collection provides a list of Analytics accounts to which a user
/// has access.
///
/// The account collection is the entry point to all management information.
/// Each resource in the collection corresponds to a single Analytics account.
class Accounts {
/// A list of accounts.
core.List<Account>? items;
/// The maximum number of entries the response can contain, regardless of the
/// actual number of entries returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Next link for this account collection.
core.String? nextLink;
/// Previous link for this account collection.
core.String? previousLink;
/// The starting index of the entries, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Accounts({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Accounts.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Account.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// JSON template for an Google Ads account.
class AdWordsAccount {
/// True if auto-tagging is enabled on the Google Ads account.
///
/// Read-only after the insert operation.
core.bool? autoTaggingEnabled;
/// Customer ID.
///
/// This field is required when creating a Google Ads link.
core.String? customerId;
/// Resource type for Google Ads account.
core.String? kind;
AdWordsAccount({
this.autoTaggingEnabled,
this.customerId,
this.kind,
});
AdWordsAccount.fromJson(core.Map json_)
: this(
autoTaggingEnabled: json_.containsKey('autoTaggingEnabled')
? json_['autoTaggingEnabled'] as core.bool
: null,
customerId: json_.containsKey('customerId')
? json_['customerId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (autoTaggingEnabled != null)
'autoTaggingEnabled': autoTaggingEnabled!,
if (customerId != null) 'customerId': customerId!,
if (kind != null) 'kind': kind!,
};
}
/// Request template for the delete upload data request.
class AnalyticsDataimportDeleteUploadDataRequest {
/// A list of upload UIDs.
core.List<core.String>? customDataImportUids;
AnalyticsDataimportDeleteUploadDataRequest({
this.customDataImportUids,
});
AnalyticsDataimportDeleteUploadDataRequest.fromJson(core.Map json_)
: this(
customDataImportUids: json_.containsKey('customDataImportUids')
? (json_['customDataImportUids'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (customDataImportUids != null)
'customDataImportUids': customDataImportUids!,
};
}
/// JSON template for a metadata column.
class Column {
/// Map of attribute name and value for this column.
core.Map<core.String, core.String>? attributes;
/// Column id.
core.String? id;
/// Resource type for Analytics column.
core.String? kind;
Column({
this.attributes,
this.id,
this.kind,
});
Column.fromJson(core.Map json_)
: this(
attributes: json_.containsKey('attributes')
? (json_['attributes'] as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (attributes != null) 'attributes': attributes!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
};
}
/// Lists columns (dimensions and metrics) for a particular report type.
class Columns {
/// List of attributes names returned by columns.
core.List<core.String>? attributeNames;
/// Etag of collection.
///
/// This etag can be compared with the last response etag to check if response
/// has changed.
core.String? etag;
/// List of columns for a report type.
core.List<Column>? items;
/// Collection type.
core.String? kind;
/// Total number of columns returned in the response.
core.int? totalResults;
Columns({
this.attributeNames,
this.etag,
this.items,
this.kind,
this.totalResults,
});
Columns.fromJson(core.Map json_)
: this(
attributeNames: json_.containsKey('attributeNames')
? (json_['attributeNames'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
etag: json_.containsKey('etag') ? json_['etag'] as core.String : null,
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Column.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (attributeNames != null) 'attributeNames': attributeNames!,
if (etag != null) 'etag': etag!,
if (items != null) 'items': items!,
if (kind != null) 'kind': kind!,
if (totalResults != null) 'totalResults': totalResults!,
};
}
class CustomDataSourceChildLink {
/// Link to the list of daily uploads for this custom data source.
///
/// Link to the list of uploads for this custom data source.
core.String? href;
/// Value is "analytics#dailyUploads".
///
/// Value is "analytics#uploads".
core.String? type;
CustomDataSourceChildLink({
this.href,
this.type,
});
CustomDataSourceChildLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Parent link for this custom data source.
///
/// Points to the web property to which this custom data source belongs.
class CustomDataSourceParentLink {
/// Link to the web property to which this custom data source belongs.
core.String? href;
/// Value is "analytics#webproperty".
core.String? type;
CustomDataSourceParentLink({
this.href,
this.type,
});
CustomDataSourceParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// JSON template for an Analytics custom data source.
class CustomDataSource {
/// Account ID to which this custom data source belongs.
core.String? accountId;
CustomDataSourceChildLink? childLink;
/// Time this custom data source was created.
core.DateTime? created;
/// Description of custom data source.
core.String? description;
/// Custom data source ID.
core.String? id;
core.String? importBehavior;
/// Resource type for Analytics custom data source.
core.String? kind;
/// Name of this custom data source.
core.String? name;
/// Parent link for this custom data source.
///
/// Points to the web property to which this custom data source belongs.
CustomDataSourceParentLink? parentLink;
/// IDs of views (profiles) linked to the custom data source.
core.List<core.String>? profilesLinked;
/// Collection of schema headers of the custom data source.
core.List<core.String>? schema;
/// Link for this Analytics custom data source.
core.String? selfLink;
/// Type of the custom data source.
core.String? type;
/// Time this custom data source was last modified.
core.DateTime? updated;
/// Upload type of the custom data source.
core.String? uploadType;
/// Web property ID of the form UA-XXXXX-YY to which this custom data source
/// belongs.
core.String? webPropertyId;
CustomDataSource({
this.accountId,
this.childLink,
this.created,
this.description,
this.id,
this.importBehavior,
this.kind,
this.name,
this.parentLink,
this.profilesLinked,
this.schema,
this.selfLink,
this.type,
this.updated,
this.uploadType,
this.webPropertyId,
});
CustomDataSource.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
childLink: json_.containsKey('childLink')
? CustomDataSourceChildLink.fromJson(
json_['childLink'] as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
importBehavior: json_.containsKey('importBehavior')
? json_['importBehavior'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? CustomDataSourceParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
profilesLinked: json_.containsKey('profilesLinked')
? (json_['profilesLinked'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
schema: json_.containsKey('schema')
? (json_['schema'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
uploadType: json_.containsKey('uploadType')
? json_['uploadType'] as core.String
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (childLink != null) 'childLink': childLink!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (description != null) 'description': description!,
if (id != null) 'id': id!,
if (importBehavior != null) 'importBehavior': importBehavior!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (profilesLinked != null) 'profilesLinked': profilesLinked!,
if (schema != null) 'schema': schema!,
if (selfLink != null) 'selfLink': selfLink!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (uploadType != null) 'uploadType': uploadType!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// Lists Analytics custom data sources to which the user has access.
///
/// Each resource in the collection corresponds to a single Analytics custom
/// data source.
class CustomDataSources {
/// Collection of custom data sources.
core.List<CustomDataSource>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this custom data source collection.
core.String? nextLink;
/// Link to previous page for this custom data source collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
CustomDataSources({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
CustomDataSources.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => CustomDataSource.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Parent link for the custom dimension.
///
/// Points to the property to which the custom dimension belongs.
class CustomDimensionParentLink {
/// Link to the property to which the custom dimension belongs.
core.String? href;
/// Type of the parent link.
///
/// Set to "analytics#webproperty".
core.String? type;
CustomDimensionParentLink({
this.href,
this.type,
});
CustomDimensionParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// JSON template for Analytics Custom Dimension.
class CustomDimension {
/// Account ID.
core.String? accountId;
/// Boolean indicating whether the custom dimension is active.
core.bool? active;
/// Time the custom dimension was created.
core.DateTime? created;
/// Custom dimension ID.
core.String? id;
/// Index of the custom dimension.
core.int? index;
/// Kind value for a custom dimension.
///
/// Set to "analytics#customDimension". It is a read-only field.
core.String? kind;
/// Name of the custom dimension.
core.String? name;
/// Parent link for the custom dimension.
///
/// Points to the property to which the custom dimension belongs.
CustomDimensionParentLink? parentLink;
/// Scope of the custom dimension: HIT, SESSION, USER or PRODUCT.
core.String? scope;
/// Link for the custom dimension
core.String? selfLink;
/// Time the custom dimension was last modified.
core.DateTime? updated;
/// Property ID.
core.String? webPropertyId;
CustomDimension({
this.accountId,
this.active,
this.created,
this.id,
this.index,
this.kind,
this.name,
this.parentLink,
this.scope,
this.selfLink,
this.updated,
this.webPropertyId,
});
CustomDimension.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
active:
json_.containsKey('active') ? json_['active'] as core.bool : null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
index: json_.containsKey('index') ? json_['index'] as core.int : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? CustomDimensionParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
scope:
json_.containsKey('scope') ? json_['scope'] as core.String : null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (active != null) 'active': active!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (id != null) 'id': id!,
if (index != null) 'index': index!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (scope != null) 'scope': scope!,
if (selfLink != null) 'selfLink': selfLink!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// A custom dimension collection lists Analytics custom dimensions to which the
/// user has access.
///
/// Each resource in the collection corresponds to a single Analytics custom
/// dimension.
class CustomDimensions {
/// Collection of custom dimensions.
core.List<CustomDimension>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this custom dimension collection.
core.String? nextLink;
/// Link to previous page for this custom dimension collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
CustomDimensions({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
CustomDimensions.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => CustomDimension.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Parent link for the custom metric.
///
/// Points to the property to which the custom metric belongs.
class CustomMetricParentLink {
/// Link to the property to which the custom metric belongs.
core.String? href;
/// Type of the parent link.
///
/// Set to "analytics#webproperty".
core.String? type;
CustomMetricParentLink({
this.href,
this.type,
});
CustomMetricParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// JSON template for Analytics Custom Metric.
class CustomMetric {
/// Account ID.
core.String? accountId;
/// Boolean indicating whether the custom metric is active.
core.bool? active;
/// Time the custom metric was created.
core.DateTime? created;
/// Custom metric ID.
core.String? id;
/// Index of the custom metric.
core.int? index;
/// Kind value for a custom metric.
///
/// Set to "analytics#customMetric". It is a read-only field.
core.String? kind;
/// Max value of custom metric.
core.String? maxValue;
/// Min value of custom metric.
core.String? minValue;
/// Name of the custom metric.
core.String? name;
/// Parent link for the custom metric.
///
/// Points to the property to which the custom metric belongs.
CustomMetricParentLink? parentLink;
/// Scope of the custom metric: HIT or PRODUCT.
core.String? scope;
/// Link for the custom metric
core.String? selfLink;
/// Data type of custom metric.
core.String? type;
/// Time the custom metric was last modified.
core.DateTime? updated;
/// Property ID.
core.String? webPropertyId;
CustomMetric({
this.accountId,
this.active,
this.created,
this.id,
this.index,
this.kind,
this.maxValue,
this.minValue,
this.name,
this.parentLink,
this.scope,
this.selfLink,
this.type,
this.updated,
this.webPropertyId,
});
CustomMetric.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
active:
json_.containsKey('active') ? json_['active'] as core.bool : null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
index: json_.containsKey('index') ? json_['index'] as core.int : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
maxValue: json_.containsKey('max_value')
? json_['max_value'] as core.String
: null,
minValue: json_.containsKey('min_value')
? json_['min_value'] as core.String
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? CustomMetricParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
scope:
json_.containsKey('scope') ? json_['scope'] as core.String : null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (active != null) 'active': active!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (id != null) 'id': id!,
if (index != null) 'index': index!,
if (kind != null) 'kind': kind!,
if (maxValue != null) 'max_value': maxValue!,
if (minValue != null) 'min_value': minValue!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (scope != null) 'scope': scope!,
if (selfLink != null) 'selfLink': selfLink!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// A custom metric collection lists Analytics custom metrics to which the user
/// has access.
///
/// Each resource in the collection corresponds to a single Analytics custom
/// metric.
class CustomMetrics {
/// Collection of custom metrics.
core.List<CustomMetric>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this custom metric collection.
core.String? nextLink;
/// Link to previous page for this custom metric collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
CustomMetrics({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
CustomMetrics.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => CustomMetric.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Web property being linked.
class EntityAdWordsLinkEntity {
WebPropertyRef? webPropertyRef;
EntityAdWordsLinkEntity({
this.webPropertyRef,
});
EntityAdWordsLinkEntity.fromJson(core.Map json_)
: this(
webPropertyRef: json_.containsKey('webPropertyRef')
? WebPropertyRef.fromJson(json_['webPropertyRef']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (webPropertyRef != null) 'webPropertyRef': webPropertyRef!,
};
}
/// JSON template for Analytics Entity Google Ads Link.
class EntityAdWordsLink {
/// A list of Google Ads client accounts.
///
/// These cannot be MCC accounts. This field is required when creating a
/// Google Ads link. It cannot be empty.
core.List<AdWordsAccount>? adWordsAccounts;
/// Web property being linked.
EntityAdWordsLinkEntity? entity;
/// Entity Google Ads link ID
core.String? id;
/// Resource type for entity Google Ads link.
core.String? kind;
/// Name of the link.
///
/// This field is required when creating a Google Ads link.
core.String? name;
/// IDs of linked Views (Profiles) represented as strings.
core.List<core.String>? profileIds;
/// URL link for this Google Analytics - Google Ads link.
core.String? selfLink;
EntityAdWordsLink({
this.adWordsAccounts,
this.entity,
this.id,
this.kind,
this.name,
this.profileIds,
this.selfLink,
});
EntityAdWordsLink.fromJson(core.Map json_)
: this(
adWordsAccounts: json_.containsKey('adWordsAccounts')
? (json_['adWordsAccounts'] as core.List)
.map((value) => AdWordsAccount.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
entity: json_.containsKey('entity')
? EntityAdWordsLinkEntity.fromJson(
json_['entity'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
profileIds: json_.containsKey('profileIds')
? (json_['profileIds'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (adWordsAccounts != null) 'adWordsAccounts': adWordsAccounts!,
if (entity != null) 'entity': entity!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (profileIds != null) 'profileIds': profileIds!,
if (selfLink != null) 'selfLink': selfLink!,
};
}
/// An entity Google Ads link collection provides a list of GA-Google Ads links
/// Each resource in this collection corresponds to a single link.
class EntityAdWordsLinks {
/// A list of entity Google Ads links.
core.List<EntityAdWordsLink>? items;
/// The maximum number of entries the response can contain, regardless of the
/// actual number of entries returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Next link for this Google Ads link collection.
core.String? nextLink;
/// Previous link for this Google Ads link collection.
core.String? previousLink;
/// The starting index of the entries, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
EntityAdWordsLinks({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
});
EntityAdWordsLinks.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => EntityAdWordsLink.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
};
}
/// Entity for this link.
///
/// It can be an account, a web property, or a view (profile).
class EntityUserLinkEntity {
/// Account for this link.
AccountRef? accountRef;
/// View (Profile) for this link.
ProfileRef? profileRef;
/// Web property for this link.
WebPropertyRef? webPropertyRef;
EntityUserLinkEntity({
this.accountRef,
this.profileRef,
this.webPropertyRef,
});
EntityUserLinkEntity.fromJson(core.Map json_)
: this(
accountRef: json_.containsKey('accountRef')
? AccountRef.fromJson(
json_['accountRef'] as core.Map<core.String, core.dynamic>)
: null,
profileRef: json_.containsKey('profileRef')
? ProfileRef.fromJson(
json_['profileRef'] as core.Map<core.String, core.dynamic>)
: null,
webPropertyRef: json_.containsKey('webPropertyRef')
? WebPropertyRef.fromJson(json_['webPropertyRef']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountRef != null) 'accountRef': accountRef!,
if (profileRef != null) 'profileRef': profileRef!,
if (webPropertyRef != null) 'webPropertyRef': webPropertyRef!,
};
}
/// Permissions the user has for this entity.
class EntityUserLinkPermissions {
/// Effective permissions represent all the permissions that a user has for
/// this entity.
///
/// These include any implied permissions (e.g., EDIT implies VIEW) or
/// inherited permissions from the parent entity. Effective permissions are
/// read-only.
core.List<core.String>? effective;
/// Permissions that a user has been assigned at this very level.
///
/// Does not include any implied or inherited permissions. Local permissions
/// are modifiable.
core.List<core.String>? local;
EntityUserLinkPermissions({
this.effective,
this.local,
});
EntityUserLinkPermissions.fromJson(core.Map json_)
: this(
effective: json_.containsKey('effective')
? (json_['effective'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
local: json_.containsKey('local')
? (json_['local'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (effective != null) 'effective': effective!,
if (local != null) 'local': local!,
};
}
/// JSON template for an Analytics Entity-User Link.
///
/// Returns permissions that a user has for an entity.
class EntityUserLink {
/// Entity for this link.
///
/// It can be an account, a web property, or a view (profile).
EntityUserLinkEntity? entity;
/// Entity user link ID
core.String? id;
/// Resource type for entity user link.
core.String? kind;
/// Permissions the user has for this entity.
EntityUserLinkPermissions? permissions;
/// Self link for this resource.
core.String? selfLink;
/// User reference.
UserRef? userRef;
EntityUserLink({
this.entity,
this.id,
this.kind,
this.permissions,
this.selfLink,
this.userRef,
});
EntityUserLink.fromJson(core.Map json_)
: this(
entity: json_.containsKey('entity')
? EntityUserLinkEntity.fromJson(
json_['entity'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
permissions: json_.containsKey('permissions')
? EntityUserLinkPermissions.fromJson(
json_['permissions'] as core.Map<core.String, core.dynamic>)
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
userRef: json_.containsKey('userRef')
? UserRef.fromJson(
json_['userRef'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (entity != null) 'entity': entity!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (permissions != null) 'permissions': permissions!,
if (selfLink != null) 'selfLink': selfLink!,
if (userRef != null) 'userRef': userRef!,
};
}
/// An entity user link collection provides a list of Analytics ACL links Each
/// resource in this collection corresponds to a single link.
class EntityUserLinks {
/// A list of entity user links.
core.List<EntityUserLink>? items;
/// The maximum number of entries the response can contain, regardless of the
/// actual number of entries returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Next link for this account collection.
core.String? nextLink;
/// Previous link for this account collection.
core.String? previousLink;
/// The starting index of the entries, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
EntityUserLinks({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
});
EntityUserLinks.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => EntityUserLink.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
};
}
/// Parent link for an experiment.
///
/// Points to the view (profile) to which this experiment belongs.
class ExperimentParentLink {
/// Link to the view (profile) to which this experiment belongs.
///
/// This field is read-only.
core.String? href;
/// Value is "analytics#profile".
///
/// This field is read-only.
core.String? type;
ExperimentParentLink({
this.href,
this.type,
});
ExperimentParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
class ExperimentVariations {
/// The name of the variation.
///
/// This field is required when creating an experiment. This field may not be
/// changed for an experiment whose status is ENDED.
core.String? name;
/// Status of the variation.
///
/// Possible values: "ACTIVE", "INACTIVE". INACTIVE variations are not served.
/// This field may not be changed for an experiment whose status is ENDED.
core.String? status;
/// The URL of the variation.
///
/// This field may not be changed for an experiment whose status is RUNNING or
/// ENDED.
core.String? url;
/// Weight that this variation should receive.
///
/// Only present if the experiment is running. This field is read-only.
core.double? weight;
/// True if the experiment has ended and this variation performed
/// (statistically) significantly better than the original.
///
/// This field is read-only.
core.bool? won;
ExperimentVariations({
this.name,
this.status,
this.url,
this.weight,
this.won,
});
ExperimentVariations.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
status: json_.containsKey('status')
? json_['status'] as core.String
: null,
url: json_.containsKey('url') ? json_['url'] as core.String : null,
weight: json_.containsKey('weight')
? (json_['weight'] as core.num).toDouble()
: null,
won: json_.containsKey('won') ? json_['won'] as core.bool : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (status != null) 'status': status!,
if (url != null) 'url': url!,
if (weight != null) 'weight': weight!,
if (won != null) 'won': won!,
};
}
/// JSON template for Analytics experiment resource.
class Experiment {
/// Account ID to which this experiment belongs.
///
/// This field is read-only.
core.String? accountId;
/// Time the experiment was created.
///
/// This field is read-only.
core.DateTime? created;
/// Notes about this experiment.
core.String? description;
/// If true, the end user will be able to edit the experiment via the Google
/// Analytics user interface.
core.bool? editableInGaUi;
/// The ending time of the experiment (the time the status changed from
/// RUNNING to ENDED).
///
/// This field is present only if the experiment has ended. This field is
/// read-only.
core.DateTime? endTime;
/// Boolean specifying whether to distribute traffic evenly across all
/// variations.
///
/// If the value is False, content experiments follows the default behavior of
/// adjusting traffic dynamically based on variation performance. Optional --
/// defaults to False. This field may not be changed for an experiment whose
/// status is ENDED.
core.bool? equalWeighting;
/// Experiment ID.
///
/// Required for patch and update. Disallowed for create.
core.String? id;
/// Internal ID for the web property to which this experiment belongs.
///
/// This field is read-only.
core.String? internalWebPropertyId;
/// Resource type for an Analytics experiment.
///
/// This field is read-only.
core.String? kind;
/// An integer number in \[3, 90\].
///
/// Specifies the minimum length of the experiment. Can be changed for a
/// running experiment. This field may not be changed for an experiments whose
/// status is ENDED.
core.int? minimumExperimentLengthInDays;
/// Experiment name.
///
/// This field may not be changed for an experiment whose status is ENDED.
/// This field is required when creating an experiment.
core.String? name;
/// The metric that the experiment is optimizing.
///
/// Valid values: "ga:goal(n)Completions", "ga:adsenseAdsClicks",
/// "ga:adsenseAdsViewed", "ga:adsenseRevenue", "ga:bounces", "ga:pageviews",
/// "ga:sessionDuration", "ga:transactions", "ga:transactionRevenue". This
/// field is required if status is "RUNNING" and servingFramework is one of
/// "REDIRECT" or "API".
core.String? objectiveMetric;
/// Whether the objectiveMetric should be minimized or maximized.
///
/// Possible values: "MAXIMUM", "MINIMUM". Optional--defaults to "MAXIMUM".
/// Cannot be specified without objectiveMetric. Cannot be modified when
/// status is "RUNNING" or "ENDED".
core.String? optimizationType;
/// Parent link for an experiment.
///
/// Points to the view (profile) to which this experiment belongs.
ExperimentParentLink? parentLink;
/// View (Profile) ID to which this experiment belongs.
///
/// This field is read-only.
core.String? profileId;
/// Why the experiment ended.
///
/// Possible values: "STOPPED_BY_USER", "WINNER_FOUND", "EXPERIMENT_EXPIRED",
/// "ENDED_WITH_NO_WINNER", "GOAL_OBJECTIVE_CHANGED". "ENDED_WITH_NO_WINNER"
/// means that the experiment didn't expire but no winner was projected to be
/// found. If the experiment status is changed via the API to ENDED this field
/// is set to STOPPED_BY_USER. This field is read-only.
core.String? reasonExperimentEnded;
/// Boolean specifying whether variations URLS are rewritten to match those of
/// the original.
///
/// This field may not be changed for an experiments whose status is ENDED.
core.bool? rewriteVariationUrlsAsOriginal;
/// Link for this experiment.
///
/// This field is read-only.
core.String? selfLink;
/// The framework used to serve the experiment variations and evaluate the
/// results.
///
/// One of:
/// - REDIRECT: Google Analytics redirects traffic to different variation
/// pages, reports the chosen variation and evaluates the results.
/// - API: Google Analytics chooses and reports the variation to serve and
/// evaluates the results; the caller is responsible for serving the selected
/// variation.
/// - EXTERNAL: The variations will be served externally and the chosen
/// variation reported to Google Analytics. The caller is responsible for
/// serving the selected variation and evaluating the results.
core.String? servingFramework;
/// The snippet of code to include on the control page(s).
///
/// This field is read-only.
core.String? snippet;
/// The starting time of the experiment (the time the status changed from
/// READY_TO_RUN to RUNNING).
///
/// This field is present only if the experiment has started. This field is
/// read-only.
core.DateTime? startTime;
/// Experiment status.
///
/// Possible values: "DRAFT", "READY_TO_RUN", "RUNNING", "ENDED". Experiments
/// can be created in the "DRAFT", "READY_TO_RUN" or "RUNNING" state. This
/// field is required when creating an experiment.
core.String? status;
/// A floating-point number in (0, 1\].
///
/// Specifies the fraction of the traffic that participates in the experiment.
/// Can be changed for a running experiment. This field may not be changed for
/// an experiments whose status is ENDED.
core.double? trafficCoverage;
/// Time the experiment was last modified.
///
/// This field is read-only.
core.DateTime? updated;
/// Array of variations.
///
/// The first variation in the array is the original. The number of variations
/// may not change once an experiment is in the RUNNING state. At least two
/// variations are required before status can be set to RUNNING.
core.List<ExperimentVariations>? variations;
/// Web property ID to which this experiment belongs.
///
/// The web property ID is of the form UA-XXXXX-YY. This field is read-only.
core.String? webPropertyId;
/// A floating-point number in (0, 1).
///
/// Specifies the necessary confidence level to choose a winner. This field
/// may not be changed for an experiments whose status is ENDED.
core.double? winnerConfidenceLevel;
/// Boolean specifying whether a winner has been found for this experiment.
///
/// This field is read-only.
core.bool? winnerFound;
Experiment({
this.accountId,
this.created,
this.description,
this.editableInGaUi,
this.endTime,
this.equalWeighting,
this.id,
this.internalWebPropertyId,
this.kind,
this.minimumExperimentLengthInDays,
this.name,
this.objectiveMetric,
this.optimizationType,
this.parentLink,
this.profileId,
this.reasonExperimentEnded,
this.rewriteVariationUrlsAsOriginal,
this.selfLink,
this.servingFramework,
this.snippet,
this.startTime,
this.status,
this.trafficCoverage,
this.updated,
this.variations,
this.webPropertyId,
this.winnerConfidenceLevel,
this.winnerFound,
});
Experiment.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
editableInGaUi: json_.containsKey('editableInGaUi')
? json_['editableInGaUi'] as core.bool
: null,
endTime: json_.containsKey('endTime')
? core.DateTime.parse(json_['endTime'] as core.String)
: null,
equalWeighting: json_.containsKey('equalWeighting')
? json_['equalWeighting'] as core.bool
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
minimumExperimentLengthInDays:
json_.containsKey('minimumExperimentLengthInDays')
? json_['minimumExperimentLengthInDays'] as core.int
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
objectiveMetric: json_.containsKey('objectiveMetric')
? json_['objectiveMetric'] as core.String
: null,
optimizationType: json_.containsKey('optimizationType')
? json_['optimizationType'] as core.String
: null,
parentLink: json_.containsKey('parentLink')
? ExperimentParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
reasonExperimentEnded: json_.containsKey('reasonExperimentEnded')
? json_['reasonExperimentEnded'] as core.String
: null,
rewriteVariationUrlsAsOriginal:
json_.containsKey('rewriteVariationUrlsAsOriginal')
? json_['rewriteVariationUrlsAsOriginal'] as core.bool
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
servingFramework: json_.containsKey('servingFramework')
? json_['servingFramework'] as core.String
: null,
snippet: json_.containsKey('snippet')
? json_['snippet'] as core.String
: null,
startTime: json_.containsKey('startTime')
? core.DateTime.parse(json_['startTime'] as core.String)
: null,
status: json_.containsKey('status')
? json_['status'] as core.String
: null,
trafficCoverage: json_.containsKey('trafficCoverage')
? (json_['trafficCoverage'] as core.num).toDouble()
: null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
variations: json_.containsKey('variations')
? (json_['variations'] as core.List)
.map((value) => ExperimentVariations.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
winnerConfidenceLevel: json_.containsKey('winnerConfidenceLevel')
? (json_['winnerConfidenceLevel'] as core.num).toDouble()
: null,
winnerFound: json_.containsKey('winnerFound')
? json_['winnerFound'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (description != null) 'description': description!,
if (editableInGaUi != null) 'editableInGaUi': editableInGaUi!,
if (endTime != null) 'endTime': endTime!.toUtc().toIso8601String(),
if (equalWeighting != null) 'equalWeighting': equalWeighting!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (minimumExperimentLengthInDays != null)
'minimumExperimentLengthInDays': minimumExperimentLengthInDays!,
if (name != null) 'name': name!,
if (objectiveMetric != null) 'objectiveMetric': objectiveMetric!,
if (optimizationType != null) 'optimizationType': optimizationType!,
if (parentLink != null) 'parentLink': parentLink!,
if (profileId != null) 'profileId': profileId!,
if (reasonExperimentEnded != null)
'reasonExperimentEnded': reasonExperimentEnded!,
if (rewriteVariationUrlsAsOriginal != null)
'rewriteVariationUrlsAsOriginal': rewriteVariationUrlsAsOriginal!,
if (selfLink != null) 'selfLink': selfLink!,
if (servingFramework != null) 'servingFramework': servingFramework!,
if (snippet != null) 'snippet': snippet!,
if (startTime != null)
'startTime': startTime!.toUtc().toIso8601String(),
if (status != null) 'status': status!,
if (trafficCoverage != null) 'trafficCoverage': trafficCoverage!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (variations != null) 'variations': variations!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
if (winnerConfidenceLevel != null)
'winnerConfidenceLevel': winnerConfidenceLevel!,
if (winnerFound != null) 'winnerFound': winnerFound!,
};
}
/// An experiment collection lists Analytics experiments to which the user has
/// access.
///
/// Each view (profile) can have a set of experiments. Each resource in the
/// Experiment collection corresponds to a single Analytics experiment.
class Experiments {
/// A list of experiments.
core.List<Experiment>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this experiment collection.
core.String? nextLink;
/// Link to previous page for this experiment collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// resources in the result.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Experiments({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Experiments.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Experiment.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Details for the filter of the type ADVANCED.
class FilterAdvancedDetails {
/// Indicates if the filter expressions are case sensitive.
core.bool? caseSensitive;
/// Expression to extract from field A.
core.String? extractA;
/// Expression to extract from field B.
core.String? extractB;
/// Field A.
core.String? fieldA;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? fieldAIndex;
/// Indicates if field A is required to match.
core.bool? fieldARequired;
/// Field B.
core.String? fieldB;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? fieldBIndex;
/// Indicates if field B is required to match.
core.bool? fieldBRequired;
/// Expression used to construct the output value.
core.String? outputConstructor;
/// Output field.
core.String? outputToField;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? outputToFieldIndex;
/// Indicates if the existing value of the output field, if any, should be
/// overridden by the output expression.
core.bool? overrideOutputField;
FilterAdvancedDetails({
this.caseSensitive,
this.extractA,
this.extractB,
this.fieldA,
this.fieldAIndex,
this.fieldARequired,
this.fieldB,
this.fieldBIndex,
this.fieldBRequired,
this.outputConstructor,
this.outputToField,
this.outputToFieldIndex,
this.overrideOutputField,
});
FilterAdvancedDetails.fromJson(core.Map json_)
: this(
caseSensitive: json_.containsKey('caseSensitive')
? json_['caseSensitive'] as core.bool
: null,
extractA: json_.containsKey('extractA')
? json_['extractA'] as core.String
: null,
extractB: json_.containsKey('extractB')
? json_['extractB'] as core.String
: null,
fieldA: json_.containsKey('fieldA')
? json_['fieldA'] as core.String
: null,
fieldAIndex: json_.containsKey('fieldAIndex')
? json_['fieldAIndex'] as core.int
: null,
fieldARequired: json_.containsKey('fieldARequired')
? json_['fieldARequired'] as core.bool
: null,
fieldB: json_.containsKey('fieldB')
? json_['fieldB'] as core.String
: null,
fieldBIndex: json_.containsKey('fieldBIndex')
? json_['fieldBIndex'] as core.int
: null,
fieldBRequired: json_.containsKey('fieldBRequired')
? json_['fieldBRequired'] as core.bool
: null,
outputConstructor: json_.containsKey('outputConstructor')
? json_['outputConstructor'] as core.String
: null,
outputToField: json_.containsKey('outputToField')
? json_['outputToField'] as core.String
: null,
outputToFieldIndex: json_.containsKey('outputToFieldIndex')
? json_['outputToFieldIndex'] as core.int
: null,
overrideOutputField: json_.containsKey('overrideOutputField')
? json_['overrideOutputField'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (caseSensitive != null) 'caseSensitive': caseSensitive!,
if (extractA != null) 'extractA': extractA!,
if (extractB != null) 'extractB': extractB!,
if (fieldA != null) 'fieldA': fieldA!,
if (fieldAIndex != null) 'fieldAIndex': fieldAIndex!,
if (fieldARequired != null) 'fieldARequired': fieldARequired!,
if (fieldB != null) 'fieldB': fieldB!,
if (fieldBIndex != null) 'fieldBIndex': fieldBIndex!,
if (fieldBRequired != null) 'fieldBRequired': fieldBRequired!,
if (outputConstructor != null) 'outputConstructor': outputConstructor!,
if (outputToField != null) 'outputToField': outputToField!,
if (outputToFieldIndex != null)
'outputToFieldIndex': outputToFieldIndex!,
if (overrideOutputField != null)
'overrideOutputField': overrideOutputField!,
};
}
/// Details for the filter of the type LOWER.
class FilterLowercaseDetails {
/// Field to use in the filter.
core.String? field;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? fieldIndex;
FilterLowercaseDetails({
this.field,
this.fieldIndex,
});
FilterLowercaseDetails.fromJson(core.Map json_)
: this(
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
fieldIndex: json_.containsKey('fieldIndex')
? json_['fieldIndex'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (field != null) 'field': field!,
if (fieldIndex != null) 'fieldIndex': fieldIndex!,
};
}
/// Parent link for this filter.
///
/// Points to the account to which this filter belongs.
class FilterParentLink {
/// Link to the account to which this filter belongs.
core.String? href;
/// Value is "analytics#account".
core.String? type;
FilterParentLink({
this.href,
this.type,
});
FilterParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Details for the filter of the type SEARCH_AND_REPLACE.
class FilterSearchAndReplaceDetails {
/// Determines if the filter is case sensitive.
core.bool? caseSensitive;
/// Field to use in the filter.
core.String? field;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? fieldIndex;
/// Term to replace the search term with.
core.String? replaceString;
/// Term to search.
core.String? searchString;
FilterSearchAndReplaceDetails({
this.caseSensitive,
this.field,
this.fieldIndex,
this.replaceString,
this.searchString,
});
FilterSearchAndReplaceDetails.fromJson(core.Map json_)
: this(
caseSensitive: json_.containsKey('caseSensitive')
? json_['caseSensitive'] as core.bool
: null,
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
fieldIndex: json_.containsKey('fieldIndex')
? json_['fieldIndex'] as core.int
: null,
replaceString: json_.containsKey('replaceString')
? json_['replaceString'] as core.String
: null,
searchString: json_.containsKey('searchString')
? json_['searchString'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (caseSensitive != null) 'caseSensitive': caseSensitive!,
if (field != null) 'field': field!,
if (fieldIndex != null) 'fieldIndex': fieldIndex!,
if (replaceString != null) 'replaceString': replaceString!,
if (searchString != null) 'searchString': searchString!,
};
}
/// Details for the filter of the type UPPER.
class FilterUppercaseDetails {
/// Field to use in the filter.
core.String? field;
/// The Index of the custom dimension.
///
/// Required if field is a CUSTOM_DIMENSION.
core.int? fieldIndex;
FilterUppercaseDetails({
this.field,
this.fieldIndex,
});
FilterUppercaseDetails.fromJson(core.Map json_)
: this(
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
fieldIndex: json_.containsKey('fieldIndex')
? json_['fieldIndex'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (field != null) 'field': field!,
if (fieldIndex != null) 'fieldIndex': fieldIndex!,
};
}
/// JSON template for an Analytics account filter.
class Filter {
/// Account ID to which this filter belongs.
core.String? accountId;
/// Details for the filter of the type ADVANCED.
FilterAdvancedDetails? advancedDetails;
/// Time this filter was created.
core.DateTime? created;
/// Details for the filter of the type EXCLUDE.
FilterExpression? excludeDetails;
/// Filter ID.
core.String? id;
/// Details for the filter of the type INCLUDE.
FilterExpression? includeDetails;
/// Resource type for Analytics filter.
core.String? kind;
/// Details for the filter of the type LOWER.
FilterLowercaseDetails? lowercaseDetails;
/// Name of this filter.
core.String? name;
/// Parent link for this filter.
///
/// Points to the account to which this filter belongs.
FilterParentLink? parentLink;
/// Details for the filter of the type SEARCH_AND_REPLACE.
FilterSearchAndReplaceDetails? searchAndReplaceDetails;
/// Link for this filter.
core.String? selfLink;
/// Type of this filter.
///
/// Possible values are INCLUDE, EXCLUDE, LOWERCASE, UPPERCASE,
/// SEARCH_AND_REPLACE and ADVANCED.
core.String? type;
/// Time this filter was last modified.
core.DateTime? updated;
/// Details for the filter of the type UPPER.
FilterUppercaseDetails? uppercaseDetails;
Filter({
this.accountId,
this.advancedDetails,
this.created,
this.excludeDetails,
this.id,
this.includeDetails,
this.kind,
this.lowercaseDetails,
this.name,
this.parentLink,
this.searchAndReplaceDetails,
this.selfLink,
this.type,
this.updated,
this.uppercaseDetails,
});
Filter.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
advancedDetails: json_.containsKey('advancedDetails')
? FilterAdvancedDetails.fromJson(json_['advancedDetails']
as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
excludeDetails: json_.containsKey('excludeDetails')
? FilterExpression.fromJson(json_['excludeDetails']
as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
includeDetails: json_.containsKey('includeDetails')
? FilterExpression.fromJson(json_['includeDetails']
as core.Map<core.String, core.dynamic>)
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
lowercaseDetails: json_.containsKey('lowercaseDetails')
? FilterLowercaseDetails.fromJson(json_['lowercaseDetails']
as core.Map<core.String, core.dynamic>)
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? FilterParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
searchAndReplaceDetails: json_.containsKey('searchAndReplaceDetails')
? FilterSearchAndReplaceDetails.fromJson(
json_['searchAndReplaceDetails']
as core.Map<core.String, core.dynamic>)
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
uppercaseDetails: json_.containsKey('uppercaseDetails')
? FilterUppercaseDetails.fromJson(json_['uppercaseDetails']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (advancedDetails != null) 'advancedDetails': advancedDetails!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (excludeDetails != null) 'excludeDetails': excludeDetails!,
if (id != null) 'id': id!,
if (includeDetails != null) 'includeDetails': includeDetails!,
if (kind != null) 'kind': kind!,
if (lowercaseDetails != null) 'lowercaseDetails': lowercaseDetails!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (searchAndReplaceDetails != null)
'searchAndReplaceDetails': searchAndReplaceDetails!,
if (selfLink != null) 'selfLink': selfLink!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (uppercaseDetails != null) 'uppercaseDetails': uppercaseDetails!,
};
}
/// JSON template for an Analytics filter expression.
class FilterExpression {
/// Determines if the filter is case sensitive.
core.bool? caseSensitive;
/// Filter expression value
core.String? expressionValue;
/// Field to filter.
///
/// Possible values:
/// - Content and Traffic
/// - PAGE_REQUEST_URI,
/// - PAGE_HOSTNAME,
/// - PAGE_TITLE,
/// - REFERRAL,
/// - COST_DATA_URI (Campaign target URL),
/// - HIT_TYPE,
/// - INTERNAL_SEARCH_TERM,
/// - INTERNAL_SEARCH_TYPE,
/// - SOURCE_PROPERTY_TRACKING_ID,
/// - Campaign or AdGroup
/// - CAMPAIGN_SOURCE,
/// - CAMPAIGN_MEDIUM,
/// - CAMPAIGN_NAME,
/// - CAMPAIGN_AD_GROUP,
/// - CAMPAIGN_TERM,
/// - CAMPAIGN_CONTENT,
/// - CAMPAIGN_CODE,
/// - CAMPAIGN_REFERRAL_PATH,
/// - E-Commerce
/// - TRANSACTION_COUNTRY,
/// - TRANSACTION_REGION,
/// - TRANSACTION_CITY,
/// - TRANSACTION_AFFILIATION (Store or order location),
/// - ITEM_NAME,
/// - ITEM_CODE,
/// - ITEM_VARIATION,
/// - TRANSACTION_ID,
/// - TRANSACTION_CURRENCY_CODE,
/// - PRODUCT_ACTION_TYPE,
/// - Audience/Users
/// - BROWSER,
/// - BROWSER_VERSION,
/// - BROWSER_SIZE,
/// - PLATFORM,
/// - PLATFORM_VERSION,
/// - LANGUAGE,
/// - SCREEN_RESOLUTION,
/// - SCREEN_COLORS,
/// - JAVA_ENABLED (Boolean Field),
/// - FLASH_VERSION,
/// - GEO_SPEED (Connection speed),
/// - VISITOR_TYPE,
/// - GEO_ORGANIZATION (ISP organization),
/// - GEO_DOMAIN,
/// - GEO_IP_ADDRESS,
/// - GEO_IP_VERSION,
/// - Location
/// - GEO_COUNTRY,
/// - GEO_REGION,
/// - GEO_CITY,
/// - Event
/// - EVENT_CATEGORY,
/// - EVENT_ACTION,
/// - EVENT_LABEL,
/// - Other
/// - CUSTOM_FIELD_1,
/// - CUSTOM_FIELD_2,
/// - USER_DEFINED_VALUE,
/// - Application
/// - APP_ID,
/// - APP_INSTALLER_ID,
/// - APP_NAME,
/// - APP_VERSION,
/// - SCREEN,
/// - IS_APP (Boolean Field),
/// - IS_FATAL_EXCEPTION (Boolean Field),
/// - EXCEPTION_DESCRIPTION,
/// - Mobile device
/// - IS_MOBILE (Boolean Field, Deprecated. Use DEVICE_CATEGORY=mobile),
/// - IS_TABLET (Boolean Field, Deprecated. Use DEVICE_CATEGORY=tablet),
/// - DEVICE_CATEGORY,
/// - MOBILE_HAS_QWERTY_KEYBOARD (Boolean Field),
/// - MOBILE_HAS_NFC_SUPPORT (Boolean Field),
/// - MOBILE_HAS_CELLULAR_RADIO (Boolean Field),
/// - MOBILE_HAS_WIFI_SUPPORT (Boolean Field),
/// - MOBILE_BRAND_NAME,
/// - MOBILE_MODEL_NAME,
/// - MOBILE_MARKETING_NAME,
/// - MOBILE_POINTING_METHOD,
/// - Social
/// - SOCIAL_NETWORK,
/// - SOCIAL_ACTION,
/// - SOCIAL_ACTION_TARGET,
/// - Custom dimension
/// - CUSTOM_DIMENSION (See accompanying field index),
core.String? field;
/// The Index of the custom dimension.
///
/// Set only if the field is a is CUSTOM_DIMENSION.
core.int? fieldIndex;
/// Kind value for filter expression
core.String? kind;
/// Match type for this filter.
///
/// Possible values are BEGINS_WITH, EQUAL, ENDS_WITH, CONTAINS, or MATCHES.
/// GEO_DOMAIN, GEO_IP_ADDRESS, PAGE_REQUEST_URI, or PAGE_HOSTNAME filters can
/// use any match type; all other filters must use MATCHES.
core.String? matchType;
FilterExpression({
this.caseSensitive,
this.expressionValue,
this.field,
this.fieldIndex,
this.kind,
this.matchType,
});
FilterExpression.fromJson(core.Map json_)
: this(
caseSensitive: json_.containsKey('caseSensitive')
? json_['caseSensitive'] as core.bool
: null,
expressionValue: json_.containsKey('expressionValue')
? json_['expressionValue'] as core.String
: null,
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
fieldIndex: json_.containsKey('fieldIndex')
? json_['fieldIndex'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
matchType: json_.containsKey('matchType')
? json_['matchType'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (caseSensitive != null) 'caseSensitive': caseSensitive!,
if (expressionValue != null) 'expressionValue': expressionValue!,
if (field != null) 'field': field!,
if (fieldIndex != null) 'fieldIndex': fieldIndex!,
if (kind != null) 'kind': kind!,
if (matchType != null) 'matchType': matchType!,
};
}
/// JSON template for a profile filter link.
class FilterRef {
/// Account ID to which this filter belongs.
core.String? accountId;
/// Link for this filter.
core.String? href;
/// Filter ID.
core.String? id;
/// Kind value for filter reference.
core.String? kind;
/// Name of this filter.
core.String? name;
FilterRef({
this.accountId,
this.href,
this.id,
this.kind,
this.name,
});
FilterRef.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
href: json_.containsKey('href') ? json_['href'] as core.String : null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (href != null) 'href': href!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
};
}
/// A filter collection lists filters created by users in an Analytics account.
///
/// Each resource in the collection corresponds to a filter.
class Filters {
/// A list of filters.
core.List<Filter>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1,000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this filter collection.
core.String? nextLink;
/// Link to previous page for this filter collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Filters({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Filters.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Filter.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
class GaDataColumnHeaders {
/// Column Type.
///
/// Either DIMENSION or METRIC.
core.String? columnType;
/// Data type.
///
/// Dimension column headers have only STRING as the data type. Metric column
/// headers have data types for metric values such as INTEGER, DOUBLE,
/// CURRENCY etc.
core.String? dataType;
/// Column name.
core.String? name;
GaDataColumnHeaders({
this.columnType,
this.dataType,
this.name,
});
GaDataColumnHeaders.fromJson(core.Map json_)
: this(
columnType: json_.containsKey('columnType')
? json_['columnType'] as core.String
: null,
dataType: json_.containsKey('dataType')
? json_['dataType'] as core.String
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnType != null) 'columnType': columnType!,
if (dataType != null) 'dataType': dataType!,
if (name != null) 'name': name!,
};
}
class GaDataDataTableCols {
core.String? id;
core.String? label;
core.String? type;
GaDataDataTableCols({
this.id,
this.label,
this.type,
});
GaDataDataTableCols.fromJson(core.Map json_)
: this(
id: json_.containsKey('id') ? json_['id'] as core.String : null,
label:
json_.containsKey('label') ? json_['label'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (id != null) 'id': id!,
if (label != null) 'label': label!,
if (type != null) 'type': type!,
};
}
class GaDataDataTableRowsC {
core.String? v;
GaDataDataTableRowsC({
this.v,
});
GaDataDataTableRowsC.fromJson(core.Map json_)
: this(
v: json_.containsKey('v') ? json_['v'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (v != null) 'v': v!,
};
}
class GaDataDataTableRows {
core.List<GaDataDataTableRowsC>? c;
GaDataDataTableRows({
this.c,
});
GaDataDataTableRows.fromJson(core.Map json_)
: this(
c: json_.containsKey('c')
? (json_['c'] as core.List)
.map((value) => GaDataDataTableRowsC.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (c != null) 'c': c!,
};
}
class GaDataDataTable {
core.List<GaDataDataTableCols>? cols;
core.List<GaDataDataTableRows>? rows;
GaDataDataTable({
this.cols,
this.rows,
});
GaDataDataTable.fromJson(core.Map json_)
: this(
cols: json_.containsKey('cols')
? (json_['cols'] as core.List)
.map((value) => GaDataDataTableCols.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
rows: json_.containsKey('rows')
? (json_['rows'] as core.List)
.map((value) => GaDataDataTableRows.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (cols != null) 'cols': cols!,
if (rows != null) 'rows': rows!,
};
}
/// Information for the view (profile), for which the Analytics data was
/// requested.
class GaDataProfileInfo {
/// Account ID to which this view (profile) belongs.
core.String? accountId;
/// Internal ID for the web property to which this view (profile) belongs.
core.String? internalWebPropertyId;
/// View (Profile) ID.
core.String? profileId;
/// View (Profile) name.
core.String? profileName;
/// Table ID for view (profile).
core.String? tableId;
/// Web Property ID to which this view (profile) belongs.
core.String? webPropertyId;
GaDataProfileInfo({
this.accountId,
this.internalWebPropertyId,
this.profileId,
this.profileName,
this.tableId,
this.webPropertyId,
});
GaDataProfileInfo.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
profileName: json_.containsKey('profileName')
? json_['profileName'] as core.String
: null,
tableId: json_.containsKey('tableId')
? json_['tableId'] as core.String
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (profileId != null) 'profileId': profileId!,
if (profileName != null) 'profileName': profileName!,
if (tableId != null) 'tableId': tableId!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// Analytics data request query parameters.
class GaDataQuery {
/// List of analytics dimensions.
core.String? dimensions;
/// End date.
core.String? endDate;
/// Comma-separated list of dimension or metric filters.
core.String? filters;
/// Unique table ID.
core.String? ids;
/// Maximum results per page.
core.int? maxResults;
/// List of analytics metrics.
core.List<core.String>? metrics;
/// Desired sampling level
core.String? samplingLevel;
/// Analytics advanced segment.
core.String? segment;
/// List of dimensions or metrics based on which Analytics data is sorted.
core.List<core.String>? sort;
/// Start date.
core.String? startDate;
/// Start index.
core.int? startIndex;
GaDataQuery({
this.dimensions,
this.endDate,
this.filters,
this.ids,
this.maxResults,
this.metrics,
this.samplingLevel,
this.segment,
this.sort,
this.startDate,
this.startIndex,
});
GaDataQuery.fromJson(core.Map json_)
: this(
dimensions: json_.containsKey('dimensions')
? json_['dimensions'] as core.String
: null,
endDate: json_.containsKey('end-date')
? json_['end-date'] as core.String
: null,
filters: json_.containsKey('filters')
? json_['filters'] as core.String
: null,
ids: json_.containsKey('ids') ? json_['ids'] as core.String : null,
maxResults: json_.containsKey('max-results')
? json_['max-results'] as core.int
: null,
metrics: json_.containsKey('metrics')
? (json_['metrics'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
samplingLevel: json_.containsKey('samplingLevel')
? json_['samplingLevel'] as core.String
: null,
segment: json_.containsKey('segment')
? json_['segment'] as core.String
: null,
sort: json_.containsKey('sort')
? (json_['sort'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
startDate: json_.containsKey('start-date')
? json_['start-date'] as core.String
: null,
startIndex: json_.containsKey('start-index')
? json_['start-index'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (dimensions != null) 'dimensions': dimensions!,
if (endDate != null) 'end-date': endDate!,
if (filters != null) 'filters': filters!,
if (ids != null) 'ids': ids!,
if (maxResults != null) 'max-results': maxResults!,
if (metrics != null) 'metrics': metrics!,
if (samplingLevel != null) 'samplingLevel': samplingLevel!,
if (segment != null) 'segment': segment!,
if (sort != null) 'sort': sort!,
if (startDate != null) 'start-date': startDate!,
if (startIndex != null) 'start-index': startIndex!,
};
}
/// Analytics data for a given view (profile).
class GaData {
/// Column headers that list dimension names followed by the metric names.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<GaDataColumnHeaders>? columnHeaders;
/// Determines if Analytics data contains samples.
core.bool? containsSampledData;
/// The last refreshed time in seconds for Analytics data.
core.String? dataLastRefreshed;
GaDataDataTable? dataTable;
/// Unique ID for this data response.
core.String? id;
/// The maximum number of rows the response can contain, regardless of the
/// actual number of rows returned.
///
/// Its value ranges from 1 to 10,000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Resource type.
core.String? kind;
/// Link to next page for this Analytics data query.
core.String? nextLink;
/// Link to previous page for this Analytics data query.
core.String? previousLink;
/// Information for the view (profile), for which the Analytics data was
/// requested.
GaDataProfileInfo? profileInfo;
/// Analytics data request query parameters.
GaDataQuery? query;
/// Analytics data rows, where each row contains a list of dimension values
/// followed by the metric values.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<core.List<core.String>>? rows;
/// The number of samples used to calculate the result.
core.String? sampleSize;
/// Total size of the sample space from which the samples were selected.
core.String? sampleSpace;
/// Link to this page.
core.String? selfLink;
/// The total number of rows for the query, regardless of the number of rows
/// in the response.
core.int? totalResults;
/// Total values for the requested metrics over all the results, not just the
/// results returned in this response.
///
/// The order of the metric totals is same as the metric order specified in
/// the request.
core.Map<core.String, core.String>? totalsForAllResults;
GaData({
this.columnHeaders,
this.containsSampledData,
this.dataLastRefreshed,
this.dataTable,
this.id,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.profileInfo,
this.query,
this.rows,
this.sampleSize,
this.sampleSpace,
this.selfLink,
this.totalResults,
this.totalsForAllResults,
});
GaData.fromJson(core.Map json_)
: this(
columnHeaders: json_.containsKey('columnHeaders')
? (json_['columnHeaders'] as core.List)
.map((value) => GaDataColumnHeaders.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
containsSampledData: json_.containsKey('containsSampledData')
? json_['containsSampledData'] as core.bool
: null,
dataLastRefreshed: json_.containsKey('dataLastRefreshed')
? json_['dataLastRefreshed'] as core.String
: null,
dataTable: json_.containsKey('dataTable')
? GaDataDataTable.fromJson(
json_['dataTable'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
profileInfo: json_.containsKey('profileInfo')
? GaDataProfileInfo.fromJson(
json_['profileInfo'] as core.Map<core.String, core.dynamic>)
: null,
query: json_.containsKey('query')
? GaDataQuery.fromJson(
json_['query'] as core.Map<core.String, core.dynamic>)
: null,
rows: json_.containsKey('rows')
? (json_['rows'] as core.List)
.map((value) => (value as core.List)
.map((value) => value as core.String)
.toList())
.toList()
: null,
sampleSize: json_.containsKey('sampleSize')
? json_['sampleSize'] as core.String
: null,
sampleSpace: json_.containsKey('sampleSpace')
? json_['sampleSpace'] as core.String
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
totalsForAllResults: json_.containsKey('totalsForAllResults')
? (json_['totalsForAllResults']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnHeaders != null) 'columnHeaders': columnHeaders!,
if (containsSampledData != null)
'containsSampledData': containsSampledData!,
if (dataLastRefreshed != null) 'dataLastRefreshed': dataLastRefreshed!,
if (dataTable != null) 'dataTable': dataTable!,
if (id != null) 'id': id!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (profileInfo != null) 'profileInfo': profileInfo!,
if (query != null) 'query': query!,
if (rows != null) 'rows': rows!,
if (sampleSize != null) 'sampleSize': sampleSize!,
if (sampleSpace != null) 'sampleSpace': sampleSpace!,
if (selfLink != null) 'selfLink': selfLink!,
if (totalResults != null) 'totalResults': totalResults!,
if (totalsForAllResults != null)
'totalsForAllResults': totalsForAllResults!,
};
}
class GoalEventDetailsEventConditions {
/// Type of comparison.
///
/// Possible values are LESS_THAN, GREATER_THAN or EQUAL.
core.String? comparisonType;
/// Value used for this comparison.
core.String? comparisonValue;
/// Expression used for this match.
core.String? expression;
/// Type of the match to be performed.
///
/// Possible values are REGEXP, BEGINS_WITH, or EXACT.
core.String? matchType;
/// Type of this event condition.
///
/// Possible values are CATEGORY, ACTION, LABEL, or VALUE.
core.String? type;
GoalEventDetailsEventConditions({
this.comparisonType,
this.comparisonValue,
this.expression,
this.matchType,
this.type,
});
GoalEventDetailsEventConditions.fromJson(core.Map json_)
: this(
comparisonType: json_.containsKey('comparisonType')
? json_['comparisonType'] as core.String
: null,
comparisonValue: json_.containsKey('comparisonValue')
? json_['comparisonValue'] as core.String
: null,
expression: json_.containsKey('expression')
? json_['expression'] as core.String
: null,
matchType: json_.containsKey('matchType')
? json_['matchType'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (comparisonType != null) 'comparisonType': comparisonType!,
if (comparisonValue != null) 'comparisonValue': comparisonValue!,
if (expression != null) 'expression': expression!,
if (matchType != null) 'matchType': matchType!,
if (type != null) 'type': type!,
};
}
/// Details for the goal of the type EVENT.
class GoalEventDetails {
/// List of event conditions.
core.List<GoalEventDetailsEventConditions>? eventConditions;
/// Determines if the event value should be used as the value for this goal.
core.bool? useEventValue;
GoalEventDetails({
this.eventConditions,
this.useEventValue,
});
GoalEventDetails.fromJson(core.Map json_)
: this(
eventConditions: json_.containsKey('eventConditions')
? (json_['eventConditions'] as core.List)
.map((value) => GoalEventDetailsEventConditions.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
useEventValue: json_.containsKey('useEventValue')
? json_['useEventValue'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (eventConditions != null) 'eventConditions': eventConditions!,
if (useEventValue != null) 'useEventValue': useEventValue!,
};
}
/// Parent link for a goal.
///
/// Points to the view (profile) to which this goal belongs.
class GoalParentLink {
/// Link to the view (profile) to which this goal belongs.
core.String? href;
/// Value is "analytics#profile".
core.String? type;
GoalParentLink({
this.href,
this.type,
});
GoalParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
class GoalUrlDestinationDetailsSteps {
/// Step name.
core.String? name;
/// Step number.
core.int? number;
/// URL for this step.
core.String? url;
GoalUrlDestinationDetailsSteps({
this.name,
this.number,
this.url,
});
GoalUrlDestinationDetailsSteps.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
number:
json_.containsKey('number') ? json_['number'] as core.int : null,
url: json_.containsKey('url') ? json_['url'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (number != null) 'number': number!,
if (url != null) 'url': url!,
};
}
/// Details for the goal of the type URL_DESTINATION.
class GoalUrlDestinationDetails {
/// Determines if the goal URL must exactly match the capitalization of
/// visited URLs.
core.bool? caseSensitive;
/// Determines if the first step in this goal is required.
core.bool? firstStepRequired;
/// Match type for the goal URL.
///
/// Possible values are HEAD, EXACT, or REGEX.
core.String? matchType;
/// List of steps configured for this goal funnel.
core.List<GoalUrlDestinationDetailsSteps>? steps;
/// URL for this goal.
core.String? url;
GoalUrlDestinationDetails({
this.caseSensitive,
this.firstStepRequired,
this.matchType,
this.steps,
this.url,
});
GoalUrlDestinationDetails.fromJson(core.Map json_)
: this(
caseSensitive: json_.containsKey('caseSensitive')
? json_['caseSensitive'] as core.bool
: null,
firstStepRequired: json_.containsKey('firstStepRequired')
? json_['firstStepRequired'] as core.bool
: null,
matchType: json_.containsKey('matchType')
? json_['matchType'] as core.String
: null,
steps: json_.containsKey('steps')
? (json_['steps'] as core.List)
.map((value) => GoalUrlDestinationDetailsSteps.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
url: json_.containsKey('url') ? json_['url'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (caseSensitive != null) 'caseSensitive': caseSensitive!,
if (firstStepRequired != null) 'firstStepRequired': firstStepRequired!,
if (matchType != null) 'matchType': matchType!,
if (steps != null) 'steps': steps!,
if (url != null) 'url': url!,
};
}
/// Details for the goal of the type VISIT_NUM_PAGES.
class GoalVisitNumPagesDetails {
/// Type of comparison.
///
/// Possible values are LESS_THAN, GREATER_THAN, or EQUAL.
core.String? comparisonType;
/// Value used for this comparison.
core.String? comparisonValue;
GoalVisitNumPagesDetails({
this.comparisonType,
this.comparisonValue,
});
GoalVisitNumPagesDetails.fromJson(core.Map json_)
: this(
comparisonType: json_.containsKey('comparisonType')
? json_['comparisonType'] as core.String
: null,
comparisonValue: json_.containsKey('comparisonValue')
? json_['comparisonValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (comparisonType != null) 'comparisonType': comparisonType!,
if (comparisonValue != null) 'comparisonValue': comparisonValue!,
};
}
/// Details for the goal of the type VISIT_TIME_ON_SITE.
class GoalVisitTimeOnSiteDetails {
/// Type of comparison.
///
/// Possible values are LESS_THAN or GREATER_THAN.
core.String? comparisonType;
/// Value used for this comparison.
core.String? comparisonValue;
GoalVisitTimeOnSiteDetails({
this.comparisonType,
this.comparisonValue,
});
GoalVisitTimeOnSiteDetails.fromJson(core.Map json_)
: this(
comparisonType: json_.containsKey('comparisonType')
? json_['comparisonType'] as core.String
: null,
comparisonValue: json_.containsKey('comparisonValue')
? json_['comparisonValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (comparisonType != null) 'comparisonType': comparisonType!,
if (comparisonValue != null) 'comparisonValue': comparisonValue!,
};
}
/// JSON template for Analytics goal resource.
class Goal {
/// Account ID to which this goal belongs.
core.String? accountId;
/// Determines whether this goal is active.
core.bool? active;
/// Time this goal was created.
core.DateTime? created;
/// Details for the goal of the type EVENT.
GoalEventDetails? eventDetails;
/// Goal ID.
core.String? id;
/// Internal ID for the web property to which this goal belongs.
core.String? internalWebPropertyId;
/// Resource type for an Analytics goal.
core.String? kind;
/// Goal name.
core.String? name;
/// Parent link for a goal.
///
/// Points to the view (profile) to which this goal belongs.
GoalParentLink? parentLink;
/// View (Profile) ID to which this goal belongs.
core.String? profileId;
/// Link for this goal.
core.String? selfLink;
/// Goal type.
///
/// Possible values are URL_DESTINATION, VISIT_TIME_ON_SITE, VISIT_NUM_PAGES,
/// AND EVENT.
core.String? type;
/// Time this goal was last modified.
core.DateTime? updated;
/// Details for the goal of the type URL_DESTINATION.
GoalUrlDestinationDetails? urlDestinationDetails;
/// Goal value.
core.double? value;
/// Details for the goal of the type VISIT_NUM_PAGES.
GoalVisitNumPagesDetails? visitNumPagesDetails;
/// Details for the goal of the type VISIT_TIME_ON_SITE.
GoalVisitTimeOnSiteDetails? visitTimeOnSiteDetails;
/// Web property ID to which this goal belongs.
///
/// The web property ID is of the form UA-XXXXX-YY.
core.String? webPropertyId;
Goal({
this.accountId,
this.active,
this.created,
this.eventDetails,
this.id,
this.internalWebPropertyId,
this.kind,
this.name,
this.parentLink,
this.profileId,
this.selfLink,
this.type,
this.updated,
this.urlDestinationDetails,
this.value,
this.visitNumPagesDetails,
this.visitTimeOnSiteDetails,
this.webPropertyId,
});
Goal.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
active:
json_.containsKey('active') ? json_['active'] as core.bool : null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
eventDetails: json_.containsKey('eventDetails')
? GoalEventDetails.fromJson(
json_['eventDetails'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? GoalParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
urlDestinationDetails: json_.containsKey('urlDestinationDetails')
? GoalUrlDestinationDetails.fromJson(
json_['urlDestinationDetails']
as core.Map<core.String, core.dynamic>)
: null,
value: json_.containsKey('value')
? (json_['value'] as core.num).toDouble()
: null,
visitNumPagesDetails: json_.containsKey('visitNumPagesDetails')
? GoalVisitNumPagesDetails.fromJson(json_['visitNumPagesDetails']
as core.Map<core.String, core.dynamic>)
: null,
visitTimeOnSiteDetails: json_.containsKey('visitTimeOnSiteDetails')
? GoalVisitTimeOnSiteDetails.fromJson(
json_['visitTimeOnSiteDetails']
as core.Map<core.String, core.dynamic>)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (active != null) 'active': active!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (eventDetails != null) 'eventDetails': eventDetails!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (profileId != null) 'profileId': profileId!,
if (selfLink != null) 'selfLink': selfLink!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (urlDestinationDetails != null)
'urlDestinationDetails': urlDestinationDetails!,
if (value != null) 'value': value!,
if (visitNumPagesDetails != null)
'visitNumPagesDetails': visitNumPagesDetails!,
if (visitTimeOnSiteDetails != null)
'visitTimeOnSiteDetails': visitTimeOnSiteDetails!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// A goal collection lists Analytics goals to which the user has access.
///
/// Each view (profile) can have a set of goals. Each resource in the Goal
/// collection corresponds to a single Analytics goal.
class Goals {
/// A list of goals.
core.List<Goal>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this goal collection.
core.String? nextLink;
/// Link to previous page for this goal collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// resources in the result.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Goals({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Goals.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Goal.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// JSON template for a hash Client Id request resource.
class HashClientIdRequest {
core.String? clientId;
core.String? kind;
core.String? webPropertyId;
HashClientIdRequest({
this.clientId,
this.kind,
this.webPropertyId,
});
HashClientIdRequest.fromJson(core.Map json_)
: this(
clientId: json_.containsKey('clientId')
? json_['clientId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (clientId != null) 'clientId': clientId!,
if (kind != null) 'kind': kind!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// JSON template for a hash Client Id response resource.
class HashClientIdResponse {
core.String? clientId;
core.String? hashedClientId;
core.String? kind;
core.String? webPropertyId;
HashClientIdResponse({
this.clientId,
this.hashedClientId,
this.kind,
this.webPropertyId,
});
HashClientIdResponse.fromJson(core.Map json_)
: this(
clientId: json_.containsKey('clientId')
? json_['clientId'] as core.String
: null,
hashedClientId: json_.containsKey('hashedClientId')
? json_['hashedClientId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (clientId != null) 'clientId': clientId!,
if (hashedClientId != null) 'hashedClientId': hashedClientId!,
if (kind != null) 'kind': kind!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// JSON template for an Analytics Remarketing Include Conditions.
class IncludeConditions {
/// The look-back window lets you specify a time frame for evaluating the
/// behavior that qualifies users for your audience.
///
/// For example, if your filters include users from Central Asia, and
/// Transactions Greater than 2, and you set the look-back window to 14 days,
/// then any user from Central Asia whose cumulative transactions exceed 2
/// during the last 14 days is added to the audience.
core.int? daysToLookBack;
/// Boolean indicating whether this segment is a smart list.
///
/// https://support.google.com/analytics/answer/4628577
core.bool? isSmartList;
/// Resource type for include conditions.
core.String? kind;
/// Number of days (in the range 1 to 540) a user remains in the audience.
core.int? membershipDurationDays;
/// The segment condition that will cause a user to be added to an audience.
core.String? segment;
IncludeConditions({
this.daysToLookBack,
this.isSmartList,
this.kind,
this.membershipDurationDays,
this.segment,
});
IncludeConditions.fromJson(core.Map json_)
: this(
daysToLookBack: json_.containsKey('daysToLookBack')
? json_['daysToLookBack'] as core.int
: null,
isSmartList: json_.containsKey('isSmartList')
? json_['isSmartList'] as core.bool
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
membershipDurationDays: json_.containsKey('membershipDurationDays')
? json_['membershipDurationDays'] as core.int
: null,
segment: json_.containsKey('segment')
? json_['segment'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (daysToLookBack != null) 'daysToLookBack': daysToLookBack!,
if (isSmartList != null) 'isSmartList': isSmartList!,
if (kind != null) 'kind': kind!,
if (membershipDurationDays != null)
'membershipDurationDays': membershipDurationDays!,
if (segment != null) 'segment': segment!,
};
}
/// JSON template for an Analytics Remarketing Audience Foreign Link.
class LinkedForeignAccount {
/// Account ID to which this linked foreign account belongs.
core.String? accountId;
/// Boolean indicating whether this is eligible for search.
core.bool? eligibleForSearch;
/// Entity ad account link ID.
core.String? id;
/// Internal ID for the web property to which this linked foreign account
/// belongs.
core.String? internalWebPropertyId;
/// Resource type for linked foreign account.
core.String? kind;
/// The foreign account ID.
///
/// For example the an Google Ads `linkedAccountId` has the following format
/// XXX-XXX-XXXX.
core.String? linkedAccountId;
/// Remarketing audience ID to which this linked foreign account belongs.
core.String? remarketingAudienceId;
/// The status of this foreign account link.
core.String? status;
/// The type of the foreign account.
///
/// For example, `ADWORDS_LINKS`, `DBM_LINKS`, `MCC_LINKS` or `OPTIMIZE`.
core.String? type;
/// Web property ID of the form UA-XXXXX-YY to which this linked foreign
/// account belongs.
core.String? webPropertyId;
LinkedForeignAccount({
this.accountId,
this.eligibleForSearch,
this.id,
this.internalWebPropertyId,
this.kind,
this.linkedAccountId,
this.remarketingAudienceId,
this.status,
this.type,
this.webPropertyId,
});
LinkedForeignAccount.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
eligibleForSearch: json_.containsKey('eligibleForSearch')
? json_['eligibleForSearch'] as core.bool
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
linkedAccountId: json_.containsKey('linkedAccountId')
? json_['linkedAccountId'] as core.String
: null,
remarketingAudienceId: json_.containsKey('remarketingAudienceId')
? json_['remarketingAudienceId'] as core.String
: null,
status: json_.containsKey('status')
? json_['status'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (eligibleForSearch != null) 'eligibleForSearch': eligibleForSearch!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (linkedAccountId != null) 'linkedAccountId': linkedAccountId!,
if (remarketingAudienceId != null)
'remarketingAudienceId': remarketingAudienceId!,
if (status != null) 'status': status!,
if (type != null) 'type': type!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
class McfDataColumnHeaders {
/// Column Type.
///
/// Either DIMENSION or METRIC.
core.String? columnType;
/// Data type.
///
/// Dimension and metric values data types such as INTEGER, DOUBLE, CURRENCY,
/// MCF_SEQUENCE etc.
core.String? dataType;
/// Column name.
core.String? name;
McfDataColumnHeaders({
this.columnType,
this.dataType,
this.name,
});
McfDataColumnHeaders.fromJson(core.Map json_)
: this(
columnType: json_.containsKey('columnType')
? json_['columnType'] as core.String
: null,
dataType: json_.containsKey('dataType')
? json_['dataType'] as core.String
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnType != null) 'columnType': columnType!,
if (dataType != null) 'dataType': dataType!,
if (name != null) 'name': name!,
};
}
/// Information for the view (profile), for which the Analytics data was
/// requested.
class McfDataProfileInfo {
/// Account ID to which this view (profile) belongs.
core.String? accountId;
/// Internal ID for the web property to which this view (profile) belongs.
core.String? internalWebPropertyId;
/// View (Profile) ID.
core.String? profileId;
/// View (Profile) name.
core.String? profileName;
/// Table ID for view (profile).
core.String? tableId;
/// Web Property ID to which this view (profile) belongs.
core.String? webPropertyId;
McfDataProfileInfo({
this.accountId,
this.internalWebPropertyId,
this.profileId,
this.profileName,
this.tableId,
this.webPropertyId,
});
McfDataProfileInfo.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
profileName: json_.containsKey('profileName')
? json_['profileName'] as core.String
: null,
tableId: json_.containsKey('tableId')
? json_['tableId'] as core.String
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (profileId != null) 'profileId': profileId!,
if (profileName != null) 'profileName': profileName!,
if (tableId != null) 'tableId': tableId!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// Analytics data request query parameters.
class McfDataQuery {
/// List of analytics dimensions.
core.String? dimensions;
/// End date.
core.String? endDate;
/// Comma-separated list of dimension or metric filters.
core.String? filters;
/// Unique table ID.
core.String? ids;
/// Maximum results per page.
core.int? maxResults;
/// List of analytics metrics.
core.List<core.String>? metrics;
/// Desired sampling level
core.String? samplingLevel;
/// Analytics advanced segment.
core.String? segment;
/// List of dimensions or metrics based on which Analytics data is sorted.
core.List<core.String>? sort;
/// Start date.
core.String? startDate;
/// Start index.
core.int? startIndex;
McfDataQuery({
this.dimensions,
this.endDate,
this.filters,
this.ids,
this.maxResults,
this.metrics,
this.samplingLevel,
this.segment,
this.sort,
this.startDate,
this.startIndex,
});
McfDataQuery.fromJson(core.Map json_)
: this(
dimensions: json_.containsKey('dimensions')
? json_['dimensions'] as core.String
: null,
endDate: json_.containsKey('end-date')
? json_['end-date'] as core.String
: null,
filters: json_.containsKey('filters')
? json_['filters'] as core.String
: null,
ids: json_.containsKey('ids') ? json_['ids'] as core.String : null,
maxResults: json_.containsKey('max-results')
? json_['max-results'] as core.int
: null,
metrics: json_.containsKey('metrics')
? (json_['metrics'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
samplingLevel: json_.containsKey('samplingLevel')
? json_['samplingLevel'] as core.String
: null,
segment: json_.containsKey('segment')
? json_['segment'] as core.String
: null,
sort: json_.containsKey('sort')
? (json_['sort'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
startDate: json_.containsKey('start-date')
? json_['start-date'] as core.String
: null,
startIndex: json_.containsKey('start-index')
? json_['start-index'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (dimensions != null) 'dimensions': dimensions!,
if (endDate != null) 'end-date': endDate!,
if (filters != null) 'filters': filters!,
if (ids != null) 'ids': ids!,
if (maxResults != null) 'max-results': maxResults!,
if (metrics != null) 'metrics': metrics!,
if (samplingLevel != null) 'samplingLevel': samplingLevel!,
if (segment != null) 'segment': segment!,
if (sort != null) 'sort': sort!,
if (startDate != null) 'start-date': startDate!,
if (startIndex != null) 'start-index': startIndex!,
};
}
class McfDataRowsConversionPathValue {
/// Type of an interaction on conversion path.
///
/// Such as CLICK, IMPRESSION etc.
core.String? interactionType;
/// Node value of an interaction on conversion path.
///
/// Such as source, medium etc.
core.String? nodeValue;
McfDataRowsConversionPathValue({
this.interactionType,
this.nodeValue,
});
McfDataRowsConversionPathValue.fromJson(core.Map json_)
: this(
interactionType: json_.containsKey('interactionType')
? json_['interactionType'] as core.String
: null,
nodeValue: json_.containsKey('nodeValue')
? json_['nodeValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (interactionType != null) 'interactionType': interactionType!,
if (nodeValue != null) 'nodeValue': nodeValue!,
};
}
/// A union object representing a dimension or metric value.
///
/// Only one of "primitiveValue" or "conversionPathValue" attribute will be
/// populated.
class McfDataRows {
/// A conversion path dimension value, containing a list of interactions with
/// their attributes.
core.List<McfDataRowsConversionPathValue>? conversionPathValue;
/// A primitive dimension value.
///
/// A primitive metric value.
core.String? primitiveValue;
McfDataRows({
this.conversionPathValue,
this.primitiveValue,
});
McfDataRows.fromJson(core.Map json_)
: this(
conversionPathValue: json_.containsKey('conversionPathValue')
? (json_['conversionPathValue'] as core.List)
.map((value) => McfDataRowsConversionPathValue.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
primitiveValue: json_.containsKey('primitiveValue')
? json_['primitiveValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (conversionPathValue != null)
'conversionPathValue': conversionPathValue!,
if (primitiveValue != null) 'primitiveValue': primitiveValue!,
};
}
/// Multi-Channel Funnels data for a given view (profile).
class McfData {
/// Column headers that list dimension names followed by the metric names.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<McfDataColumnHeaders>? columnHeaders;
/// Determines if the Analytics data contains sampled data.
core.bool? containsSampledData;
/// Unique ID for this data response.
core.String? id;
/// The maximum number of rows the response can contain, regardless of the
/// actual number of rows returned.
///
/// Its value ranges from 1 to 10,000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Resource type.
core.String? kind;
/// Link to next page for this Analytics data query.
core.String? nextLink;
/// Link to previous page for this Analytics data query.
core.String? previousLink;
/// Information for the view (profile), for which the Analytics data was
/// requested.
McfDataProfileInfo? profileInfo;
/// Analytics data request query parameters.
McfDataQuery? query;
/// Analytics data rows, where each row contains a list of dimension values
/// followed by the metric values.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<core.List<McfDataRows>>? rows;
/// The number of samples used to calculate the result.
core.String? sampleSize;
/// Total size of the sample space from which the samples were selected.
core.String? sampleSpace;
/// Link to this page.
core.String? selfLink;
/// The total number of rows for the query, regardless of the number of rows
/// in the response.
core.int? totalResults;
/// Total values for the requested metrics over all the results, not just the
/// results returned in this response.
///
/// The order of the metric totals is same as the metric order specified in
/// the request.
core.Map<core.String, core.String>? totalsForAllResults;
McfData({
this.columnHeaders,
this.containsSampledData,
this.id,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.profileInfo,
this.query,
this.rows,
this.sampleSize,
this.sampleSpace,
this.selfLink,
this.totalResults,
this.totalsForAllResults,
});
McfData.fromJson(core.Map json_)
: this(
columnHeaders: json_.containsKey('columnHeaders')
? (json_['columnHeaders'] as core.List)
.map((value) => McfDataColumnHeaders.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
containsSampledData: json_.containsKey('containsSampledData')
? json_['containsSampledData'] as core.bool
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
profileInfo: json_.containsKey('profileInfo')
? McfDataProfileInfo.fromJson(
json_['profileInfo'] as core.Map<core.String, core.dynamic>)
: null,
query: json_.containsKey('query')
? McfDataQuery.fromJson(
json_['query'] as core.Map<core.String, core.dynamic>)
: null,
rows: json_.containsKey('rows')
? (json_['rows'] as core.List)
.map((value) => (value as core.List)
.map((value) => McfDataRows.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList())
.toList()
: null,
sampleSize: json_.containsKey('sampleSize')
? json_['sampleSize'] as core.String
: null,
sampleSpace: json_.containsKey('sampleSpace')
? json_['sampleSpace'] as core.String
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
totalsForAllResults: json_.containsKey('totalsForAllResults')
? (json_['totalsForAllResults']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnHeaders != null) 'columnHeaders': columnHeaders!,
if (containsSampledData != null)
'containsSampledData': containsSampledData!,
if (id != null) 'id': id!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (profileInfo != null) 'profileInfo': profileInfo!,
if (query != null) 'query': query!,
if (rows != null) 'rows': rows!,
if (sampleSize != null) 'sampleSize': sampleSize!,
if (sampleSpace != null) 'sampleSpace': sampleSpace!,
if (selfLink != null) 'selfLink': selfLink!,
if (totalResults != null) 'totalResults': totalResults!,
if (totalsForAllResults != null)
'totalsForAllResults': totalsForAllResults!,
};
}
/// Child link for this view (profile).
///
/// Points to the list of goals for this view (profile).
class ProfileChildLink {
/// Link to the list of goals for this view (profile).
core.String? href;
/// Value is "analytics#goals".
core.String? type;
ProfileChildLink({
this.href,
this.type,
});
ProfileChildLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Parent link for this view (profile).
///
/// Points to the web property to which this view (profile) belongs.
class ProfileParentLink {
/// Link to the web property to which this view (profile) belongs.
core.String? href;
/// Value is "analytics#webproperty".
core.String? type;
ProfileParentLink({
this.href,
this.type,
});
ProfileParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Permissions the user has for this view (profile).
class ProfilePermissions {
/// All the permissions that the user has for this view (profile).
///
/// These include any implied permissions (e.g., EDIT implies VIEW) or
/// inherited permissions from the parent web property.
core.List<core.String>? effective;
ProfilePermissions({
this.effective,
});
ProfilePermissions.fromJson(core.Map json_)
: this(
effective: json_.containsKey('effective')
? (json_['effective'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (effective != null) 'effective': effective!,
};
}
/// JSON template for an Analytics view (profile).
class Profile {
/// Account ID to which this view (profile) belongs.
core.String? accountId;
/// Indicates whether bot filtering is enabled for this view (profile).
core.bool? botFilteringEnabled;
/// Child link for this view (profile).
///
/// Points to the list of goals for this view (profile).
ProfileChildLink? childLink;
/// Time this view (profile) was created.
core.DateTime? created;
/// The currency type associated with this view (profile), defaults to USD.
///
/// The supported values are:
/// USD, JPY, EUR, GBP, AUD, KRW, BRL, CNY, DKK, RUB, SEK, NOK, PLN, TRY, TWD,
/// HKD, THB, IDR, ARS, MXN, VND, PHP, INR, CHF, CAD, CZK, NZD, HUF, BGN, LTL,
/// ZAR, UAH, AED, BOB, CLP, COP, EGP, HRK, ILS, MAD, MYR, PEN, PKR, RON, RSD,
/// SAR, SGD, VEF, LVL
core.String? currency;
/// Default page for this view (profile).
core.String? defaultPage;
/// Indicates whether ecommerce tracking is enabled for this view (profile).
core.bool? eCommerceTracking;
/// Indicates whether enhanced ecommerce tracking is enabled for this view
/// (profile).
///
/// This property can only be enabled if ecommerce tracking is enabled.
core.bool? enhancedECommerceTracking;
/// The query parameters that are excluded from this view (profile).
core.String? excludeQueryParameters;
/// View (Profile) ID.
core.String? id;
/// Internal ID for the web property to which this view (profile) belongs.
core.String? internalWebPropertyId;
/// Resource type for Analytics view (profile).
core.String? kind;
/// Name of this view (profile).
core.String? name;
/// Parent link for this view (profile).
///
/// Points to the web property to which this view (profile) belongs.
ProfileParentLink? parentLink;
/// Permissions the user has for this view (profile).
ProfilePermissions? permissions;
/// Link for this view (profile).
core.String? selfLink;
/// Site search category parameters for this view (profile).
core.String? siteSearchCategoryParameters;
/// The site search query parameters for this view (profile).
core.String? siteSearchQueryParameters;
/// Indicates whether this view (profile) is starred or not.
core.bool? starred;
/// Whether or not Analytics will strip search category parameters from the
/// URLs in your reports.
core.bool? stripSiteSearchCategoryParameters;
/// Whether or not Analytics will strip search query parameters from the URLs
/// in your reports.
core.bool? stripSiteSearchQueryParameters;
/// Time zone for which this view (profile) has been configured.
///
/// Time zones are identified by strings from the TZ database.
core.String? timezone;
/// View (Profile) type.
///
/// Supported types: WEB or APP.
core.String? type;
/// Time this view (profile) was last modified.
core.DateTime? updated;
/// Web property ID of the form UA-XXXXX-YY to which this view (profile)
/// belongs.
core.String? webPropertyId;
/// Website URL for this view (profile).
core.String? websiteUrl;
Profile({
this.accountId,
this.botFilteringEnabled,
this.childLink,
this.created,
this.currency,
this.defaultPage,
this.eCommerceTracking,
this.enhancedECommerceTracking,
this.excludeQueryParameters,
this.id,
this.internalWebPropertyId,
this.kind,
this.name,
this.parentLink,
this.permissions,
this.selfLink,
this.siteSearchCategoryParameters,
this.siteSearchQueryParameters,
this.starred,
this.stripSiteSearchCategoryParameters,
this.stripSiteSearchQueryParameters,
this.timezone,
this.type,
this.updated,
this.webPropertyId,
this.websiteUrl,
});
Profile.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
botFilteringEnabled: json_.containsKey('botFilteringEnabled')
? json_['botFilteringEnabled'] as core.bool
: null,
childLink: json_.containsKey('childLink')
? ProfileChildLink.fromJson(
json_['childLink'] as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
currency: json_.containsKey('currency')
? json_['currency'] as core.String
: null,
defaultPage: json_.containsKey('defaultPage')
? json_['defaultPage'] as core.String
: null,
eCommerceTracking: json_.containsKey('eCommerceTracking')
? json_['eCommerceTracking'] as core.bool
: null,
enhancedECommerceTracking:
json_.containsKey('enhancedECommerceTracking')
? json_['enhancedECommerceTracking'] as core.bool
: null,
excludeQueryParameters: json_.containsKey('excludeQueryParameters')
? json_['excludeQueryParameters'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? ProfileParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
permissions: json_.containsKey('permissions')
? ProfilePermissions.fromJson(
json_['permissions'] as core.Map<core.String, core.dynamic>)
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
siteSearchCategoryParameters:
json_.containsKey('siteSearchCategoryParameters')
? json_['siteSearchCategoryParameters'] as core.String
: null,
siteSearchQueryParameters:
json_.containsKey('siteSearchQueryParameters')
? json_['siteSearchQueryParameters'] as core.String
: null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
stripSiteSearchCategoryParameters:
json_.containsKey('stripSiteSearchCategoryParameters')
? json_['stripSiteSearchCategoryParameters'] as core.bool
: null,
stripSiteSearchQueryParameters:
json_.containsKey('stripSiteSearchQueryParameters')
? json_['stripSiteSearchQueryParameters'] as core.bool
: null,
timezone: json_.containsKey('timezone')
? json_['timezone'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
websiteUrl: json_.containsKey('websiteUrl')
? json_['websiteUrl'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (botFilteringEnabled != null)
'botFilteringEnabled': botFilteringEnabled!,
if (childLink != null) 'childLink': childLink!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (currency != null) 'currency': currency!,
if (defaultPage != null) 'defaultPage': defaultPage!,
if (eCommerceTracking != null) 'eCommerceTracking': eCommerceTracking!,
if (enhancedECommerceTracking != null)
'enhancedECommerceTracking': enhancedECommerceTracking!,
if (excludeQueryParameters != null)
'excludeQueryParameters': excludeQueryParameters!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (permissions != null) 'permissions': permissions!,
if (selfLink != null) 'selfLink': selfLink!,
if (siteSearchCategoryParameters != null)
'siteSearchCategoryParameters': siteSearchCategoryParameters!,
if (siteSearchQueryParameters != null)
'siteSearchQueryParameters': siteSearchQueryParameters!,
if (starred != null) 'starred': starred!,
if (stripSiteSearchCategoryParameters != null)
'stripSiteSearchCategoryParameters':
stripSiteSearchCategoryParameters!,
if (stripSiteSearchQueryParameters != null)
'stripSiteSearchQueryParameters': stripSiteSearchQueryParameters!,
if (timezone != null) 'timezone': timezone!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
if (websiteUrl != null) 'websiteUrl': websiteUrl!,
};
}
/// JSON template for an Analytics profile filter link.
class ProfileFilterLink {
/// Filter for this link.
FilterRef? filterRef;
/// Profile filter link ID.
core.String? id;
/// Resource type for Analytics filter.
core.String? kind;
/// View (Profile) for this link.
ProfileRef? profileRef;
/// The rank of this profile filter link relative to the other filters linked
/// to the same profile.
/// For readonly (i.e., list and get) operations, the rank always starts at 1.
/// For write (i.e., create, update, or delete) operations, you may specify a
/// value between 0 and 255 inclusively, \[0, 255\].
///
/// In order to insert a link at the end of the list, either don't specify a
/// rank or set a rank to a number greater than the largest rank in the list.
/// In order to insert a link to the beginning of the list specify a rank that
/// is less than or equal to 1. The new link will move all existing filters
/// with the same or lower rank down the list. After the link is
/// inserted/updated/deleted all profile filter links will be renumbered
/// starting at 1.
core.int? rank;
/// Link for this profile filter link.
core.String? selfLink;
ProfileFilterLink({
this.filterRef,
this.id,
this.kind,
this.profileRef,
this.rank,
this.selfLink,
});
ProfileFilterLink.fromJson(core.Map json_)
: this(
filterRef: json_.containsKey('filterRef')
? FilterRef.fromJson(
json_['filterRef'] as core.Map<core.String, core.dynamic>)
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profileRef: json_.containsKey('profileRef')
? ProfileRef.fromJson(
json_['profileRef'] as core.Map<core.String, core.dynamic>)
: null,
rank: json_.containsKey('rank') ? json_['rank'] as core.int : null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (filterRef != null) 'filterRef': filterRef!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (profileRef != null) 'profileRef': profileRef!,
if (rank != null) 'rank': rank!,
if (selfLink != null) 'selfLink': selfLink!,
};
}
/// A profile filter link collection lists profile filter links between profiles
/// and filters.
///
/// Each resource in the collection corresponds to a profile filter link.
class ProfileFilterLinks {
/// A list of profile filter links.
core.List<ProfileFilterLink>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1,000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this profile filter link collection.
core.String? nextLink;
/// Link to previous page for this profile filter link collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
ProfileFilterLinks({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
ProfileFilterLinks.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => ProfileFilterLink.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// JSON template for a linked view (profile).
class ProfileRef {
/// Account ID to which this view (profile) belongs.
core.String? accountId;
/// Link for this view (profile).
core.String? href;
/// View (Profile) ID.
core.String? id;
/// Internal ID for the web property to which this view (profile) belongs.
core.String? internalWebPropertyId;
/// Analytics view (profile) reference.
core.String? kind;
/// Name of this view (profile).
core.String? name;
/// Web property ID of the form UA-XXXXX-YY to which this view (profile)
/// belongs.
core.String? webPropertyId;
ProfileRef({
this.accountId,
this.href,
this.id,
this.internalWebPropertyId,
this.kind,
this.name,
this.webPropertyId,
});
ProfileRef.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
href: json_.containsKey('href') ? json_['href'] as core.String : null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (href != null) 'href': href!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// JSON template for an Analytics ProfileSummary.
///
/// ProfileSummary returns basic information (i.e., summary) for a profile.
class ProfileSummary {
/// View (profile) ID.
core.String? id;
/// Resource type for Analytics ProfileSummary.
core.String? kind;
/// View (profile) name.
core.String? name;
/// Indicates whether this view (profile) is starred or not.
core.bool? starred;
/// View (Profile) type.
///
/// Supported types: WEB or APP.
core.String? type;
ProfileSummary({
this.id,
this.kind,
this.name,
this.starred,
this.type,
});
ProfileSummary.fromJson(core.Map json_)
: this(
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (starred != null) 'starred': starred!,
if (type != null) 'type': type!,
};
}
/// A view (profile) collection lists Analytics views (profiles) to which the
/// user has access.
///
/// Each resource in the collection corresponds to a single Analytics view
/// (profile).
class Profiles {
/// A list of views (profiles).
core.List<Profile>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this view (profile) collection.
core.String? nextLink;
/// Link to previous page for this view (profile) collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Profiles({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Profiles.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Profile.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
class RealtimeDataColumnHeaders {
/// Column Type.
///
/// Either DIMENSION or METRIC.
core.String? columnType;
/// Data type.
///
/// Dimension column headers have only STRING as the data type. Metric column
/// headers have data types for metric values such as INTEGER, DOUBLE,
/// CURRENCY etc.
core.String? dataType;
/// Column name.
core.String? name;
RealtimeDataColumnHeaders({
this.columnType,
this.dataType,
this.name,
});
RealtimeDataColumnHeaders.fromJson(core.Map json_)
: this(
columnType: json_.containsKey('columnType')
? json_['columnType'] as core.String
: null,
dataType: json_.containsKey('dataType')
? json_['dataType'] as core.String
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnType != null) 'columnType': columnType!,
if (dataType != null) 'dataType': dataType!,
if (name != null) 'name': name!,
};
}
/// Information for the view (profile), for which the real time data was
/// requested.
class RealtimeDataProfileInfo {
/// Account ID to which this view (profile) belongs.
core.String? accountId;
/// Internal ID for the web property to which this view (profile) belongs.
core.String? internalWebPropertyId;
/// View (Profile) ID.
core.String? profileId;
/// View (Profile) name.
core.String? profileName;
/// Table ID for view (profile).
core.String? tableId;
/// Web Property ID to which this view (profile) belongs.
core.String? webPropertyId;
RealtimeDataProfileInfo({
this.accountId,
this.internalWebPropertyId,
this.profileId,
this.profileName,
this.tableId,
this.webPropertyId,
});
RealtimeDataProfileInfo.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
profileName: json_.containsKey('profileName')
? json_['profileName'] as core.String
: null,
tableId: json_.containsKey('tableId')
? json_['tableId'] as core.String
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (profileId != null) 'profileId': profileId!,
if (profileName != null) 'profileName': profileName!,
if (tableId != null) 'tableId': tableId!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// Real time data request query parameters.
class RealtimeDataQuery {
/// List of real time dimensions.
core.String? dimensions;
/// Comma-separated list of dimension or metric filters.
core.String? filters;
/// Unique table ID.
core.String? ids;
/// Maximum results per page.
core.int? maxResults;
/// List of real time metrics.
core.List<core.String>? metrics;
/// List of dimensions or metrics based on which real time data is sorted.
core.List<core.String>? sort;
RealtimeDataQuery({
this.dimensions,
this.filters,
this.ids,
this.maxResults,
this.metrics,
this.sort,
});
RealtimeDataQuery.fromJson(core.Map json_)
: this(
dimensions: json_.containsKey('dimensions')
? json_['dimensions'] as core.String
: null,
filters: json_.containsKey('filters')
? json_['filters'] as core.String
: null,
ids: json_.containsKey('ids') ? json_['ids'] as core.String : null,
maxResults: json_.containsKey('max-results')
? json_['max-results'] as core.int
: null,
metrics: json_.containsKey('metrics')
? (json_['metrics'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
sort: json_.containsKey('sort')
? (json_['sort'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (dimensions != null) 'dimensions': dimensions!,
if (filters != null) 'filters': filters!,
if (ids != null) 'ids': ids!,
if (maxResults != null) 'max-results': maxResults!,
if (metrics != null) 'metrics': metrics!,
if (sort != null) 'sort': sort!,
};
}
/// Real time data for a given view (profile).
class RealtimeData {
/// Column headers that list dimension names followed by the metric names.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<RealtimeDataColumnHeaders>? columnHeaders;
/// Unique ID for this data response.
core.String? id;
/// Resource type.
core.String? kind;
/// Information for the view (profile), for which the real time data was
/// requested.
RealtimeDataProfileInfo? profileInfo;
/// Real time data request query parameters.
RealtimeDataQuery? query;
/// Real time data rows, where each row contains a list of dimension values
/// followed by the metric values.
///
/// The order of dimensions and metrics is same as specified in the request.
core.List<core.List<core.String>>? rows;
/// Link to this page.
core.String? selfLink;
/// The total number of rows for the query, regardless of the number of rows
/// in the response.
core.int? totalResults;
/// Total values for the requested metrics over all the results, not just the
/// results returned in this response.
///
/// The order of the metric totals is same as the metric order specified in
/// the request.
core.Map<core.String, core.String>? totalsForAllResults;
RealtimeData({
this.columnHeaders,
this.id,
this.kind,
this.profileInfo,
this.query,
this.rows,
this.selfLink,
this.totalResults,
this.totalsForAllResults,
});
RealtimeData.fromJson(core.Map json_)
: this(
columnHeaders: json_.containsKey('columnHeaders')
? (json_['columnHeaders'] as core.List)
.map((value) => RealtimeDataColumnHeaders.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profileInfo: json_.containsKey('profileInfo')
? RealtimeDataProfileInfo.fromJson(
json_['profileInfo'] as core.Map<core.String, core.dynamic>)
: null,
query: json_.containsKey('query')
? RealtimeDataQuery.fromJson(
json_['query'] as core.Map<core.String, core.dynamic>)
: null,
rows: json_.containsKey('rows')
? (json_['rows'] as core.List)
.map((value) => (value as core.List)
.map((value) => value as core.String)
.toList())
.toList()
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
totalsForAllResults: json_.containsKey('totalsForAllResults')
? (json_['totalsForAllResults']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (columnHeaders != null) 'columnHeaders': columnHeaders!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (profileInfo != null) 'profileInfo': profileInfo!,
if (query != null) 'query': query!,
if (rows != null) 'rows': rows!,
if (selfLink != null) 'selfLink': selfLink!,
if (totalResults != null) 'totalResults': totalResults!,
if (totalsForAllResults != null)
'totalsForAllResults': totalsForAllResults!,
};
}
/// The simple audience definition that will cause a user to be added to an
/// audience.
class RemarketingAudienceAudienceDefinition {
/// Defines the conditions to include users to the audience.
IncludeConditions? includeConditions;
RemarketingAudienceAudienceDefinition({
this.includeConditions,
});
RemarketingAudienceAudienceDefinition.fromJson(core.Map json_)
: this(
includeConditions: json_.containsKey('includeConditions')
? IncludeConditions.fromJson(json_['includeConditions']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (includeConditions != null) 'includeConditions': includeConditions!,
};
}
/// Defines the conditions to exclude users from the audience.
class RemarketingAudienceStateBasedAudienceDefinitionExcludeConditions {
/// Whether to make the exclusion TEMPORARY or PERMANENT.
core.String? exclusionDuration;
/// The segment condition that will cause a user to be removed from an
/// audience.
core.String? segment;
RemarketingAudienceStateBasedAudienceDefinitionExcludeConditions({
this.exclusionDuration,
this.segment,
});
RemarketingAudienceStateBasedAudienceDefinitionExcludeConditions.fromJson(
core.Map json_)
: this(
exclusionDuration: json_.containsKey('exclusionDuration')
? json_['exclusionDuration'] as core.String
: null,
segment: json_.containsKey('segment')
? json_['segment'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (exclusionDuration != null) 'exclusionDuration': exclusionDuration!,
if (segment != null) 'segment': segment!,
};
}
/// A state based audience definition that will cause a user to be added or
/// removed from an audience.
class RemarketingAudienceStateBasedAudienceDefinition {
/// Defines the conditions to exclude users from the audience.
RemarketingAudienceStateBasedAudienceDefinitionExcludeConditions?
excludeConditions;
/// Defines the conditions to include users to the audience.
IncludeConditions? includeConditions;
RemarketingAudienceStateBasedAudienceDefinition({
this.excludeConditions,
this.includeConditions,
});
RemarketingAudienceStateBasedAudienceDefinition.fromJson(core.Map json_)
: this(
excludeConditions: json_.containsKey('excludeConditions')
? RemarketingAudienceStateBasedAudienceDefinitionExcludeConditions
.fromJson(json_['excludeConditions']
as core.Map<core.String, core.dynamic>)
: null,
includeConditions: json_.containsKey('includeConditions')
? IncludeConditions.fromJson(json_['includeConditions']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (excludeConditions != null) 'excludeConditions': excludeConditions!,
if (includeConditions != null) 'includeConditions': includeConditions!,
};
}
/// JSON template for an Analytics remarketing audience.
class RemarketingAudience {
/// Account ID to which this remarketing audience belongs.
core.String? accountId;
/// The simple audience definition that will cause a user to be added to an
/// audience.
RemarketingAudienceAudienceDefinition? audienceDefinition;
/// The type of audience, either SIMPLE or STATE_BASED.
core.String? audienceType;
/// Time this remarketing audience was created.
core.DateTime? created;
/// The description of this remarketing audience.
core.String? description;
/// Remarketing Audience ID.
core.String? id;
/// Internal ID for the web property to which this remarketing audience
/// belongs.
core.String? internalWebPropertyId;
/// Collection type.
core.String? kind;
/// The linked ad accounts associated with this remarketing audience.
///
/// A remarketing audience can have only one linkedAdAccount currently.
core.List<LinkedForeignAccount>? linkedAdAccounts;
/// The views (profiles) that this remarketing audience is linked to.
core.List<core.String>? linkedViews;
/// The name of this remarketing audience.
core.String? name;
/// A state based audience definition that will cause a user to be added or
/// removed from an audience.
RemarketingAudienceStateBasedAudienceDefinition? stateBasedAudienceDefinition;
/// Time this remarketing audience was last modified.
core.DateTime? updated;
/// Web property ID of the form UA-XXXXX-YY to which this remarketing audience
/// belongs.
core.String? webPropertyId;
RemarketingAudience({
this.accountId,
this.audienceDefinition,
this.audienceType,
this.created,
this.description,
this.id,
this.internalWebPropertyId,
this.kind,
this.linkedAdAccounts,
this.linkedViews,
this.name,
this.stateBasedAudienceDefinition,
this.updated,
this.webPropertyId,
});
RemarketingAudience.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
audienceDefinition: json_.containsKey('audienceDefinition')
? RemarketingAudienceAudienceDefinition.fromJson(
json_['audienceDefinition']
as core.Map<core.String, core.dynamic>)
: null,
audienceType: json_.containsKey('audienceType')
? json_['audienceType'] as core.String
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
linkedAdAccounts: json_.containsKey('linkedAdAccounts')
? (json_['linkedAdAccounts'] as core.List)
.map((value) => LinkedForeignAccount.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
linkedViews: json_.containsKey('linkedViews')
? (json_['linkedViews'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
stateBasedAudienceDefinition:
json_.containsKey('stateBasedAudienceDefinition')
? RemarketingAudienceStateBasedAudienceDefinition.fromJson(
json_['stateBasedAudienceDefinition']
as core.Map<core.String, core.dynamic>)
: null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (audienceDefinition != null)
'audienceDefinition': audienceDefinition!,
if (audienceType != null) 'audienceType': audienceType!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (description != null) 'description': description!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (linkedAdAccounts != null) 'linkedAdAccounts': linkedAdAccounts!,
if (linkedViews != null) 'linkedViews': linkedViews!,
if (name != null) 'name': name!,
if (stateBasedAudienceDefinition != null)
'stateBasedAudienceDefinition': stateBasedAudienceDefinition!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// A remarketing audience collection lists Analytics remarketing audiences to
/// which the user has access.
///
/// Each resource in the collection corresponds to a single Analytics
/// remarketing audience.
class RemarketingAudiences {
/// A list of remarketing audiences.
core.List<RemarketingAudience>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this remarketing audience collection.
core.String? nextLink;
/// Link to previous page for this view (profile) collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
RemarketingAudiences({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
RemarketingAudiences.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => RemarketingAudience.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// JSON template for an Analytics segment.
class Segment {
/// Time the segment was created.
core.DateTime? created;
/// Segment definition.
core.String? definition;
/// Segment ID.
core.String? id;
/// Resource type for Analytics segment.
core.String? kind;
/// Segment name.
core.String? name;
/// Segment ID.
///
/// Can be used with the 'segment' parameter in Core Reporting API.
core.String? segmentId;
/// Link for this segment.
core.String? selfLink;
/// Type for a segment.
///
/// Possible values are "BUILT_IN" or "CUSTOM".
core.String? type;
/// Time the segment was last modified.
core.DateTime? updated;
Segment({
this.created,
this.definition,
this.id,
this.kind,
this.name,
this.segmentId,
this.selfLink,
this.type,
this.updated,
});
Segment.fromJson(core.Map json_)
: this(
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
definition: json_.containsKey('definition')
? json_['definition'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
segmentId: json_.containsKey('segmentId')
? json_['segmentId'] as core.String
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (definition != null) 'definition': definition!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (segmentId != null) 'segmentId': segmentId!,
if (selfLink != null) 'selfLink': selfLink!,
if (type != null) 'type': type!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
};
}
/// An segment collection lists Analytics segments that the user has access to.
///
/// Each resource in the collection corresponds to a single Analytics segment.
class Segments {
/// A list of segments.
core.List<Segment>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type for segments.
core.String? kind;
/// Link to next page for this segment collection.
core.String? nextLink;
/// Link to previous page for this segment collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Segments({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Segments.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Segment.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Download details for a file stored in Google Cloud Storage.
class UnsampledReportCloudStorageDownloadDetails {
/// Id of the bucket the file object is stored in.
core.String? bucketId;
/// Id of the file object containing the report data.
core.String? objectId;
UnsampledReportCloudStorageDownloadDetails({
this.bucketId,
this.objectId,
});
UnsampledReportCloudStorageDownloadDetails.fromJson(core.Map json_)
: this(
bucketId: json_.containsKey('bucketId')
? json_['bucketId'] as core.String
: null,
objectId: json_.containsKey('objectId')
? json_['objectId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (bucketId != null) 'bucketId': bucketId!,
if (objectId != null) 'objectId': objectId!,
};
}
/// Download details for a file stored in Google Drive.
class UnsampledReportDriveDownloadDetails {
/// Id of the document/file containing the report data.
core.String? documentId;
UnsampledReportDriveDownloadDetails({
this.documentId,
});
UnsampledReportDriveDownloadDetails.fromJson(core.Map json_)
: this(
documentId: json_.containsKey('documentId')
? json_['documentId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (documentId != null) 'documentId': documentId!,
};
}
/// JSON template for Analytics unsampled report resource.
class UnsampledReport {
/// Account ID to which this unsampled report belongs.
core.String? accountId;
/// Download details for a file stored in Google Cloud Storage.
UnsampledReportCloudStorageDownloadDetails? cloudStorageDownloadDetails;
/// Time this unsampled report was created.
core.DateTime? created;
/// The dimensions for the unsampled report.
core.String? dimensions;
/// The type of download you need to use for the report data file.
///
/// Possible values include `GOOGLE_DRIVE` and `GOOGLE_CLOUD_STORAGE`. If the
/// value is `GOOGLE_DRIVE`, see the `driveDownloadDetails` field. If the
/// value is `GOOGLE_CLOUD_STORAGE`, see the `cloudStorageDownloadDetails`
/// field.
core.String? downloadType;
/// Download details for a file stored in Google Drive.
UnsampledReportDriveDownloadDetails? driveDownloadDetails;
/// The end date for the unsampled report.
core.String? endDate;
/// The filters for the unsampled report.
core.String? filters;
/// Unsampled report ID.
core.String? id;
/// Resource type for an Analytics unsampled report.
core.String? kind;
/// The metrics for the unsampled report.
core.String? metrics;
/// View (Profile) ID to which this unsampled report belongs.
core.String? profileId;
/// The segment for the unsampled report.
core.String? segment;
/// Link for this unsampled report.
core.String? selfLink;
/// The start date for the unsampled report.
core.String? startDate;
/// Status of this unsampled report.
///
/// Possible values are PENDING, COMPLETED, or FAILED.
core.String? status;
/// Title of the unsampled report.
core.String? title;
/// Time this unsampled report was last modified.
core.DateTime? updated;
/// Web property ID to which this unsampled report belongs.
///
/// The web property ID is of the form UA-XXXXX-YY.
core.String? webPropertyId;
UnsampledReport({
this.accountId,
this.cloudStorageDownloadDetails,
this.created,
this.dimensions,
this.downloadType,
this.driveDownloadDetails,
this.endDate,
this.filters,
this.id,
this.kind,
this.metrics,
this.profileId,
this.segment,
this.selfLink,
this.startDate,
this.status,
this.title,
this.updated,
this.webPropertyId,
});
UnsampledReport.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
cloudStorageDownloadDetails:
json_.containsKey('cloudStorageDownloadDetails')
? UnsampledReportCloudStorageDownloadDetails.fromJson(
json_['cloudStorageDownloadDetails']
as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
dimensions: json_.containsKey('dimensions')
? json_['dimensions'] as core.String
: null,
downloadType: json_.containsKey('downloadType')
? json_['downloadType'] as core.String
: null,
driveDownloadDetails: json_.containsKey('driveDownloadDetails')
? UnsampledReportDriveDownloadDetails.fromJson(
json_['driveDownloadDetails']
as core.Map<core.String, core.dynamic>)
: null,
endDate: json_.containsKey('end-date')
? json_['end-date'] as core.String
: null,
filters: json_.containsKey('filters')
? json_['filters'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
metrics: json_.containsKey('metrics')
? json_['metrics'] as core.String
: null,
profileId: json_.containsKey('profileId')
? json_['profileId'] as core.String
: null,
segment: json_.containsKey('segment')
? json_['segment'] as core.String
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
startDate: json_.containsKey('start-date')
? json_['start-date'] as core.String
: null,
status: json_.containsKey('status')
? json_['status'] as core.String
: null,
title:
json_.containsKey('title') ? json_['title'] as core.String : null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (cloudStorageDownloadDetails != null)
'cloudStorageDownloadDetails': cloudStorageDownloadDetails!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (dimensions != null) 'dimensions': dimensions!,
if (downloadType != null) 'downloadType': downloadType!,
if (driveDownloadDetails != null)
'driveDownloadDetails': driveDownloadDetails!,
if (endDate != null) 'end-date': endDate!,
if (filters != null) 'filters': filters!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (metrics != null) 'metrics': metrics!,
if (profileId != null) 'profileId': profileId!,
if (segment != null) 'segment': segment!,
if (selfLink != null) 'selfLink': selfLink!,
if (startDate != null) 'start-date': startDate!,
if (status != null) 'status': status!,
if (title != null) 'title': title!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// An unsampled report collection lists Analytics unsampled reports to which
/// the user has access.
///
/// Each view (profile) can have a set of unsampled reports. Each resource in
/// the unsampled report collection corresponds to a single Analytics unsampled
/// report.
class UnsampledReports {
/// A list of unsampled reports.
core.List<UnsampledReport>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this unsampled report collection.
core.String? nextLink;
/// Link to previous page for this unsampled report collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// resources in the result.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
UnsampledReports({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
UnsampledReports.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => UnsampledReport.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Metadata returned for an upload operation.
class Upload {
/// Account Id to which this upload belongs.
core.String? accountId;
/// Custom data source Id to which this data import belongs.
core.String? customDataSourceId;
/// Data import errors collection.
core.List<core.String>? errors;
/// A unique ID for this upload.
core.String? id;
/// Resource type for Analytics upload.
core.String? kind;
/// Upload status.
///
/// Possible values: PENDING, COMPLETED, FAILED, DELETING, DELETED.
core.String? status;
/// Time this file is uploaded.
core.DateTime? uploadTime;
Upload({
this.accountId,
this.customDataSourceId,
this.errors,
this.id,
this.kind,
this.status,
this.uploadTime,
});
Upload.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
customDataSourceId: json_.containsKey('customDataSourceId')
? json_['customDataSourceId'] as core.String
: null,
errors: json_.containsKey('errors')
? (json_['errors'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
status: json_.containsKey('status')
? json_['status'] as core.String
: null,
uploadTime: json_.containsKey('uploadTime')
? core.DateTime.parse(json_['uploadTime'] as core.String)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (customDataSourceId != null)
'customDataSourceId': customDataSourceId!,
if (errors != null) 'errors': errors!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (status != null) 'status': status!,
if (uploadTime != null)
'uploadTime': uploadTime!.toUtc().toIso8601String(),
};
}
/// Upload collection lists Analytics uploads to which the user has access.
///
/// Each custom data source can have a set of uploads. Each resource in the
/// upload collection corresponds to a single Analytics data upload.
class Uploads {
/// A list of uploads.
core.List<Upload>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this upload collection.
core.String? nextLink;
/// Link to previous page for this upload collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// resources in the result.
core.int? totalResults;
Uploads({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
});
Uploads.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Upload.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
};
}
/// User ID.
class UserDeletionRequestId {
/// Type of user
core.String? type;
/// The User's id
core.String? userId;
UserDeletionRequestId({
this.type,
this.userId,
});
UserDeletionRequestId.fromJson(core.Map json_)
: this(
type: json_.containsKey('type') ? json_['type'] as core.String : null,
userId: json_.containsKey('userId')
? json_['userId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (type != null) 'type': type!,
if (userId != null) 'userId': userId!,
};
}
/// JSON template for a user deletion request resource.
class UserDeletionRequest {
/// This marks the point in time for which all user data before should be
/// deleted
core.DateTime? deletionRequestTime;
/// Firebase Project Id
core.String? firebaseProjectId;
/// User ID.
UserDeletionRequestId? id;
/// Value is "analytics#userDeletionRequest".
core.String? kind;
/// Property ID
core.String? propertyId;
/// Web property ID of the form UA-XXXXX-YY.
core.String? webPropertyId;
UserDeletionRequest({
this.deletionRequestTime,
this.firebaseProjectId,
this.id,
this.kind,
this.propertyId,
this.webPropertyId,
});
UserDeletionRequest.fromJson(core.Map json_)
: this(
deletionRequestTime: json_.containsKey('deletionRequestTime')
? core.DateTime.parse(json_['deletionRequestTime'] as core.String)
: null,
firebaseProjectId: json_.containsKey('firebaseProjectId')
? json_['firebaseProjectId'] as core.String
: null,
id: json_.containsKey('id')
? UserDeletionRequestId.fromJson(
json_['id'] as core.Map<core.String, core.dynamic>)
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
propertyId: json_.containsKey('propertyId')
? json_['propertyId'] as core.String
: null,
webPropertyId: json_.containsKey('webPropertyId')
? json_['webPropertyId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (deletionRequestTime != null)
'deletionRequestTime': deletionRequestTime!.toUtc().toIso8601String(),
if (firebaseProjectId != null) 'firebaseProjectId': firebaseProjectId!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
if (propertyId != null) 'propertyId': propertyId!,
if (webPropertyId != null) 'webPropertyId': webPropertyId!,
};
}
/// JSON template for a user reference.
class UserRef {
/// Email ID of this user.
core.String? email;
/// User ID.
core.String? id;
core.String? kind;
UserRef({
this.email,
this.id,
this.kind,
});
UserRef.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (id != null) 'id': id!,
if (kind != null) 'kind': kind!,
};
}
/// JSON template for a web property reference.
class WebPropertyRef {
/// Account ID to which this web property belongs.
core.String? accountId;
/// Link for this web property.
core.String? href;
/// Web property ID of the form UA-XXXXX-YY.
core.String? id;
/// Internal ID for this web property.
core.String? internalWebPropertyId;
/// Analytics web property reference.
core.String? kind;
/// Name of this web property.
core.String? name;
WebPropertyRef({
this.accountId,
this.href,
this.id,
this.internalWebPropertyId,
this.kind,
this.name,
});
WebPropertyRef.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
href: json_.containsKey('href') ? json_['href'] as core.String : null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (href != null) 'href': href!,
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
};
}
/// JSON template for an Analytics WebPropertySummary.
///
/// WebPropertySummary returns basic information (i.e., summary) for a web
/// property.
class WebPropertySummary {
/// Web property ID of the form UA-XXXXX-YY.
core.String? id;
/// Internal ID for this web property.
core.String? internalWebPropertyId;
/// Resource type for Analytics WebPropertySummary.
core.String? kind;
/// Level for this web property.
///
/// Possible values are STANDARD or PREMIUM.
core.String? level;
/// Web property name.
core.String? name;
/// List of profiles under this web property.
core.List<ProfileSummary>? profiles;
/// Indicates whether this web property is starred or not.
core.bool? starred;
/// Website url for this web property.
core.String? websiteUrl;
WebPropertySummary({
this.id,
this.internalWebPropertyId,
this.kind,
this.level,
this.name,
this.profiles,
this.starred,
this.websiteUrl,
});
WebPropertySummary.fromJson(core.Map json_)
: this(
id: json_.containsKey('id') ? json_['id'] as core.String : null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
level:
json_.containsKey('level') ? json_['level'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
profiles: json_.containsKey('profiles')
? (json_['profiles'] as core.List)
.map((value) => ProfileSummary.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
websiteUrl: json_.containsKey('websiteUrl')
? json_['websiteUrl'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (id != null) 'id': id!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (level != null) 'level': level!,
if (name != null) 'name': name!,
if (profiles != null) 'profiles': profiles!,
if (starred != null) 'starred': starred!,
if (websiteUrl != null) 'websiteUrl': websiteUrl!,
};
}
/// A web property collection lists Analytics web properties to which the user
/// has access.
///
/// Each resource in the collection corresponds to a single Analytics web
/// property.
class Webproperties {
/// A list of web properties.
core.List<Webproperty>? items;
/// The maximum number of resources the response can contain, regardless of
/// the actual number of resources returned.
///
/// Its value ranges from 1 to 1000 with a value of 1000 by default, or
/// otherwise specified by the max-results query parameter.
core.int? itemsPerPage;
/// Collection type.
core.String? kind;
/// Link to next page for this web property collection.
core.String? nextLink;
/// Link to previous page for this web property collection.
core.String? previousLink;
/// The starting index of the resources, which is 1 by default or otherwise
/// specified by the start-index query parameter.
core.int? startIndex;
/// The total number of results for the query, regardless of the number of
/// results in the response.
core.int? totalResults;
/// Email ID of the authenticated user
core.String? username;
Webproperties({
this.items,
this.itemsPerPage,
this.kind,
this.nextLink,
this.previousLink,
this.startIndex,
this.totalResults,
this.username,
});
Webproperties.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => Webproperty.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
itemsPerPage: json_.containsKey('itemsPerPage')
? json_['itemsPerPage'] as core.int
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextLink: json_.containsKey('nextLink')
? json_['nextLink'] as core.String
: null,
previousLink: json_.containsKey('previousLink')
? json_['previousLink'] as core.String
: null,
startIndex: json_.containsKey('startIndex')
? json_['startIndex'] as core.int
: null,
totalResults: json_.containsKey('totalResults')
? json_['totalResults'] as core.int
: null,
username: json_.containsKey('username')
? json_['username'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (itemsPerPage != null) 'itemsPerPage': itemsPerPage!,
if (kind != null) 'kind': kind!,
if (nextLink != null) 'nextLink': nextLink!,
if (previousLink != null) 'previousLink': previousLink!,
if (startIndex != null) 'startIndex': startIndex!,
if (totalResults != null) 'totalResults': totalResults!,
if (username != null) 'username': username!,
};
}
/// Child link for this web property.
///
/// Points to the list of views (profiles) for this web property.
class WebpropertyChildLink {
/// Link to the list of views (profiles) for this web property.
core.String? href;
/// Type of the parent link.
///
/// Its value is "analytics#profiles".
core.String? type;
WebpropertyChildLink({
this.href,
this.type,
});
WebpropertyChildLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Parent link for this web property.
///
/// Points to the account to which this web property belongs.
class WebpropertyParentLink {
/// Link to the account for this web property.
core.String? href;
/// Type of the parent link.
///
/// Its value is "analytics#account".
core.String? type;
WebpropertyParentLink({
this.href,
this.type,
});
WebpropertyParentLink.fromJson(core.Map json_)
: this(
href: json_.containsKey('href') ? json_['href'] as core.String : null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (href != null) 'href': href!,
if (type != null) 'type': type!,
};
}
/// Permissions the user has for this web property.
class WebpropertyPermissions {
/// All the permissions that the user has for this web property.
///
/// These include any implied permissions (e.g., EDIT implies VIEW) or
/// inherited permissions from the parent account.
core.List<core.String>? effective;
WebpropertyPermissions({
this.effective,
});
WebpropertyPermissions.fromJson(core.Map json_)
: this(
effective: json_.containsKey('effective')
? (json_['effective'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (effective != null) 'effective': effective!,
};
}
/// JSON template for an Analytics web property.
class Webproperty {
/// Account ID to which this web property belongs.
core.String? accountId;
/// Child link for this web property.
///
/// Points to the list of views (profiles) for this web property.
WebpropertyChildLink? childLink;
/// Time this web property was created.
core.DateTime? created;
/// Set to true to reset the retention period of the user identifier with each
/// new event from that user (thus setting the expiration date to current time
/// plus retention period).
/// Set to false to delete data associated with the user identifier
/// automatically after the rentention period.
/// This property cannot be set on insert.
core.bool? dataRetentionResetOnNewActivity;
/// The length of time for which user and event data is retained.
/// This property cannot be set on insert.
core.String? dataRetentionTtl;
/// Default view (profile) ID.
core.String? defaultProfileId;
/// Web property ID of the form UA-XXXXX-YY.
core.String? id;
/// The industry vertical/category selected for this web property.
core.String? industryVertical;
/// Internal ID for this web property.
core.String? internalWebPropertyId;
/// Resource type for Analytics WebProperty.
core.String? kind;
/// Level for this web property.
///
/// Possible values are STANDARD or PREMIUM.
core.String? level;
/// Name of this web property.
core.String? name;
/// Parent link for this web property.
///
/// Points to the account to which this web property belongs.
WebpropertyParentLink? parentLink;
/// Permissions the user has for this web property.
WebpropertyPermissions? permissions;
/// View (Profile) count for this web property.
core.int? profileCount;
/// Link for this web property.
core.String? selfLink;
/// Indicates whether this web property is starred or not.
core.bool? starred;
/// Time this web property was last modified.
core.DateTime? updated;
/// Website url for this web property.
core.String? websiteUrl;
Webproperty({
this.accountId,
this.childLink,
this.created,
this.dataRetentionResetOnNewActivity,
this.dataRetentionTtl,
this.defaultProfileId,
this.id,
this.industryVertical,
this.internalWebPropertyId,
this.kind,
this.level,
this.name,
this.parentLink,
this.permissions,
this.profileCount,
this.selfLink,
this.starred,
this.updated,
this.websiteUrl,
});
Webproperty.fromJson(core.Map json_)
: this(
accountId: json_.containsKey('accountId')
? json_['accountId'] as core.String
: null,
childLink: json_.containsKey('childLink')
? WebpropertyChildLink.fromJson(
json_['childLink'] as core.Map<core.String, core.dynamic>)
: null,
created: json_.containsKey('created')
? core.DateTime.parse(json_['created'] as core.String)
: null,
dataRetentionResetOnNewActivity:
json_.containsKey('dataRetentionResetOnNewActivity')
? json_['dataRetentionResetOnNewActivity'] as core.bool
: null,
dataRetentionTtl: json_.containsKey('dataRetentionTtl')
? json_['dataRetentionTtl'] as core.String
: null,
defaultProfileId: json_.containsKey('defaultProfileId')
? json_['defaultProfileId'] as core.String
: null,
id: json_.containsKey('id') ? json_['id'] as core.String : null,
industryVertical: json_.containsKey('industryVertical')
? json_['industryVertical'] as core.String
: null,
internalWebPropertyId: json_.containsKey('internalWebPropertyId')
? json_['internalWebPropertyId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
level:
json_.containsKey('level') ? json_['level'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parentLink: json_.containsKey('parentLink')
? WebpropertyParentLink.fromJson(
json_['parentLink'] as core.Map<core.String, core.dynamic>)
: null,
permissions: json_.containsKey('permissions')
? WebpropertyPermissions.fromJson(
json_['permissions'] as core.Map<core.String, core.dynamic>)
: null,
profileCount: json_.containsKey('profileCount')
? json_['profileCount'] as core.int
: null,
selfLink: json_.containsKey('selfLink')
? json_['selfLink'] as core.String
: null,
starred: json_.containsKey('starred')
? json_['starred'] as core.bool
: null,
updated: json_.containsKey('updated')
? core.DateTime.parse(json_['updated'] as core.String)
: null,
websiteUrl: json_.containsKey('websiteUrl')
? json_['websiteUrl'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accountId != null) 'accountId': accountId!,
if (childLink != null) 'childLink': childLink!,
if (created != null) 'created': created!.toUtc().toIso8601String(),
if (dataRetentionResetOnNewActivity != null)
'dataRetentionResetOnNewActivity': dataRetentionResetOnNewActivity!,
if (dataRetentionTtl != null) 'dataRetentionTtl': dataRetentionTtl!,
if (defaultProfileId != null) 'defaultProfileId': defaultProfileId!,
if (id != null) 'id': id!,
if (industryVertical != null) 'industryVertical': industryVertical!,
if (internalWebPropertyId != null)
'internalWebPropertyId': internalWebPropertyId!,
if (kind != null) 'kind': kind!,
if (level != null) 'level': level!,
if (name != null) 'name': name!,
if (parentLink != null) 'parentLink': parentLink!,
if (permissions != null) 'permissions': permissions!,
if (profileCount != null) 'profileCount': profileCount!,
if (selfLink != null) 'selfLink': selfLink!,
if (starred != null) 'starred': starred!,
if (updated != null) 'updated': updated!.toUtc().toIso8601String(),
if (websiteUrl != null) 'websiteUrl': websiteUrl!,
};
}
|
googleapis.dart/generated/googleapis/lib/analytics/v3.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/analytics/v3.dart', 'repo_id': 'googleapis.dart', 'token_count': 150290}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Chrome Policy API - v1
///
/// The Chrome Policy API is a suite of services that allows Chrome
/// administrators to control the policies applied to their managed Chrome OS
/// devices and Chrome browsers.
///
/// For more information, see <https://developers.google.com/chrome/policy>
///
/// Create an instance of [ChromePolicyApi] to access these resources:
///
/// - [CustomersResource]
/// - [CustomersPoliciesResource]
/// - [CustomersPoliciesGroupsResource]
/// - [CustomersPoliciesNetworksResource]
/// - [CustomersPoliciesOrgunitsResource]
/// - [CustomersPolicySchemasResource]
/// - [MediaResource]
library chromepolicy_v1;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../shared.dart';
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show
ApiRequestError,
ByteRange,
DetailedApiRequestError,
DownloadOptions,
Media,
PartialDownloadOptions,
ResumableUploadOptions,
UploadOptions;
/// The Chrome Policy API is a suite of services that allows Chrome
/// administrators to control the policies applied to their managed Chrome OS
/// devices and Chrome browsers.
class ChromePolicyApi {
/// See, edit, create or delete policies applied to Chrome OS and Chrome
/// Browsers managed within your organization
static const chromeManagementPolicyScope =
'https://www.googleapis.com/auth/chrome.management.policy';
/// See policies applied to Chrome OS and Chrome Browsers managed within your
/// organization
static const chromeManagementPolicyReadonlyScope =
'https://www.googleapis.com/auth/chrome.management.policy.readonly';
final commons.ApiRequester _requester;
CustomersResource get customers => CustomersResource(_requester);
MediaResource get media => MediaResource(_requester);
ChromePolicyApi(http.Client client,
{core.String rootUrl = 'https://chromepolicy.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class CustomersResource {
final commons.ApiRequester _requester;
CustomersPoliciesResource get policies =>
CustomersPoliciesResource(_requester);
CustomersPolicySchemasResource get policySchemas =>
CustomersPolicySchemasResource(_requester);
CustomersResource(commons.ApiRequester client) : _requester = client;
}
class CustomersPoliciesResource {
final commons.ApiRequester _requester;
CustomersPoliciesGroupsResource get groups =>
CustomersPoliciesGroupsResource(_requester);
CustomersPoliciesNetworksResource get networks =>
CustomersPoliciesNetworksResource(_requester);
CustomersPoliciesOrgunitsResource get orgunits =>
CustomersPoliciesOrgunitsResource(_requester);
CustomersPoliciesResource(commons.ApiRequester client) : _requester = client;
/// Gets the resolved policy values for a list of policies that match a search
/// query.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - ID of the G Suite account or literal "my_customer" for the
/// customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1ResolveResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1ResolveResponse> resolve(
GoogleChromePolicyVersionsV1ResolveRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$customer') + '/policies:resolve';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1ResolveResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class CustomersPoliciesGroupsResource {
final commons.ApiRequester _requester;
CustomersPoliciesGroupsResource(commons.ApiRequester client)
: _requester = client;
/// Delete multiple policy values that are applied to a specific group.
///
/// All targets must have the same target format. That is to say that they
/// must point to the same target resource and must have the same keys
/// specified in `additionalTargetKeyNames`, though the values for those keys
/// may be different. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - ID of the Google Workspace account or literal "my_customer"
/// for the customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleProtobufEmpty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleProtobufEmpty> batchDelete(
GoogleChromePolicyVersionsV1BatchDeleteGroupPoliciesRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/groups:batchDelete';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleProtobufEmpty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Modify multiple policy values that are applied to a specific group.
///
/// All targets must have the same target format. That is to say that they
/// must point to the same target resource and must have the same keys
/// specified in `additionalTargetKeyNames`, though the values for those keys
/// may be different. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - ID of the Google Workspace account or literal "my_customer"
/// for the customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleProtobufEmpty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleProtobufEmpty> batchModify(
GoogleChromePolicyVersionsV1BatchModifyGroupPoliciesRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/groups:batchModify';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleProtobufEmpty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Retrieve a group priority ordering for an app.
///
/// The target app must be supplied in `additionalTargetKeyNames` in the
/// PolicyTargetKey. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. ID of the Google Workspace account or literal
/// "my_customer" for the customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a
/// [GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse>
listGroupPriorityOrdering(
GoogleChromePolicyVersionsV1ListGroupPriorityOrderingRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/groups:listGroupPriorityOrdering';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse
.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Update a group priority ordering for an app.
///
/// The target app must be supplied in `additionalTargetKeyNames` in the
/// PolicyTargetKey. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. ID of the Google Workspace account or literal
/// "my_customer" for the customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleProtobufEmpty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleProtobufEmpty> updateGroupPriorityOrdering(
GoogleChromePolicyVersionsV1UpdateGroupPriorityOrderingRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/groups:updateGroupPriorityOrdering';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleProtobufEmpty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class CustomersPoliciesNetworksResource {
final commons.ApiRequester _requester;
CustomersPoliciesNetworksResource(commons.ApiRequester client)
: _requester = client;
/// Creates a certificate at a specified OU for a customer.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. The customer for which the certificate will apply.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1DefineCertificateResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1DefineCertificateResponse>
defineCertificate(
GoogleChromePolicyVersionsV1DefineCertificateRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/networks:defineCertificate';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1DefineCertificateResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Define a new network.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. The customer who will own this new network.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1DefineNetworkResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1DefineNetworkResponse> defineNetwork(
GoogleChromePolicyVersionsV1DefineNetworkRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/networks:defineNetwork';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1DefineNetworkResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Remove an existing certificate by guid.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. The customer whose certificate will be removed.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1RemoveCertificateResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1RemoveCertificateResponse>
removeCertificate(
GoogleChromePolicyVersionsV1RemoveCertificateRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/networks:removeCertificate';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1RemoveCertificateResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Remove an existing network by guid.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. The customer whose network will be removed.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1RemoveNetworkResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1RemoveNetworkResponse> removeNetwork(
GoogleChromePolicyVersionsV1RemoveNetworkRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/networks:removeNetwork';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1RemoveNetworkResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class CustomersPoliciesOrgunitsResource {
final commons.ApiRequester _requester;
CustomersPoliciesOrgunitsResource(commons.ApiRequester client)
: _requester = client;
/// Modify multiple policy values that are applied to a specific org unit so
/// that they now inherit the value from a parent (if applicable).
///
/// All targets must have the same target format. That is to say that they
/// must point to the same target resource and must have the same keys
/// specified in `additionalTargetKeyNames`, though the values for those keys
/// may be different. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - ID of the G Suite account or literal "my_customer" for the
/// customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleProtobufEmpty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleProtobufEmpty> batchInherit(
GoogleChromePolicyVersionsV1BatchInheritOrgUnitPoliciesRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/orgunits:batchInherit';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleProtobufEmpty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Modify multiple policy values that are applied to a specific org unit.
///
/// All targets must have the same target format. That is to say that they
/// must point to the same target resource and must have the same keys
/// specified in `additionalTargetKeyNames`, though the values for those keys
/// may be different. On failure the request will return the error details as
/// part of the google.rpc.Status.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - ID of the G Suite account or literal "my_customer" for the
/// customer associated to the request.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleProtobufEmpty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleProtobufEmpty> batchModify(
GoogleChromePolicyVersionsV1BatchModifyOrgUnitPoliciesRequest request,
core.String customer, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/orgunits:batchModify';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GoogleProtobufEmpty.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class CustomersPolicySchemasResource {
final commons.ApiRequester _requester;
CustomersPolicySchemasResource(commons.ApiRequester client)
: _requester = client;
/// Get a specific policy schema for a customer by its resource name.
///
/// Request parameters:
///
/// [name] - Required. The policy schema resource name to query.
/// Value must have pattern `^customers/\[^/\]+/policySchemas/.*$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1PolicySchema].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1PolicySchema> get(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1PolicySchema.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Gets a list of policy schemas that match a specified filter value for a
/// given customer.
///
/// Request parameters:
///
/// [parent] - Required. The customer for which the listing request will
/// apply.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [filter] - The schema filter used to find a particular schema based on
/// fields like its resource name, description and `additionalTargetKeyNames`.
///
/// [pageSize] - The maximum number of policy schemas to return, defaults to
/// 100 and has a maximum of 1000.
///
/// [pageToken] - The page token used to retrieve a specific page of the
/// listing request.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleChromePolicyVersionsV1ListPolicySchemasResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1ListPolicySchemasResponse> list(
core.String parent, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/policySchemas';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return GoogleChromePolicyVersionsV1ListPolicySchemasResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class MediaResource {
final commons.ApiRequester _requester;
MediaResource(commons.ApiRequester client) : _requester = client;
/// Creates an enterprise file from the content provided by user.
///
/// Returns a public download url for end user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [customer] - Required. The customer for which the file upload will apply.
/// Value must have pattern `^customers/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// [uploadMedia] - The media to upload.
///
/// Completes with a [GoogleChromePolicyVersionsV1UploadPolicyFileResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GoogleChromePolicyVersionsV1UploadPolicyFileResponse> upload(
GoogleChromePolicyVersionsV1UploadPolicyFileRequest request,
core.String customer, {
core.String? $fields,
commons.Media? uploadMedia,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
core.String url_;
if (uploadMedia == null) {
url_ = 'v1/' +
core.Uri.encodeFull('$customer') +
'/policies/files:uploadPolicyFile';
} else {
url_ = '/upload/v1/' +
core.Uri.encodeFull('$customer') +
'/policies/files:uploadPolicyFile';
}
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
uploadMedia: uploadMedia,
uploadOptions: commons.UploadOptions.defaultOptions,
);
return GoogleChromePolicyVersionsV1UploadPolicyFileResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ChromeCrosDpanelAutosettingsProtoPolicyApiLifecycle {
/// In the event that this policy was deprecated in favor of another policy,
/// the fully qualified namespace(s) of the new policies as they will show in
/// PolicyAPI.
core.List<core.String>? deprecatedInFavorOf;
/// Description about current life cycle.
core.String? description;
/// End supporting date for current policy.
GoogleTypeDate? endSupport;
/// Indicate current life cycle stage of the policy API.
/// Possible string values are:
/// - "API_UNSPECIFIED" : unspecified.
/// - "API_PREVIEW" : Policy is not working yet, but giving developers heads
/// up on format. This stage can transfer to API_DEVELOPEMNT or API_CURRENT.
/// - "API_DEVELOPMENT" : Policy can change format in backward incompatible
/// way (breaking change). This stage can transfer to API_CURRENT or
/// API_DEPRECATED. This could be used for policies launched only to TTs or
/// launched to selected customers for emergency usage.
/// - "API_CURRENT" : Policy in official format. Policy can change format in
/// backward compatible way (non-breaking change). Example: this policy can
/// introduce a new field, which is considered non-breaking change, when field
/// masks are properly utilized. This stage can transfer to API_DEPRECATED.
/// - "API_DEPRECATED" : Please stop using this policy. This policy is
/// deprecated and may/will be removed in the future. Most likely a new policy
/// was introduced to replace this one.
core.String? policyApiLifecycleStage;
ChromeCrosDpanelAutosettingsProtoPolicyApiLifecycle({
this.deprecatedInFavorOf,
this.description,
this.endSupport,
this.policyApiLifecycleStage,
});
ChromeCrosDpanelAutosettingsProtoPolicyApiLifecycle.fromJson(core.Map json_)
: this(
deprecatedInFavorOf: json_.containsKey('deprecatedInFavorOf')
? (json_['deprecatedInFavorOf'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
endSupport: json_.containsKey('endSupport')
? GoogleTypeDate.fromJson(
json_['endSupport'] as core.Map<core.String, core.dynamic>)
: null,
policyApiLifecycleStage: json_.containsKey('policyApiLifecycleStage')
? json_['policyApiLifecycleStage'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (deprecatedInFavorOf != null)
'deprecatedInFavorOf': deprecatedInFavorOf!,
if (description != null) 'description': description!,
if (endSupport != null) 'endSupport': endSupport!,
if (policyApiLifecycleStage != null)
'policyApiLifecycleStage': policyApiLifecycleStage!,
};
}
/// Additional key names that will be used to identify the target of the policy
/// value.
class GoogleChromePolicyVersionsV1AdditionalTargetKeyName {
/// Key name.
core.String? key;
/// Key description.
core.String? keyDescription;
GoogleChromePolicyVersionsV1AdditionalTargetKeyName({
this.key,
this.keyDescription,
});
GoogleChromePolicyVersionsV1AdditionalTargetKeyName.fromJson(core.Map json_)
: this(
key: json_.containsKey('key') ? json_['key'] as core.String : null,
keyDescription: json_.containsKey('keyDescription')
? json_['keyDescription'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (key != null) 'key': key!,
if (keyDescription != null) 'keyDescription': keyDescription!,
};
}
/// Request message for specifying that multiple policy values will be deleted.
class GoogleChromePolicyVersionsV1BatchDeleteGroupPoliciesRequest {
/// List of policies that will be deleted as defined by the `requests`.
///
/// All requests in the list must follow these restrictions: 1. All schemas in
/// the list must have the same root namespace. 2. All
/// `policyTargetKey.targetResource` values must point to a group resource. 3.
/// All `policyTargetKey` values must have the same `app_id` key name in the
/// `additionalTargetKeys`. 4. No two modification requests can reference the
/// same `policySchema` + ` policyTargetKey` pair.
core.List<GoogleChromePolicyVersionsV1DeleteGroupPolicyRequest>? requests;
GoogleChromePolicyVersionsV1BatchDeleteGroupPoliciesRequest({
this.requests,
});
GoogleChromePolicyVersionsV1BatchDeleteGroupPoliciesRequest.fromJson(
core.Map json_)
: this(
requests: json_.containsKey('requests')
? (json_['requests'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1DeleteGroupPolicyRequest
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (requests != null) 'requests': requests!,
};
}
/// Request message for specifying that multiple policy values inherit their
/// value from their parents.
class GoogleChromePolicyVersionsV1BatchInheritOrgUnitPoliciesRequest {
/// List of policies that have to inherit their values as defined by the
/// `requests`.
///
/// All requests in the list must follow these restrictions: 1. All schemas in
/// the list must have the same root namespace. 2. All
/// `policyTargetKey.targetResource` values must point to an org unit
/// resource. 3. All `policyTargetKey` values must have the same key names in
/// the ` additionalTargetKeys`. This also means if one of the targets has an
/// empty `additionalTargetKeys` map, all of the targets must have an empty
/// `additionalTargetKeys` map. 4. No two modification requests can reference
/// the same `policySchema` + ` policyTargetKey` pair.
core.List<GoogleChromePolicyVersionsV1InheritOrgUnitPolicyRequest>? requests;
GoogleChromePolicyVersionsV1BatchInheritOrgUnitPoliciesRequest({
this.requests,
});
GoogleChromePolicyVersionsV1BatchInheritOrgUnitPoliciesRequest.fromJson(
core.Map json_)
: this(
requests: json_.containsKey('requests')
? (json_['requests'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1InheritOrgUnitPolicyRequest
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (requests != null) 'requests': requests!,
};
}
/// Request message for modifying multiple policy values for a specific
/// group-based target.
class GoogleChromePolicyVersionsV1BatchModifyGroupPoliciesRequest {
/// List of policies to modify as defined by the `requests`.
///
/// All requests in the list must follow these restrictions: 1. All schemas in
/// the list must have the same root namespace. 2. All
/// `policyTargetKey.targetResource` values must point to a group resource. 3.
/// All `policyTargetKey` values must have the same `app_id` key name in the
/// `additionalTargetKeys`. 4. No two modification requests can reference the
/// same `policySchema` + ` policyTargetKey` pair.
core.List<GoogleChromePolicyVersionsV1ModifyGroupPolicyRequest>? requests;
GoogleChromePolicyVersionsV1BatchModifyGroupPoliciesRequest({
this.requests,
});
GoogleChromePolicyVersionsV1BatchModifyGroupPoliciesRequest.fromJson(
core.Map json_)
: this(
requests: json_.containsKey('requests')
? (json_['requests'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1ModifyGroupPolicyRequest
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (requests != null) 'requests': requests!,
};
}
/// Request message for modifying multiple policy values for a specific target.
class GoogleChromePolicyVersionsV1BatchModifyOrgUnitPoliciesRequest {
/// List of policies to modify as defined by the `requests`.
///
/// All requests in the list must follow these restrictions: 1. All schemas in
/// the list must have the same root namespace. 2. All
/// `policyTargetKey.targetResource` values must point to an org unit
/// resource. 3. All `policyTargetKey` values must have the same key names in
/// the ` additionalTargetKeys`. This also means if one of the targets has an
/// empty `additionalTargetKeys` map, all of the targets must have an empty
/// `additionalTargetKeys` map. 4. No two modification requests can reference
/// the same `policySchema` + ` policyTargetKey` pair.
core.List<GoogleChromePolicyVersionsV1ModifyOrgUnitPolicyRequest>? requests;
GoogleChromePolicyVersionsV1BatchModifyOrgUnitPoliciesRequest({
this.requests,
});
GoogleChromePolicyVersionsV1BatchModifyOrgUnitPoliciesRequest.fromJson(
core.Map json_)
: this(
requests: json_.containsKey('requests')
? (json_['requests'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1ModifyOrgUnitPolicyRequest
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (requests != null) 'requests': requests!,
};
}
/// Request object for creating a certificate.
class GoogleChromePolicyVersionsV1DefineCertificateRequest {
/// The optional name of the certificate.
///
/// If not specified, the certificate issuer will be used as the name.
///
/// Optional.
core.String? ceritificateName;
/// The raw contents of the .PEM, .CRT, or .CER file.
///
/// Required.
core.String? certificate;
/// Certificate settings within the chrome.networks.certificates namespace.
///
/// Optional.
core.List<GoogleChromePolicyVersionsV1NetworkSetting>? settings;
/// The target resource on which this certificate is applied.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}")
///
/// Required.
core.String? targetResource;
GoogleChromePolicyVersionsV1DefineCertificateRequest({
this.ceritificateName,
this.certificate,
this.settings,
this.targetResource,
});
GoogleChromePolicyVersionsV1DefineCertificateRequest.fromJson(core.Map json_)
: this(
ceritificateName: json_.containsKey('ceritificateName')
? json_['ceritificateName'] as core.String
: null,
certificate: json_.containsKey('certificate')
? json_['certificate'] as core.String
: null,
settings: json_.containsKey('settings')
? (json_['settings'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1NetworkSetting.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (ceritificateName != null) 'ceritificateName': ceritificateName!,
if (certificate != null) 'certificate': certificate!,
if (settings != null) 'settings': settings!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Response object for creating a certificate.
class GoogleChromePolicyVersionsV1DefineCertificateResponse {
/// The guid of the certificate created by the action.
core.String? networkId;
/// the affiliated settings of the certificate (NOT IMPLEMENTED)
core.List<GoogleChromePolicyVersionsV1NetworkSetting>? settings;
/// the resource at which the certificate is defined.
core.String? targetResource;
GoogleChromePolicyVersionsV1DefineCertificateResponse({
this.networkId,
this.settings,
this.targetResource,
});
GoogleChromePolicyVersionsV1DefineCertificateResponse.fromJson(core.Map json_)
: this(
networkId: json_.containsKey('networkId')
? json_['networkId'] as core.String
: null,
settings: json_.containsKey('settings')
? (json_['settings'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1NetworkSetting.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (networkId != null) 'networkId': networkId!,
if (settings != null) 'settings': settings!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Request object for creating a new network.
class GoogleChromePolicyVersionsV1DefineNetworkRequest {
/// Name of the new created network.
///
/// Required.
core.String? name;
/// Detailed network settings.
///
/// Required.
core.List<GoogleChromePolicyVersionsV1NetworkSetting>? settings;
/// The target resource on which this new network will be defined.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}")
///
/// Required.
core.String? targetResource;
GoogleChromePolicyVersionsV1DefineNetworkRequest({
this.name,
this.settings,
this.targetResource,
});
GoogleChromePolicyVersionsV1DefineNetworkRequest.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
settings: json_.containsKey('settings')
? (json_['settings'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1NetworkSetting.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (settings != null) 'settings': settings!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Response object for creating a network.
class GoogleChromePolicyVersionsV1DefineNetworkResponse {
/// Network ID of the new created network.
core.String? networkId;
/// Detailed network settings of the new created network
core.List<GoogleChromePolicyVersionsV1NetworkSetting>? settings;
/// The target resource on which this new network will be defined.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}")
core.String? targetResource;
GoogleChromePolicyVersionsV1DefineNetworkResponse({
this.networkId,
this.settings,
this.targetResource,
});
GoogleChromePolicyVersionsV1DefineNetworkResponse.fromJson(core.Map json_)
: this(
networkId: json_.containsKey('networkId')
? json_['networkId'] as core.String
: null,
settings: json_.containsKey('settings')
? (json_['settings'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1NetworkSetting.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (networkId != null) 'networkId': networkId!,
if (settings != null) 'settings': settings!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Request parameters for deleting the policy value of a specific group target.
class GoogleChromePolicyVersionsV1DeleteGroupPolicyRequest {
/// The fully qualified name of the policy schema that is being inherited.
core.String? policySchema;
/// The key of the target for which we want to modify a policy.
///
/// The target resource must point to a Group.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1DeleteGroupPolicyRequest({
this.policySchema,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1DeleteGroupPolicyRequest.fromJson(core.Map json_)
: this(
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policySchema != null) 'policySchema': policySchema!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Information about any range constraints.
class GoogleChromePolicyVersionsV1FieldConstraints {
/// The allowed range for numeric fields.
GoogleChromePolicyVersionsV1NumericRangeConstraint? numericRangeConstraint;
GoogleChromePolicyVersionsV1FieldConstraints({
this.numericRangeConstraint,
});
GoogleChromePolicyVersionsV1FieldConstraints.fromJson(core.Map json_)
: this(
numericRangeConstraint: json_.containsKey('numericRangeConstraint')
? GoogleChromePolicyVersionsV1NumericRangeConstraint.fromJson(
json_['numericRangeConstraint']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (numericRangeConstraint != null)
'numericRangeConstraint': numericRangeConstraint!,
};
}
/// Request parameters for inheriting policy value of a specific org unit target
/// from the policy value of its parent org unit.
class GoogleChromePolicyVersionsV1InheritOrgUnitPolicyRequest {
/// The fully qualified name of the policy schema that is being inherited.
core.String? policySchema;
/// The key of the target for which we want to modify a policy.
///
/// The target resource must point to an Org Unit.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1InheritOrgUnitPolicyRequest({
this.policySchema,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1InheritOrgUnitPolicyRequest.fromJson(
core.Map json_)
: this(
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policySchema != null) 'policySchema': policySchema!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Request message for listing the group priority ordering of an app.
class GoogleChromePolicyVersionsV1ListGroupPriorityOrderingRequest {
/// The namespace of the policy type for the request.
core.String? policyNamespace;
/// The schema name of the policy for the request.
core.String? policySchema;
/// The key of the target for which we want to retrieve the group priority
/// ordering.
///
/// The target resource must point to an app.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1ListGroupPriorityOrderingRequest({
this.policyNamespace,
this.policySchema,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1ListGroupPriorityOrderingRequest.fromJson(
core.Map json_)
: this(
policyNamespace: json_.containsKey('policyNamespace')
? json_['policyNamespace'] as core.String
: null,
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policyNamespace != null) 'policyNamespace': policyNamespace!,
if (policySchema != null) 'policySchema': policySchema!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Response message for listing the group priority ordering of an app.
class GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse {
/// The group IDs, in priority ordering.
///
/// Output only.
core.List<core.String>? groupIds;
/// The namespace of the policy type of the group IDs.
///
/// Output only.
core.String? policyNamespace;
/// The schema name of the policy for the group IDs.
///
/// Output only.
core.String? policySchema;
/// The target resource for which the group priority ordering has been
/// retrieved.
///
/// Output only.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse({
this.groupIds,
this.policyNamespace,
this.policySchema,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1ListGroupPriorityOrderingResponse.fromJson(
core.Map json_)
: this(
groupIds: json_.containsKey('groupIds')
? (json_['groupIds'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
policyNamespace: json_.containsKey('policyNamespace')
? json_['policyNamespace'] as core.String
: null,
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (groupIds != null) 'groupIds': groupIds!,
if (policyNamespace != null) 'policyNamespace': policyNamespace!,
if (policySchema != null) 'policySchema': policySchema!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Response message for listing policy schemas that match a filter.
class GoogleChromePolicyVersionsV1ListPolicySchemasResponse {
/// The page token used to get the next page of policy schemas.
core.String? nextPageToken;
/// The list of policy schemas that match the query.
core.List<GoogleChromePolicyVersionsV1PolicySchema>? policySchemas;
GoogleChromePolicyVersionsV1ListPolicySchemasResponse({
this.nextPageToken,
this.policySchemas,
});
GoogleChromePolicyVersionsV1ListPolicySchemasResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
policySchemas: json_.containsKey('policySchemas')
? (json_['policySchemas'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchema.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (policySchemas != null) 'policySchemas': policySchemas!,
};
}
/// Request parameters for modifying a policy value for a specific group target.
class GoogleChromePolicyVersionsV1ModifyGroupPolicyRequest {
/// The key of the target for which we want to modify a policy.
///
/// The target resource must point to a Group.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
/// The new value for the policy.
GoogleChromePolicyVersionsV1PolicyValue? policyValue;
/// Policy fields to update.
///
/// Only fields in this mask will be updated; other fields in `policy_value`
/// will be ignored (even if they have values). If a field is in this list it
/// must have a value in 'policy_value'.
///
/// Required.
core.String? updateMask;
GoogleChromePolicyVersionsV1ModifyGroupPolicyRequest({
this.policyTargetKey,
this.policyValue,
this.updateMask,
});
GoogleChromePolicyVersionsV1ModifyGroupPolicyRequest.fromJson(core.Map json_)
: this(
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
policyValue: json_.containsKey('policyValue')
? GoogleChromePolicyVersionsV1PolicyValue.fromJson(
json_['policyValue'] as core.Map<core.String, core.dynamic>)
: null,
updateMask: json_.containsKey('updateMask')
? json_['updateMask'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
if (policyValue != null) 'policyValue': policyValue!,
if (updateMask != null) 'updateMask': updateMask!,
};
}
/// Request parameters for modifying a policy value for a specific org unit
/// target.
class GoogleChromePolicyVersionsV1ModifyOrgUnitPolicyRequest {
/// The key of the target for which we want to modify a policy.
///
/// The target resource must point to an Org Unit.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
/// The new value for the policy.
GoogleChromePolicyVersionsV1PolicyValue? policyValue;
/// Policy fields to update.
///
/// Only fields in this mask will be updated; other fields in `policy_value`
/// will be ignored (even if they have values). If a field is in this list it
/// must have a value in 'policy_value'.
///
/// Required.
core.String? updateMask;
GoogleChromePolicyVersionsV1ModifyOrgUnitPolicyRequest({
this.policyTargetKey,
this.policyValue,
this.updateMask,
});
GoogleChromePolicyVersionsV1ModifyOrgUnitPolicyRequest.fromJson(
core.Map json_)
: this(
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
policyValue: json_.containsKey('policyValue')
? GoogleChromePolicyVersionsV1PolicyValue.fromJson(
json_['policyValue'] as core.Map<core.String, core.dynamic>)
: null,
updateMask: json_.containsKey('updateMask')
? json_['updateMask'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
if (policyValue != null) 'policyValue': policyValue!,
if (updateMask != null) 'updateMask': updateMask!,
};
}
/// A network setting contains network configurations.
class GoogleChromePolicyVersionsV1NetworkSetting {
/// The fully qualified name of the network setting.
core.String? policySchema;
/// The value of the network setting.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object?>? value;
GoogleChromePolicyVersionsV1NetworkSetting({
this.policySchema,
this.value,
});
GoogleChromePolicyVersionsV1NetworkSetting.fromJson(core.Map json_)
: this(
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
value: json_.containsKey('value')
? json_['value'] as core.Map<core.String, core.dynamic>
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policySchema != null) 'policySchema': policySchema!,
if (value != null) 'value': value!,
};
}
/// A constraint on upper and/or lower bounds, with at least one being set.
class GoogleChromePolicyVersionsV1NumericRangeConstraint {
/// Maximum value.
core.String? maximum;
/// Minimum value.
core.String? minimum;
GoogleChromePolicyVersionsV1NumericRangeConstraint({
this.maximum,
this.minimum,
});
GoogleChromePolicyVersionsV1NumericRangeConstraint.fromJson(core.Map json_)
: this(
maximum: json_.containsKey('maximum')
? json_['maximum'] as core.String
: null,
minimum: json_.containsKey('minimum')
? json_['minimum'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (maximum != null) 'maximum': maximum!,
if (minimum != null) 'minimum': minimum!,
};
}
/// Resource representing a policy schema.
class GoogleChromePolicyVersionsV1PolicySchema {
/// Specific access restrictions related to this policy.
///
/// Output only.
core.List<core.String>? accessRestrictions;
/// Additional key names that will be used to identify the target of the
/// policy value.
///
/// When specifying a `policyTargetKey`, each of the additional keys specified
/// here will have to be included in the `additionalTargetKeys` map.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1AdditionalTargetKeyName>?
additionalTargetKeyNames;
/// Title of the category in which a setting belongs.
core.String? categoryTitle;
/// Schema definition using proto descriptor.
Proto2FileDescriptorProto? definition;
/// Detailed description of each field that is part of the schema.
///
/// Fields are suggested to be displayed by the ordering in this list, not by
/// field number.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaFieldDescription>?
fieldDescriptions;
/// Format: name=customers/{customer}/policySchemas/{schema_namespace}
core.String? name;
/// Special notice messages related to setting certain values in certain
/// fields in the schema.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaNoticeDescription>? notices;
/// Current lifecycle information.
///
/// Output only.
ChromeCrosDpanelAutosettingsProtoPolicyApiLifecycle? policyApiLifecycle;
/// Description about the policy schema for user consumption.
///
/// Output only.
core.String? policyDescription;
/// The fully qualified name of the policy schema.
///
/// This value is used to fill the field `policy_schema` in PolicyValue when
/// calling BatchInheritOrgUnitPolicies BatchModifyOrgUnitPolicies
/// BatchModifyGroupPolicies or BatchDeleteGroupPolicies.
///
/// Output only.
core.String? schemaName;
/// URI to related support article for this schema.
///
/// Output only.
core.String? supportUri;
/// Information about applicable target resources for the policy.
///
/// Output only.
core.List<core.String>? validTargetResources;
GoogleChromePolicyVersionsV1PolicySchema({
this.accessRestrictions,
this.additionalTargetKeyNames,
this.categoryTitle,
this.definition,
this.fieldDescriptions,
this.name,
this.notices,
this.policyApiLifecycle,
this.policyDescription,
this.schemaName,
this.supportUri,
this.validTargetResources,
});
GoogleChromePolicyVersionsV1PolicySchema.fromJson(core.Map json_)
: this(
accessRestrictions: json_.containsKey('accessRestrictions')
? (json_['accessRestrictions'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
additionalTargetKeyNames: json_
.containsKey('additionalTargetKeyNames')
? (json_['additionalTargetKeyNames'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1AdditionalTargetKeyName
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
categoryTitle: json_.containsKey('categoryTitle')
? json_['categoryTitle'] as core.String
: null,
definition: json_.containsKey('definition')
? Proto2FileDescriptorProto.fromJson(
json_['definition'] as core.Map<core.String, core.dynamic>)
: null,
fieldDescriptions: json_.containsKey('fieldDescriptions')
? (json_['fieldDescriptions'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaFieldDescription
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
notices: json_.containsKey('notices')
? (json_['notices'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaNoticeDescription
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
policyApiLifecycle: json_.containsKey('policyApiLifecycle')
? ChromeCrosDpanelAutosettingsProtoPolicyApiLifecycle.fromJson(
json_['policyApiLifecycle']
as core.Map<core.String, core.dynamic>)
: null,
policyDescription: json_.containsKey('policyDescription')
? json_['policyDescription'] as core.String
: null,
schemaName: json_.containsKey('schemaName')
? json_['schemaName'] as core.String
: null,
supportUri: json_.containsKey('supportUri')
? json_['supportUri'] as core.String
: null,
validTargetResources: json_.containsKey('validTargetResources')
? (json_['validTargetResources'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (accessRestrictions != null)
'accessRestrictions': accessRestrictions!,
if (additionalTargetKeyNames != null)
'additionalTargetKeyNames': additionalTargetKeyNames!,
if (categoryTitle != null) 'categoryTitle': categoryTitle!,
if (definition != null) 'definition': definition!,
if (fieldDescriptions != null) 'fieldDescriptions': fieldDescriptions!,
if (name != null) 'name': name!,
if (notices != null) 'notices': notices!,
if (policyApiLifecycle != null)
'policyApiLifecycle': policyApiLifecycle!,
if (policyDescription != null) 'policyDescription': policyDescription!,
if (schemaName != null) 'schemaName': schemaName!,
if (supportUri != null) 'supportUri': supportUri!,
if (validTargetResources != null)
'validTargetResources': validTargetResources!,
};
}
/// The field and the value it must have for another field to be allowed to be
/// set.
class GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies {
/// The source field which this field depends on.
core.String? sourceField;
/// The value which the source field must have for this field to be allowed to
/// be set.
core.String? sourceFieldValue;
GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies({
this.sourceField,
this.sourceFieldValue,
});
GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies.fromJson(
core.Map json_)
: this(
sourceField: json_.containsKey('sourceField')
? json_['sourceField'] as core.String
: null,
sourceFieldValue: json_.containsKey('sourceFieldValue')
? json_['sourceFieldValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (sourceField != null) 'sourceField': sourceField!,
if (sourceFieldValue != null) 'sourceFieldValue': sourceFieldValue!,
};
}
/// Provides detailed information for a particular field that is part of a
/// PolicySchema.
class GoogleChromePolicyVersionsV1PolicySchemaFieldDescription {
/// Client default if the policy is unset.
///
/// Output only.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Object? defaultValue;
/// Use name and field_description instead.
///
/// The description for the field.
///
/// Deprecated.
@core.Deprecated(
'Not supported. Member documentation may have more information.',
)
core.String? description;
/// The name of the field for associated with this description.
///
/// Output only.
core.String? field;
/// Information on any input constraints associated on the values for the
/// field.
///
/// Output only.
GoogleChromePolicyVersionsV1FieldConstraints? fieldConstraints;
/// Provides a list of fields and values.
///
/// At least one of the fields must have the corresponding value in order for
/// this field to be allowed to be set.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies>?
fieldDependencies;
/// The description of the field.
///
/// Output only.
core.String? fieldDescription;
/// Any input constraints associated on the values for the field.
///
/// Output only.
core.String? inputConstraint;
/// If the field has a set of known values, this field will provide a
/// description for these values.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaFieldKnownValueDescription>?
knownValueDescriptions;
/// The name of the field.
///
/// Output only.
core.String? name;
/// Provides the description of the fields nested in this field, if the field
/// is a message type that defines multiple fields.
///
/// Fields are suggested to be displayed by the ordering in this list, not by
/// field number.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaFieldDescription>?
nestedFieldDescriptions;
/// Provides a list of fields that are required to be set if this field has a
/// certain value.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaRequiredItems>?
requiredItems;
GoogleChromePolicyVersionsV1PolicySchemaFieldDescription({
this.defaultValue,
this.description,
this.field,
this.fieldConstraints,
this.fieldDependencies,
this.fieldDescription,
this.inputConstraint,
this.knownValueDescriptions,
this.name,
this.nestedFieldDescriptions,
this.requiredItems,
});
GoogleChromePolicyVersionsV1PolicySchemaFieldDescription.fromJson(
core.Map json_)
: this(
defaultValue:
json_.containsKey('defaultValue') ? json_['defaultValue'] : null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
fieldConstraints: json_.containsKey('fieldConstraints')
? GoogleChromePolicyVersionsV1FieldConstraints.fromJson(
json_['fieldConstraints']
as core.Map<core.String, core.dynamic>)
: null,
fieldDependencies: json_.containsKey('fieldDependencies')
? (json_['fieldDependencies'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
fieldDescription: json_.containsKey('fieldDescription')
? json_['fieldDescription'] as core.String
: null,
inputConstraint: json_.containsKey('inputConstraint')
? json_['inputConstraint'] as core.String
: null,
knownValueDescriptions: json_.containsKey('knownValueDescriptions')
? (json_['knownValueDescriptions'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaFieldKnownValueDescription
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
nestedFieldDescriptions: json_.containsKey('nestedFieldDescriptions')
? (json_['nestedFieldDescriptions'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaFieldDescription
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
requiredItems: json_.containsKey('requiredItems')
? (json_['requiredItems'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaRequiredItems
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (defaultValue != null) 'defaultValue': defaultValue!,
if (description != null) 'description': description!,
if (field != null) 'field': field!,
if (fieldConstraints != null) 'fieldConstraints': fieldConstraints!,
if (fieldDependencies != null) 'fieldDependencies': fieldDependencies!,
if (fieldDescription != null) 'fieldDescription': fieldDescription!,
if (inputConstraint != null) 'inputConstraint': inputConstraint!,
if (knownValueDescriptions != null)
'knownValueDescriptions': knownValueDescriptions!,
if (name != null) 'name': name!,
if (nestedFieldDescriptions != null)
'nestedFieldDescriptions': nestedFieldDescriptions!,
if (requiredItems != null) 'requiredItems': requiredItems!,
};
}
/// Provides detailed information about a known value that is allowed for a
/// particular field in a PolicySchema.
class GoogleChromePolicyVersionsV1PolicySchemaFieldKnownValueDescription {
/// Additional description for this value.
///
/// Output only.
core.String? description;
/// Field conditions required for this value to be valid.
///
/// Output only.
core.List<GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies>?
fieldDependencies;
/// The string represenstation of the value that can be set for the field.
///
/// Output only.
core.String? value;
GoogleChromePolicyVersionsV1PolicySchemaFieldKnownValueDescription({
this.description,
this.fieldDependencies,
this.value,
});
GoogleChromePolicyVersionsV1PolicySchemaFieldKnownValueDescription.fromJson(
core.Map json_)
: this(
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
fieldDependencies: json_.containsKey('fieldDependencies')
? (json_['fieldDependencies'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1PolicySchemaFieldDependencies
.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
value:
json_.containsKey('value') ? json_['value'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (description != null) 'description': description!,
if (fieldDependencies != null) 'fieldDependencies': fieldDependencies!,
if (value != null) 'value': value!,
};
}
/// Provides special notice messages related to a particular value in a field
/// that is part of a PolicySchema.
class GoogleChromePolicyVersionsV1PolicySchemaNoticeDescription {
/// Whether the user needs to acknowledge the notice message before the value
/// can be set.
///
/// Output only.
core.bool? acknowledgementRequired;
/// The field name associated with the notice.
///
/// Output only.
core.String? field;
/// The notice message associate with the value of the field.
///
/// Output only.
core.String? noticeMessage;
/// The value of the field that has a notice.
///
/// When setting the field to this value, the user may be required to
/// acknowledge the notice message in order for the value to be set.
///
/// Output only.
core.String? noticeValue;
GoogleChromePolicyVersionsV1PolicySchemaNoticeDescription({
this.acknowledgementRequired,
this.field,
this.noticeMessage,
this.noticeValue,
});
GoogleChromePolicyVersionsV1PolicySchemaNoticeDescription.fromJson(
core.Map json_)
: this(
acknowledgementRequired: json_.containsKey('acknowledgementRequired')
? json_['acknowledgementRequired'] as core.bool
: null,
field:
json_.containsKey('field') ? json_['field'] as core.String : null,
noticeMessage: json_.containsKey('noticeMessage')
? json_['noticeMessage'] as core.String
: null,
noticeValue: json_.containsKey('noticeValue')
? json_['noticeValue'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (acknowledgementRequired != null)
'acknowledgementRequired': acknowledgementRequired!,
if (field != null) 'field': field!,
if (noticeMessage != null) 'noticeMessage': noticeMessage!,
if (noticeValue != null) 'noticeValue': noticeValue!,
};
}
/// The fields that will become required based on the value of this field.
class GoogleChromePolicyVersionsV1PolicySchemaRequiredItems {
/// The value(s) of the field that provoke required field enforcement.
///
/// An empty field_conditions implies that any value assigned to this field
/// will provoke required field enforcement.
core.List<core.String>? fieldConditions;
/// The fields that are required as a consequence of the field conditions.
core.List<core.String>? requiredFields;
GoogleChromePolicyVersionsV1PolicySchemaRequiredItems({
this.fieldConditions,
this.requiredFields,
});
GoogleChromePolicyVersionsV1PolicySchemaRequiredItems.fromJson(core.Map json_)
: this(
fieldConditions: json_.containsKey('fieldConditions')
? (json_['fieldConditions'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
requiredFields: json_.containsKey('requiredFields')
? (json_['requiredFields'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (fieldConditions != null) 'fieldConditions': fieldConditions!,
if (requiredFields != null) 'requiredFields': requiredFields!,
};
}
/// The key used to identify the target on which the policy will be applied.
class GoogleChromePolicyVersionsV1PolicyTargetKey {
/// Map containing the additional target key name and value pairs used to
/// further identify the target of the policy.
core.Map<core.String, core.String>? additionalTargetKeys;
/// The target resource on which this policy is applied.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}") * Group ("groups/{group_id}")
core.String? targetResource;
GoogleChromePolicyVersionsV1PolicyTargetKey({
this.additionalTargetKeys,
this.targetResource,
});
GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(core.Map json_)
: this(
additionalTargetKeys: json_.containsKey('additionalTargetKeys')
? (json_['additionalTargetKeys']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (additionalTargetKeys != null)
'additionalTargetKeys': additionalTargetKeys!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// A particular value for a policy managed by the service.
class GoogleChromePolicyVersionsV1PolicyValue {
/// The fully qualified name of the policy schema associated with this policy.
core.String? policySchema;
/// The value of the policy that is compatible with the schema that it is
/// associated with.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object?>? value;
GoogleChromePolicyVersionsV1PolicyValue({
this.policySchema,
this.value,
});
GoogleChromePolicyVersionsV1PolicyValue.fromJson(core.Map json_)
: this(
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
value: json_.containsKey('value')
? json_['value'] as core.Map<core.String, core.dynamic>
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policySchema != null) 'policySchema': policySchema!,
if (value != null) 'value': value!,
};
}
/// Request object for removing a certificate.
class GoogleChromePolicyVersionsV1RemoveCertificateRequest {
/// The GUID of the certificate to remove.
///
/// Required.
core.String? networkId;
/// The target resource on which this certificate will be removed.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}")
///
/// Required.
core.String? targetResource;
GoogleChromePolicyVersionsV1RemoveCertificateRequest({
this.networkId,
this.targetResource,
});
GoogleChromePolicyVersionsV1RemoveCertificateRequest.fromJson(core.Map json_)
: this(
networkId: json_.containsKey('networkId')
? json_['networkId'] as core.String
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (networkId != null) 'networkId': networkId!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Response object for removing a certificate.
typedef GoogleChromePolicyVersionsV1RemoveCertificateResponse = $Empty;
/// Request object for removing a network
class GoogleChromePolicyVersionsV1RemoveNetworkRequest {
/// The GUID of the network to remove.
///
/// Required.
core.String? networkId;
/// The target resource on which this network will be removed.
///
/// The following resources are supported: * Organizational Unit
/// ("orgunits/{orgunit_id}")
///
/// Required.
core.String? targetResource;
GoogleChromePolicyVersionsV1RemoveNetworkRequest({
this.networkId,
this.targetResource,
});
GoogleChromePolicyVersionsV1RemoveNetworkRequest.fromJson(core.Map json_)
: this(
networkId: json_.containsKey('networkId')
? json_['networkId'] as core.String
: null,
targetResource: json_.containsKey('targetResource')
? json_['targetResource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (networkId != null) 'networkId': networkId!,
if (targetResource != null) 'targetResource': targetResource!,
};
}
/// Response object for removing a network.
typedef GoogleChromePolicyVersionsV1RemoveNetworkResponse = $Empty;
/// Request message for getting the resolved policy value for a specific target.
class GoogleChromePolicyVersionsV1ResolveRequest {
/// The maximum number of policies to return, defaults to 100 and has a
/// maximum of 1000.
core.int? pageSize;
/// The page token used to retrieve a specific page of the request.
core.String? pageToken;
/// The schema filter to apply to the resolve request.
///
/// Specify a schema name to view a particular schema, for example:
/// chrome.users.ShowLogoutButton Wildcards are supported, but only in the
/// leaf portion of the schema name. Wildcards cannot be used in namespace
/// directly. Please read
/// https://developers.google.com/chrome/policy/guides/policy-schemas for
/// details on schema namespaces. For example: Valid: "chrome.users.*",
/// "chrome.users.apps.*", "chrome.printers.*" Invalid: "*", "*.users",
/// "chrome.*", "chrome.*.apps.*"
///
/// Required.
core.String? policySchemaFilter;
/// The key of the target resource on which the policies should be resolved.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1ResolveRequest({
this.pageSize,
this.pageToken,
this.policySchemaFilter,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1ResolveRequest.fromJson(core.Map json_)
: this(
pageSize: json_.containsKey('pageSize')
? json_['pageSize'] as core.int
: null,
pageToken: json_.containsKey('pageToken')
? json_['pageToken'] as core.String
: null,
policySchemaFilter: json_.containsKey('policySchemaFilter')
? json_['policySchemaFilter'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (pageSize != null) 'pageSize': pageSize!,
if (pageToken != null) 'pageToken': pageToken!,
if (policySchemaFilter != null)
'policySchemaFilter': policySchemaFilter!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Response message for getting the resolved policy value for a specific
/// target.
class GoogleChromePolicyVersionsV1ResolveResponse {
/// The page token used to get the next set of resolved policies found by the
/// request.
core.String? nextPageToken;
/// The list of resolved policies found by the resolve request.
core.List<GoogleChromePolicyVersionsV1ResolvedPolicy>? resolvedPolicies;
GoogleChromePolicyVersionsV1ResolveResponse({
this.nextPageToken,
this.resolvedPolicies,
});
GoogleChromePolicyVersionsV1ResolveResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
resolvedPolicies: json_.containsKey('resolvedPolicies')
? (json_['resolvedPolicies'] as core.List)
.map((value) =>
GoogleChromePolicyVersionsV1ResolvedPolicy.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (resolvedPolicies != null) 'resolvedPolicies': resolvedPolicies!,
};
}
/// The resolved value of a policy for a given target.
class GoogleChromePolicyVersionsV1ResolvedPolicy {
/// The added source key establishes at which level an entity was explicitly
/// added for management.
///
/// This is useful for certain type of policies that are only applied if they
/// are explicitly added for management. For example: apps and networks. An
/// entity can only be deleted from management in an Organizational Unit that
/// it was explicitly added to. If this is not present it means that the
/// policy is managed without the need to explicitly add an entity, for
/// example: standard user or device policies.
///
/// Output only.
GoogleChromePolicyVersionsV1PolicyTargetKey? addedSourceKey;
/// The source resource from which this policy value is obtained.
///
/// May be the same as `targetKey` if the policy is directly modified on the
/// target, otherwise it would be another resource from which the policy gets
/// its value (if applicable). If not present, the source is the default value
/// for the customer.
///
/// Output only.
GoogleChromePolicyVersionsV1PolicyTargetKey? sourceKey;
/// The target resource for which the resolved policy value applies.
///
/// Output only.
GoogleChromePolicyVersionsV1PolicyTargetKey? targetKey;
/// The resolved value of the policy.
///
/// Output only.
GoogleChromePolicyVersionsV1PolicyValue? value;
GoogleChromePolicyVersionsV1ResolvedPolicy({
this.addedSourceKey,
this.sourceKey,
this.targetKey,
this.value,
});
GoogleChromePolicyVersionsV1ResolvedPolicy.fromJson(core.Map json_)
: this(
addedSourceKey: json_.containsKey('addedSourceKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['addedSourceKey']
as core.Map<core.String, core.dynamic>)
: null,
sourceKey: json_.containsKey('sourceKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['sourceKey'] as core.Map<core.String, core.dynamic>)
: null,
targetKey: json_.containsKey('targetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['targetKey'] as core.Map<core.String, core.dynamic>)
: null,
value: json_.containsKey('value')
? GoogleChromePolicyVersionsV1PolicyValue.fromJson(
json_['value'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (addedSourceKey != null) 'addedSourceKey': addedSourceKey!,
if (sourceKey != null) 'sourceKey': sourceKey!,
if (targetKey != null) 'targetKey': targetKey!,
if (value != null) 'value': value!,
};
}
/// Request message for updating the group priority ordering of an app.
class GoogleChromePolicyVersionsV1UpdateGroupPriorityOrderingRequest {
/// The group IDs, in desired priority ordering.
///
/// Required.
core.List<core.String>? groupIds;
/// The namespace of the policy type for the request.
core.String? policyNamespace;
/// The schema name of the policy for the request.
core.String? policySchema;
/// The key of the target for which we want to update the group priority
/// ordering.
///
/// The target resource must point to an app.
///
/// Required.
GoogleChromePolicyVersionsV1PolicyTargetKey? policyTargetKey;
GoogleChromePolicyVersionsV1UpdateGroupPriorityOrderingRequest({
this.groupIds,
this.policyNamespace,
this.policySchema,
this.policyTargetKey,
});
GoogleChromePolicyVersionsV1UpdateGroupPriorityOrderingRequest.fromJson(
core.Map json_)
: this(
groupIds: json_.containsKey('groupIds')
? (json_['groupIds'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
policyNamespace: json_.containsKey('policyNamespace')
? json_['policyNamespace'] as core.String
: null,
policySchema: json_.containsKey('policySchema')
? json_['policySchema'] as core.String
: null,
policyTargetKey: json_.containsKey('policyTargetKey')
? GoogleChromePolicyVersionsV1PolicyTargetKey.fromJson(
json_['policyTargetKey']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (groupIds != null) 'groupIds': groupIds!,
if (policyNamespace != null) 'policyNamespace': policyNamespace!,
if (policySchema != null) 'policySchema': policySchema!,
if (policyTargetKey != null) 'policyTargetKey': policyTargetKey!,
};
}
/// Request message for uploading a file for a policy.
class GoogleChromePolicyVersionsV1UploadPolicyFileRequest {
/// The fully qualified policy schema and field name this file is uploaded
/// for.
///
/// This information will be used to validate the content type of the file.
///
/// Required.
core.String? policyField;
GoogleChromePolicyVersionsV1UploadPolicyFileRequest({
this.policyField,
});
GoogleChromePolicyVersionsV1UploadPolicyFileRequest.fromJson(core.Map json_)
: this(
policyField: json_.containsKey('policyField')
? json_['policyField'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (policyField != null) 'policyField': policyField!,
};
}
/// Response message for downloading an uploaded file.
class GoogleChromePolicyVersionsV1UploadPolicyFileResponse {
/// The uri for end user to download the file.
core.String? downloadUri;
GoogleChromePolicyVersionsV1UploadPolicyFileResponse({
this.downloadUri,
});
GoogleChromePolicyVersionsV1UploadPolicyFileResponse.fromJson(core.Map json_)
: this(
downloadUri: json_.containsKey('downloadUri')
? json_['downloadUri'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (downloadUri != null) 'downloadUri': downloadUri!,
};
}
/// A generic empty message that you can re-use to avoid defining duplicated
/// empty messages in your APIs.
///
/// A typical example is to use it as the request or the response type of an API
/// method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns
/// (google.protobuf.Empty); }
typedef GoogleProtobufEmpty = $Empty;
/// Represents a whole or partial calendar date, such as a birthday.
///
/// The time of day and time zone are either specified elsewhere or are
/// insignificant. The date is relative to the Gregorian Calendar. This can
/// represent one of the following: * A full date, with non-zero year, month,
/// and day values. * A month and day, with a zero year (for example, an
/// anniversary). * A year on its own, with a zero month and a zero day. * A
/// year and month, with a zero day (for example, a credit card expiration
/// date). Related types: * google.type.TimeOfDay * google.type.DateTime *
/// google.protobuf.Timestamp
typedef GoogleTypeDate = $Date;
/// Describes a message type.
class Proto2DescriptorProto {
core.List<Proto2EnumDescriptorProto>? enumType;
core.List<Proto2FieldDescriptorProto>? field;
core.String? name;
core.List<Proto2DescriptorProto>? nestedType;
core.List<Proto2OneofDescriptorProto>? oneofDecl;
Proto2DescriptorProto({
this.enumType,
this.field,
this.name,
this.nestedType,
this.oneofDecl,
});
Proto2DescriptorProto.fromJson(core.Map json_)
: this(
enumType: json_.containsKey('enumType')
? (json_['enumType'] as core.List)
.map((value) => Proto2EnumDescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
field: json_.containsKey('field')
? (json_['field'] as core.List)
.map((value) => Proto2FieldDescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
nestedType: json_.containsKey('nestedType')
? (json_['nestedType'] as core.List)
.map((value) => Proto2DescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
oneofDecl: json_.containsKey('oneofDecl')
? (json_['oneofDecl'] as core.List)
.map((value) => Proto2OneofDescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (enumType != null) 'enumType': enumType!,
if (field != null) 'field': field!,
if (name != null) 'name': name!,
if (nestedType != null) 'nestedType': nestedType!,
if (oneofDecl != null) 'oneofDecl': oneofDecl!,
};
}
/// Describes an enum type.
class Proto2EnumDescriptorProto {
core.String? name;
core.List<Proto2EnumValueDescriptorProto>? value;
Proto2EnumDescriptorProto({
this.name,
this.value,
});
Proto2EnumDescriptorProto.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
value: json_.containsKey('value')
? (json_['value'] as core.List)
.map((value) => Proto2EnumValueDescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (value != null) 'value': value!,
};
}
/// Describes a value within an enum.
class Proto2EnumValueDescriptorProto {
core.String? name;
core.int? number;
Proto2EnumValueDescriptorProto({
this.name,
this.number,
});
Proto2EnumValueDescriptorProto.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
number:
json_.containsKey('number') ? json_['number'] as core.int : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (number != null) 'number': number!,
};
}
/// Describes a field within a message.
class Proto2FieldDescriptorProto {
/// For numeric types, contains the original text representation of the value.
///
/// For booleans, "true" or "false". For strings, contains the default text
/// contents (not escaped in any way). For bytes, contains the C escaped
/// value. All bytes \>= 128 are escaped.
core.String? defaultValue;
/// JSON name of this field.
///
/// The value is set by protocol compiler. If the user has set a "json_name"
/// option on this field, that option's value will be used. Otherwise, it's
/// deduced from the field's name by converting it to camelCase.
core.String? jsonName;
///
/// Possible string values are:
/// - "LABEL_OPTIONAL" : 0 is reserved for errors
/// - "LABEL_REQUIRED"
/// - "LABEL_REPEATED"
core.String? label;
core.String? name;
core.int? number;
/// If set, gives the index of a oneof in the containing type's oneof_decl
/// list.
///
/// This field is a member of that oneof.
core.int? oneofIndex;
/// If true, this is a proto3 "optional".
///
/// When a proto3 field is optional, it tracks presence regardless of field
/// type. When proto3_optional is true, this field must be belong to a oneof
/// to signal to old proto3 clients that presence is tracked for this field.
/// This oneof is known as a "synthetic" oneof, and this field must be its
/// sole member (each proto3 optional field gets its own synthetic oneof).
/// Synthetic oneofs exist in the descriptor only, and do not generate any
/// API. Synthetic oneofs must be ordered after all "real" oneofs. For message
/// fields, proto3_optional doesn't create any semantic change, since
/// non-repeated message fields always track presence. However it still
/// indicates the semantic detail of whether the user wrote "optional" or not.
/// This can be useful for round-tripping the .proto file. For consistency we
/// give message fields a synthetic oneof also, even though it is not required
/// to track presence. This is especially important because the parser can't
/// tell if a field is a message or an enum, so it must always create a
/// synthetic oneof. Proto2 optional fields do not set this flag, because they
/// already indicate optional with `LABEL_OPTIONAL`.
core.bool? proto3Optional;
/// If type_name is set, this need not be set.
///
/// If both this and type_name are set, this must be one of TYPE_ENUM,
/// TYPE_MESSAGE or TYPE_GROUP.
/// Possible string values are:
/// - "TYPE_DOUBLE" : 0 is reserved for errors. Order is weird for historical
/// reasons.
/// - "TYPE_FLOAT"
/// - "TYPE_INT64" : Not ZigZag encoded. Negative numbers take 10 bytes. Use
/// TYPE_SINT64 if negative values are likely.
/// - "TYPE_UINT64"
/// - "TYPE_INT32" : Not ZigZag encoded. Negative numbers take 10 bytes. Use
/// TYPE_SINT32 if negative values are likely.
/// - "TYPE_FIXED64"
/// - "TYPE_FIXED32"
/// - "TYPE_BOOL"
/// - "TYPE_STRING"
/// - "TYPE_GROUP" : Tag-delimited aggregate. Group type is deprecated and not
/// supported in proto3. However, Proto3 implementations should still be able
/// to parse the group wire format and treat group fields as unknown fields.
/// - "TYPE_MESSAGE" : Length-delimited aggregate.
/// - "TYPE_BYTES" : New in version 2.
/// - "TYPE_UINT32"
/// - "TYPE_ENUM"
/// - "TYPE_SFIXED32"
/// - "TYPE_SFIXED64"
/// - "TYPE_SINT32" : Uses ZigZag encoding.
/// - "TYPE_SINT64" : Uses ZigZag encoding.
core.String? type;
/// For message and enum types, this is the name of the type.
///
/// If the name starts with a '.', it is fully-qualified. Otherwise, C++-like
/// scoping rules are used to find the type (i.e. first the nested types
/// within this message are searched, then within the parent, on up to the
/// root namespace).
core.String? typeName;
Proto2FieldDescriptorProto({
this.defaultValue,
this.jsonName,
this.label,
this.name,
this.number,
this.oneofIndex,
this.proto3Optional,
this.type,
this.typeName,
});
Proto2FieldDescriptorProto.fromJson(core.Map json_)
: this(
defaultValue: json_.containsKey('defaultValue')
? json_['defaultValue'] as core.String
: null,
jsonName: json_.containsKey('jsonName')
? json_['jsonName'] as core.String
: null,
label:
json_.containsKey('label') ? json_['label'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
number:
json_.containsKey('number') ? json_['number'] as core.int : null,
oneofIndex: json_.containsKey('oneofIndex')
? json_['oneofIndex'] as core.int
: null,
proto3Optional: json_.containsKey('proto3Optional')
? json_['proto3Optional'] as core.bool
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
typeName: json_.containsKey('typeName')
? json_['typeName'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (defaultValue != null) 'defaultValue': defaultValue!,
if (jsonName != null) 'jsonName': jsonName!,
if (label != null) 'label': label!,
if (name != null) 'name': name!,
if (number != null) 'number': number!,
if (oneofIndex != null) 'oneofIndex': oneofIndex!,
if (proto3Optional != null) 'proto3Optional': proto3Optional!,
if (type != null) 'type': type!,
if (typeName != null) 'typeName': typeName!,
};
}
/// Describes a complete .proto file.
class Proto2FileDescriptorProto {
core.List<Proto2EnumDescriptorProto>? enumType;
/// All top-level definitions in this file.
core.List<Proto2DescriptorProto>? messageType;
/// file name, relative to root of source tree
core.String? name;
/// e.g. "foo", "foo.bar", etc.
core.String? package;
/// The syntax of the proto file.
///
/// The supported values are "proto2", "proto3", and "editions". If `edition`
/// is present, this value must be "editions".
core.String? syntax;
Proto2FileDescriptorProto({
this.enumType,
this.messageType,
this.name,
this.package,
this.syntax,
});
Proto2FileDescriptorProto.fromJson(core.Map json_)
: this(
enumType: json_.containsKey('enumType')
? (json_['enumType'] as core.List)
.map((value) => Proto2EnumDescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
messageType: json_.containsKey('messageType')
? (json_['messageType'] as core.List)
.map((value) => Proto2DescriptorProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
package: json_.containsKey('package')
? json_['package'] as core.String
: null,
syntax: json_.containsKey('syntax')
? json_['syntax'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (enumType != null) 'enumType': enumType!,
if (messageType != null) 'messageType': messageType!,
if (name != null) 'name': name!,
if (package != null) 'package': package!,
if (syntax != null) 'syntax': syntax!,
};
}
/// Describes a oneof.
class Proto2OneofDescriptorProto {
core.String? name;
Proto2OneofDescriptorProto({
this.name,
});
Proto2OneofDescriptorProto.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
};
}
|
googleapis.dart/generated/googleapis/lib/chromepolicy/v1.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/chromepolicy/v1.dart', 'repo_id': 'googleapis.dart', 'token_count': 38807}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Google Play Game Management - v1management
///
/// The Google Play Game Management API allows developers to manage resources
/// from the Google Play Game service.
///
/// For more information, see <https://developers.google.com/games/>
///
/// Create an instance of [GamesManagementApi] to access these resources:
///
/// - [AchievementsResource]
/// - [ApplicationsResource]
/// - [EventsResource]
/// - [PlayersResource]
/// - [ScoresResource]
library gamesmanagement_v1management;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
/// The Google Play Game Management API allows developers to manage resources
/// from the Google Play Game service.
class GamesManagementApi {
/// Create, edit, and delete your Google Play Games activity
static const gamesScope = 'https://www.googleapis.com/auth/games';
final commons.ApiRequester _requester;
AchievementsResource get achievements => AchievementsResource(_requester);
ApplicationsResource get applications => ApplicationsResource(_requester);
EventsResource get events => EventsResource(_requester);
PlayersResource get players => PlayersResource(_requester);
ScoresResource get scores => ScoresResource(_requester);
GamesManagementApi(http.Client client,
{core.String rootUrl = 'https://gamesmanagement.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class AchievementsResource {
final commons.ApiRequester _requester;
AchievementsResource(commons.ApiRequester client) : _requester = client;
/// Resets the achievement with the given ID for the currently authenticated
/// player.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [achievementId] - The ID of the achievement used by this method.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [AchievementResetResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<AchievementResetResponse> reset(
core.String achievementId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/achievements/' +
commons.escapeVariable('$achievementId') +
'/reset';
final response_ = await _requester.request(
url_,
'POST',
queryParams: queryParams_,
);
return AchievementResetResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Resets all achievements for the currently authenticated player for your
/// application.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [AchievementResetAllResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<AchievementResetAllResponse> resetAll({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/achievements/reset';
final response_ = await _requester.request(
url_,
'POST',
queryParams: queryParams_,
);
return AchievementResetAllResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Resets all draft achievements for all players.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetAllForAllPlayers({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/achievements/resetAllForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets the achievement with the given ID for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft achievements can be reset.
///
/// Request parameters:
///
/// [achievementId] - The ID of the achievement used by this method.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetForAllPlayers(
core.String achievementId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/achievements/' +
commons.escapeVariable('$achievementId') +
'/resetForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets achievements with the given IDs for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft achievements may be reset.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetMultipleForAllPlayers(
AchievementResetMultipleForAllRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/achievements/resetMultipleForAllPlayers';
await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
downloadOptions: null,
);
}
}
class ApplicationsResource {
final commons.ApiRequester _requester;
ApplicationsResource(commons.ApiRequester client) : _requester = client;
/// Get the list of players hidden from the given application.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [applicationId] - The application ID from the Google Play developer
/// console.
///
/// [maxResults] - The maximum number of player resources to return in the
/// response, used for paging. For any response, the actual number of player
/// resources returned may be less than the specified `maxResults`.
///
/// [pageToken] - The token returned by the previous request.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [HiddenPlayerList].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<HiddenPlayerList> listHidden(
core.String applicationId, {
core.int? maxResults,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (maxResults != null) 'maxResults': ['${maxResults}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/applications/' +
commons.escapeVariable('$applicationId') +
'/players/hidden';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return HiddenPlayerList.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class EventsResource {
final commons.ApiRequester _requester;
EventsResource(commons.ApiRequester client) : _requester = client;
/// Resets all player progress on the event with the given ID for the
/// currently authenticated player.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [eventId] - The ID of the event.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> reset(
core.String eventId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/events/' +
commons.escapeVariable('$eventId') +
'/reset';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets all player progress on all events for the currently authenticated
/// player.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetAll({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/events/reset';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets all draft events for all players.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetAllForAllPlayers({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/events/resetAllForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets the event with the given ID for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft events can be reset.
///
/// Request parameters:
///
/// [eventId] - The ID of the event.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetForAllPlayers(
core.String eventId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/events/' +
commons.escapeVariable('$eventId') +
'/resetForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets events with the given IDs for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft events may be reset.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetMultipleForAllPlayers(
EventsResetMultipleForAllRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/events/resetMultipleForAllPlayers';
await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
downloadOptions: null,
);
}
}
class PlayersResource {
final commons.ApiRequester _requester;
PlayersResource(commons.ApiRequester client) : _requester = client;
/// Hide the given player's leaderboard scores from the given application.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [applicationId] - The application ID from the Google Play developer
/// console.
///
/// [playerId] - A player ID. A value of `me` may be used in place of the
/// authenticated player's ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> hide(
core.String applicationId,
core.String playerId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/applications/' +
commons.escapeVariable('$applicationId') +
'/players/hidden/' +
commons.escapeVariable('$playerId');
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Unhide the given player's leaderboard scores from the given application.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [applicationId] - The application ID from the Google Play developer
/// console.
///
/// [playerId] - A player ID. A value of `me` may be used in place of the
/// authenticated player's ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> unhide(
core.String applicationId,
core.String playerId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/applications/' +
commons.escapeVariable('$applicationId') +
'/players/hidden/' +
commons.escapeVariable('$playerId');
await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
downloadOptions: null,
);
}
}
class ScoresResource {
final commons.ApiRequester _requester;
ScoresResource(commons.ApiRequester client) : _requester = client;
/// Resets scores for the leaderboard with the given ID for the currently
/// authenticated player.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [leaderboardId] - The ID of the leaderboard.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PlayerScoreResetResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PlayerScoreResetResponse> reset(
core.String leaderboardId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/leaderboards/' +
commons.escapeVariable('$leaderboardId') +
'/scores/reset';
final response_ = await _requester.request(
url_,
'POST',
queryParams: queryParams_,
);
return PlayerScoreResetResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Resets all scores for all leaderboards for the currently authenticated
/// players.
///
/// This method is only accessible to whitelisted tester accounts for your
/// application.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PlayerScoreResetAllResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PlayerScoreResetAllResponse> resetAll({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/scores/reset';
final response_ = await _requester.request(
url_,
'POST',
queryParams: queryParams_,
);
return PlayerScoreResetAllResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Resets scores for all draft leaderboards for all players.
///
/// This method is only available to user accounts for your developer console.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetAllForAllPlayers({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/scores/resetAllForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets scores for the leaderboard with the given ID for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft leaderboards can be reset.
///
/// Request parameters:
///
/// [leaderboardId] - The ID of the leaderboard.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetForAllPlayers(
core.String leaderboardId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'games/v1management/leaderboards/' +
commons.escapeVariable('$leaderboardId') +
'/scores/resetForAllPlayers';
await _requester.request(
url_,
'POST',
queryParams: queryParams_,
downloadOptions: null,
);
}
/// Resets scores for the leaderboards with the given IDs for all players.
///
/// This method is only available to user accounts for your developer console.
/// Only draft leaderboards may be reset.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<void> resetMultipleForAllPlayers(
ScoresResetMultipleForAllRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'games/v1management/scores/resetMultipleForAllPlayers';
await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
downloadOptions: null,
);
}
}
/// Achievement reset all response.
class AchievementResetAllResponse {
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#achievementResetAllResponse`.
core.String? kind;
/// The achievement reset results.
core.List<AchievementResetResponse>? results;
AchievementResetAllResponse({
this.kind,
this.results,
});
AchievementResetAllResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
results: json_.containsKey('results')
? (json_['results'] as core.List)
.map((value) => AchievementResetResponse.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (results != null) 'results': results!,
};
}
class AchievementResetMultipleForAllRequest {
/// The IDs of achievements to reset.
core.List<core.String>? achievementIds;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#achievementResetMultipleForAllRequest`.
core.String? kind;
AchievementResetMultipleForAllRequest({
this.achievementIds,
this.kind,
});
AchievementResetMultipleForAllRequest.fromJson(core.Map json_)
: this(
achievementIds: json_.containsKey('achievement_ids')
? (json_['achievement_ids'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (achievementIds != null) 'achievement_ids': achievementIds!,
if (kind != null) 'kind': kind!,
};
}
/// An achievement reset response.
class AchievementResetResponse {
/// The current state of the achievement.
///
/// This is the same as the initial state of the achievement. Possible values
/// are: - "`HIDDEN`"- Achievement is hidden. - "`REVEALED`" - Achievement is
/// revealed. - "`UNLOCKED`" - Achievement is unlocked.
core.String? currentState;
/// The ID of an achievement for which player state has been updated.
core.String? definitionId;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#achievementResetResponse`.
core.String? kind;
/// Flag to indicate if the requested update actually occurred.
core.bool? updateOccurred;
AchievementResetResponse({
this.currentState,
this.definitionId,
this.kind,
this.updateOccurred,
});
AchievementResetResponse.fromJson(core.Map json_)
: this(
currentState: json_.containsKey('currentState')
? json_['currentState'] as core.String
: null,
definitionId: json_.containsKey('definitionId')
? json_['definitionId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
updateOccurred: json_.containsKey('updateOccurred')
? json_['updateOccurred'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (currentState != null) 'currentState': currentState!,
if (definitionId != null) 'definitionId': definitionId!,
if (kind != null) 'kind': kind!,
if (updateOccurred != null) 'updateOccurred': updateOccurred!,
};
}
/// Multiple events reset all request.
class EventsResetMultipleForAllRequest {
/// The IDs of events to reset.
core.List<core.String>? eventIds;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#eventsResetMultipleForAllRequest`.
core.String? kind;
EventsResetMultipleForAllRequest({
this.eventIds,
this.kind,
});
EventsResetMultipleForAllRequest.fromJson(core.Map json_)
: this(
eventIds: json_.containsKey('event_ids')
? (json_['event_ids'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (eventIds != null) 'event_ids': eventIds!,
if (kind != null) 'kind': kind!,
};
}
/// 1P/3P metadata about the player's experience.
class GamesPlayerExperienceInfoResource {
/// The current number of experience points for the player.
core.String? currentExperiencePoints;
/// The current level of the player.
GamesPlayerLevelResource? currentLevel;
/// The timestamp when the player was leveled up, in millis since Unix epoch
/// UTC.
core.String? lastLevelUpTimestampMillis;
/// The next level of the player.
///
/// If the current level is the maximum level, this should be same as the
/// current level.
GamesPlayerLevelResource? nextLevel;
GamesPlayerExperienceInfoResource({
this.currentExperiencePoints,
this.currentLevel,
this.lastLevelUpTimestampMillis,
this.nextLevel,
});
GamesPlayerExperienceInfoResource.fromJson(core.Map json_)
: this(
currentExperiencePoints: json_.containsKey('currentExperiencePoints')
? json_['currentExperiencePoints'] as core.String
: null,
currentLevel: json_.containsKey('currentLevel')
? GamesPlayerLevelResource.fromJson(
json_['currentLevel'] as core.Map<core.String, core.dynamic>)
: null,
lastLevelUpTimestampMillis:
json_.containsKey('lastLevelUpTimestampMillis')
? json_['lastLevelUpTimestampMillis'] as core.String
: null,
nextLevel: json_.containsKey('nextLevel')
? GamesPlayerLevelResource.fromJson(
json_['nextLevel'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (currentExperiencePoints != null)
'currentExperiencePoints': currentExperiencePoints!,
if (currentLevel != null) 'currentLevel': currentLevel!,
if (lastLevelUpTimestampMillis != null)
'lastLevelUpTimestampMillis': lastLevelUpTimestampMillis!,
if (nextLevel != null) 'nextLevel': nextLevel!,
};
}
/// 1P/3P metadata about a user's level.
class GamesPlayerLevelResource {
/// The level for the user.
core.int? level;
/// The maximum experience points for this level.
core.String? maxExperiencePoints;
/// The minimum experience points for this level.
core.String? minExperiencePoints;
GamesPlayerLevelResource({
this.level,
this.maxExperiencePoints,
this.minExperiencePoints,
});
GamesPlayerLevelResource.fromJson(core.Map json_)
: this(
level: json_.containsKey('level') ? json_['level'] as core.int : null,
maxExperiencePoints: json_.containsKey('maxExperiencePoints')
? json_['maxExperiencePoints'] as core.String
: null,
minExperiencePoints: json_.containsKey('minExperiencePoints')
? json_['minExperiencePoints'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (level != null) 'level': level!,
if (maxExperiencePoints != null)
'maxExperiencePoints': maxExperiencePoints!,
if (minExperiencePoints != null)
'minExperiencePoints': minExperiencePoints!,
};
}
/// The HiddenPlayer resource.
class HiddenPlayer {
/// The time this player was hidden.
///
/// Output only.
core.String? hiddenTimeMillis;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string `gamesManagement#hiddenPlayer`.
///
/// Output only.
core.String? kind;
/// The player information.
///
/// Output only.
Player? player;
HiddenPlayer({
this.hiddenTimeMillis,
this.kind,
this.player,
});
HiddenPlayer.fromJson(core.Map json_)
: this(
hiddenTimeMillis: json_.containsKey('hiddenTimeMillis')
? json_['hiddenTimeMillis'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
player: json_.containsKey('player')
? Player.fromJson(
json_['player'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (hiddenTimeMillis != null) 'hiddenTimeMillis': hiddenTimeMillis!,
if (kind != null) 'kind': kind!,
if (player != null) 'player': player!,
};
}
/// A list of hidden players.
class HiddenPlayerList {
/// The players.
core.List<HiddenPlayer>? items;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string `gamesManagement#hiddenPlayerList`.
core.String? kind;
/// The pagination token for the next page of results.
core.String? nextPageToken;
HiddenPlayerList({
this.items,
this.kind,
this.nextPageToken,
});
HiddenPlayerList.fromJson(core.Map json_)
: this(
items: json_.containsKey('items')
? (json_['items'] as core.List)
.map((value) => HiddenPlayer.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (items != null) 'items': items!,
if (kind != null) 'kind': kind!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
};
}
/// An object representation of the individual components of the player's name.
///
/// For some players, these fields may not be present.
class PlayerName {
/// The family name of this player.
///
/// In some places, this is known as the last name.
core.String? familyName;
/// The given name of this player.
///
/// In some places, this is known as the first name.
core.String? givenName;
PlayerName({
this.familyName,
this.givenName,
});
PlayerName.fromJson(core.Map json_)
: this(
familyName: json_.containsKey('familyName')
? json_['familyName'] as core.String
: null,
givenName: json_.containsKey('givenName')
? json_['givenName'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (familyName != null) 'familyName': familyName!,
if (givenName != null) 'givenName': givenName!,
};
}
/// A Player resource.
class Player {
/// The base URL for the image that represents the player.
core.String? avatarImageUrl;
/// The url to the landscape mode player banner image.
core.String? bannerUrlLandscape;
/// The url to the portrait mode player banner image.
core.String? bannerUrlPortrait;
/// The name to display for the player.
core.String? displayName;
/// An object to represent Play Game experience information for the player.
GamesPlayerExperienceInfoResource? experienceInfo;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string `gamesManagement#player`.
core.String? kind;
/// An object representation of the individual components of the player's
/// name.
///
/// For some players, these fields may not be present.
PlayerName? name;
/// The player ID that was used for this player the first time they signed
/// into the game in question.
///
/// This is only populated for calls to player.get for the requesting player,
/// only if the player ID has subsequently changed, and only to clients that
/// support remapping player IDs.
core.String? originalPlayerId;
/// The ID of the player.
core.String? playerId;
/// The player's profile settings.
///
/// Controls whether or not the player's profile is visible to other players.
ProfileSettings? profileSettings;
/// The player's title rewarded for their game activities.
core.String? title;
Player({
this.avatarImageUrl,
this.bannerUrlLandscape,
this.bannerUrlPortrait,
this.displayName,
this.experienceInfo,
this.kind,
this.name,
this.originalPlayerId,
this.playerId,
this.profileSettings,
this.title,
});
Player.fromJson(core.Map json_)
: this(
avatarImageUrl: json_.containsKey('avatarImageUrl')
? json_['avatarImageUrl'] as core.String
: null,
bannerUrlLandscape: json_.containsKey('bannerUrlLandscape')
? json_['bannerUrlLandscape'] as core.String
: null,
bannerUrlPortrait: json_.containsKey('bannerUrlPortrait')
? json_['bannerUrlPortrait'] as core.String
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
experienceInfo: json_.containsKey('experienceInfo')
? GamesPlayerExperienceInfoResource.fromJson(
json_['experienceInfo']
as core.Map<core.String, core.dynamic>)
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
name: json_.containsKey('name')
? PlayerName.fromJson(
json_['name'] as core.Map<core.String, core.dynamic>)
: null,
originalPlayerId: json_.containsKey('originalPlayerId')
? json_['originalPlayerId'] as core.String
: null,
playerId: json_.containsKey('playerId')
? json_['playerId'] as core.String
: null,
profileSettings: json_.containsKey('profileSettings')
? ProfileSettings.fromJson(json_['profileSettings']
as core.Map<core.String, core.dynamic>)
: null,
title:
json_.containsKey('title') ? json_['title'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (avatarImageUrl != null) 'avatarImageUrl': avatarImageUrl!,
if (bannerUrlLandscape != null)
'bannerUrlLandscape': bannerUrlLandscape!,
if (bannerUrlPortrait != null) 'bannerUrlPortrait': bannerUrlPortrait!,
if (displayName != null) 'displayName': displayName!,
if (experienceInfo != null) 'experienceInfo': experienceInfo!,
if (kind != null) 'kind': kind!,
if (name != null) 'name': name!,
if (originalPlayerId != null) 'originalPlayerId': originalPlayerId!,
if (playerId != null) 'playerId': playerId!,
if (profileSettings != null) 'profileSettings': profileSettings!,
if (title != null) 'title': title!,
};
}
/// A list of leaderboard reset resources.
class PlayerScoreResetAllResponse {
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#playerScoreResetAllResponse`.
core.String? kind;
/// The leaderboard reset results.
core.List<PlayerScoreResetResponse>? results;
PlayerScoreResetAllResponse({
this.kind,
this.results,
});
PlayerScoreResetAllResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
results: json_.containsKey('results')
? (json_['results'] as core.List)
.map((value) => PlayerScoreResetResponse.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (results != null) 'results': results!,
};
}
/// A list of reset leaderboard entry resources.
class PlayerScoreResetResponse {
/// The ID of an leaderboard for which player state has been updated.
core.String? definitionId;
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#playerScoreResetResponse`.
core.String? kind;
/// The time spans of the updated score.
///
/// Possible values are: - "`ALL_TIME`" - The score is an all-time score. -
/// "`WEEKLY`" - The score is a weekly score. - "`DAILY`" - The score is a
/// daily score.
core.List<core.String>? resetScoreTimeSpans;
PlayerScoreResetResponse({
this.definitionId,
this.kind,
this.resetScoreTimeSpans,
});
PlayerScoreResetResponse.fromJson(core.Map json_)
: this(
definitionId: json_.containsKey('definitionId')
? json_['definitionId'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
resetScoreTimeSpans: json_.containsKey('resetScoreTimeSpans')
? (json_['resetScoreTimeSpans'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (definitionId != null) 'definitionId': definitionId!,
if (kind != null) 'kind': kind!,
if (resetScoreTimeSpans != null)
'resetScoreTimeSpans': resetScoreTimeSpans!,
};
}
/// Profile settings
class ProfileSettings {
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string `gamesManagement#profileSettings`.
core.String? kind;
core.bool? profileVisible;
ProfileSettings({
this.kind,
this.profileVisible,
});
ProfileSettings.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
profileVisible: json_.containsKey('profileVisible')
? json_['profileVisible'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (profileVisible != null) 'profileVisible': profileVisible!,
};
}
class ScoresResetMultipleForAllRequest {
/// Uniquely identifies the type of this resource.
///
/// Value is always the fixed string
/// `gamesManagement#scoresResetMultipleForAllRequest`.
core.String? kind;
/// The IDs of leaderboards to reset.
core.List<core.String>? leaderboardIds;
ScoresResetMultipleForAllRequest({
this.kind,
this.leaderboardIds,
});
ScoresResetMultipleForAllRequest.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
leaderboardIds: json_.containsKey('leaderboard_ids')
? (json_['leaderboard_ids'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (leaderboardIds != null) 'leaderboard_ids': leaderboardIds!,
};
}
|
googleapis.dart/generated/googleapis/lib/gamesmanagement/v1management.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/gamesmanagement/v1management.dart', 'repo_id': 'googleapis.dart', 'token_count': 15349}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Google Identity Toolkit API - v3
///
/// Help the third party sites to implement federated login.
///
/// For more information, see
/// <https://developers.google.com/identity-toolkit/v3/>
///
/// Create an instance of [IdentityToolkitApi] to access these resources:
///
/// - [RelyingpartyResource]
library identitytoolkit_v3;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
/// Help the third party sites to implement federated login.
class IdentityToolkitApi {
/// View and manage your data across Google Cloud Platform services
static const cloudPlatformScope =
'https://www.googleapis.com/auth/cloud-platform';
/// View and administer all your Firebase data and settings
static const firebaseScope = 'https://www.googleapis.com/auth/firebase';
final commons.ApiRequester _requester;
RelyingpartyResource get relyingparty => RelyingpartyResource(_requester);
IdentityToolkitApi(http.Client client,
{core.String rootUrl = 'https://www.googleapis.com/',
core.String servicePath = 'identitytoolkit/v3/relyingparty/'})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class RelyingpartyResource {
final commons.ApiRequester _requester;
RelyingpartyResource(commons.ApiRequester client) : _requester = client;
/// Creates the URI used by the IdP to authenticate the user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [CreateAuthUriResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<CreateAuthUriResponse> createAuthUri(
IdentitytoolkitRelyingpartyCreateAuthUriRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'createAuthUri';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return CreateAuthUriResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Delete user account.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [DeleteAccountResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<DeleteAccountResponse> deleteAccount(
IdentitytoolkitRelyingpartyDeleteAccountRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'deleteAccount';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return DeleteAccountResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Batch download user accounts.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [DownloadAccountResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<DownloadAccountResponse> downloadAccount(
IdentitytoolkitRelyingpartyDownloadAccountRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'downloadAccount';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return DownloadAccountResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Reset password for a user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EmailLinkSigninResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EmailLinkSigninResponse> emailLinkSignin(
IdentitytoolkitRelyingpartyEmailLinkSigninRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'emailLinkSignin';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return EmailLinkSigninResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Returns the account info.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GetAccountInfoResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GetAccountInfoResponse> getAccountInfo(
IdentitytoolkitRelyingpartyGetAccountInfoRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'getAccountInfo';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GetAccountInfoResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Get a code for user action confirmation.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GetOobConfirmationCodeResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GetOobConfirmationCodeResponse> getOobConfirmationCode(
Relyingparty request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'getOobConfirmationCode';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return GetOobConfirmationCodeResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Get project configuration.
///
/// Request parameters:
///
/// [delegatedProjectNumber] - Delegated GCP project number of the request.
///
/// [projectNumber] - GCP project number of the request.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [IdentitytoolkitRelyingpartyGetProjectConfigResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartyGetProjectConfigResponse>
getProjectConfig({
core.String? delegatedProjectNumber,
core.String? projectNumber,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (delegatedProjectNumber != null)
'delegatedProjectNumber': [delegatedProjectNumber],
if (projectNumber != null) 'projectNumber': [projectNumber],
if ($fields != null) 'fields': [$fields],
};
const url_ = 'getProjectConfig';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return IdentitytoolkitRelyingpartyGetProjectConfigResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Get token signing public key.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [IdentitytoolkitRelyingpartyGetPublicKeysResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartyGetPublicKeysResponse> getPublicKeys({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'publicKeys';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return (response_ as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
);
}
/// Get recaptcha secure param.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GetRecaptchaParamResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<GetRecaptchaParamResponse> getRecaptchaParam({
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'getRecaptchaParam';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return GetRecaptchaParamResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Reset password for a user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ResetPasswordResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ResetPasswordResponse> resetPassword(
IdentitytoolkitRelyingpartyResetPasswordRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'resetPassword';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return ResetPasswordResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Send SMS verification code.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a
/// [IdentitytoolkitRelyingpartySendVerificationCodeResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartySendVerificationCodeResponse>
sendVerificationCode(
IdentitytoolkitRelyingpartySendVerificationCodeRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'sendVerificationCode';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return IdentitytoolkitRelyingpartySendVerificationCodeResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Set account info for a user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [SetAccountInfoResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<SetAccountInfoResponse> setAccountInfo(
IdentitytoolkitRelyingpartySetAccountInfoRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'setAccountInfo';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return SetAccountInfoResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Set project configuration.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [IdentitytoolkitRelyingpartySetProjectConfigResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartySetProjectConfigResponse>
setProjectConfig(
IdentitytoolkitRelyingpartySetProjectConfigRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'setProjectConfig';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return IdentitytoolkitRelyingpartySetProjectConfigResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Sign out user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [IdentitytoolkitRelyingpartySignOutUserResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartySignOutUserResponse> signOutUser(
IdentitytoolkitRelyingpartySignOutUserRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'signOutUser';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return IdentitytoolkitRelyingpartySignOutUserResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Signup new user.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [SignupNewUserResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<SignupNewUserResponse> signupNewUser(
IdentitytoolkitRelyingpartySignupNewUserRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'signupNewUser';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return SignupNewUserResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Batch upload existing user accounts.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [UploadAccountResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<UploadAccountResponse> uploadAccount(
IdentitytoolkitRelyingpartyUploadAccountRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'uploadAccount';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return UploadAccountResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Verifies the assertion returned by the IdP.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [VerifyAssertionResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<VerifyAssertionResponse> verifyAssertion(
IdentitytoolkitRelyingpartyVerifyAssertionRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'verifyAssertion';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return VerifyAssertionResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Verifies the developer asserted ID token.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [VerifyCustomTokenResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<VerifyCustomTokenResponse> verifyCustomToken(
IdentitytoolkitRelyingpartyVerifyCustomTokenRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'verifyCustomToken';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return VerifyCustomTokenResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Verifies the user entered password.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [VerifyPasswordResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<VerifyPasswordResponse> verifyPassword(
IdentitytoolkitRelyingpartyVerifyPasswordRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'verifyPassword';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return VerifyPasswordResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Verifies ownership of a phone number and creates/updates the user account
/// accordingly.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse>
verifyPhoneNumber(
IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'verifyPhoneNumber';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
/// Response of creating the IDP authentication URL.
class CreateAuthUriResponse {
/// all providers the user has once used to do federated login
core.List<core.String>? allProviders;
/// The URI used by the IDP to authenticate the user.
core.String? authUri;
/// True if captcha is required.
core.bool? captchaRequired;
/// True if the authUri is for user's existing provider.
core.bool? forExistingProvider;
/// The fixed string identitytoolkit#CreateAuthUriResponse".
core.String? kind;
/// The provider ID of the auth URI.
core.String? providerId;
/// Whether the user is registered if the identifier is an email.
core.bool? registered;
/// Session ID which should be passed in the following verifyAssertion
/// request.
core.String? sessionId;
/// All sign-in methods this user has used.
core.List<core.String>? signinMethods;
CreateAuthUriResponse({
this.allProviders,
this.authUri,
this.captchaRequired,
this.forExistingProvider,
this.kind,
this.providerId,
this.registered,
this.sessionId,
this.signinMethods,
});
CreateAuthUriResponse.fromJson(core.Map json_)
: this(
allProviders: json_.containsKey('allProviders')
? (json_['allProviders'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
authUri: json_.containsKey('authUri')
? json_['authUri'] as core.String
: null,
captchaRequired: json_.containsKey('captchaRequired')
? json_['captchaRequired'] as core.bool
: null,
forExistingProvider: json_.containsKey('forExistingProvider')
? json_['forExistingProvider'] as core.bool
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
providerId: json_.containsKey('providerId')
? json_['providerId'] as core.String
: null,
registered: json_.containsKey('registered')
? json_['registered'] as core.bool
: null,
sessionId: json_.containsKey('sessionId')
? json_['sessionId'] as core.String
: null,
signinMethods: json_.containsKey('signinMethods')
? (json_['signinMethods'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (allProviders != null) 'allProviders': allProviders!,
if (authUri != null) 'authUri': authUri!,
if (captchaRequired != null) 'captchaRequired': captchaRequired!,
if (forExistingProvider != null)
'forExistingProvider': forExistingProvider!,
if (kind != null) 'kind': kind!,
if (providerId != null) 'providerId': providerId!,
if (registered != null) 'registered': registered!,
if (sessionId != null) 'sessionId': sessionId!,
if (signinMethods != null) 'signinMethods': signinMethods!,
};
}
/// Respone of deleting account.
class DeleteAccountResponse {
/// The fixed string "identitytoolkit#DeleteAccountResponse".
core.String? kind;
DeleteAccountResponse({
this.kind,
});
DeleteAccountResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
};
}
/// Response of downloading accounts in batch.
class DownloadAccountResponse {
/// The fixed string "identitytoolkit#DownloadAccountResponse".
core.String? kind;
/// The next page token.
///
/// To be used in a subsequent request to return the next page of results.
core.String? nextPageToken;
/// The user accounts data.
core.List<UserInfo>? users;
DownloadAccountResponse({
this.kind,
this.nextPageToken,
this.users,
});
DownloadAccountResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
users: json_.containsKey('users')
? (json_['users'] as core.List)
.map((value) => UserInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (users != null) 'users': users!,
};
}
/// Response of email signIn.
class EmailLinkSigninResponse {
/// The user's email.
core.String? email;
/// Expiration time of STS id token in seconds.
core.String? expiresIn;
/// The STS id token to login the newly signed in user.
core.String? idToken;
/// Whether the user is new.
core.bool? isNewUser;
/// The fixed string "identitytoolkit#EmailLinkSigninResponse".
core.String? kind;
/// The RP local ID of the user.
core.String? localId;
/// The refresh token for the signed in user.
core.String? refreshToken;
EmailLinkSigninResponse({
this.email,
this.expiresIn,
this.idToken,
this.isNewUser,
this.kind,
this.localId,
this.refreshToken,
});
EmailLinkSigninResponse.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
isNewUser: json_.containsKey('isNewUser')
? json_['isNewUser'] as core.bool
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (isNewUser != null) 'isNewUser': isNewUser!,
if (kind != null) 'kind': kind!,
if (localId != null) 'localId': localId!,
if (refreshToken != null) 'refreshToken': refreshToken!,
};
}
/// Template for an email template.
class EmailTemplate {
/// Email body.
core.String? body;
/// Email body format.
core.String? format;
/// From address of the email.
core.String? from;
/// From display name.
core.String? fromDisplayName;
/// Reply-to address.
core.String? replyTo;
/// Subject of the email.
core.String? subject;
EmailTemplate({
this.body,
this.format,
this.from,
this.fromDisplayName,
this.replyTo,
this.subject,
});
EmailTemplate.fromJson(core.Map json_)
: this(
body: json_.containsKey('body') ? json_['body'] as core.String : null,
format: json_.containsKey('format')
? json_['format'] as core.String
: null,
from: json_.containsKey('from') ? json_['from'] as core.String : null,
fromDisplayName: json_.containsKey('fromDisplayName')
? json_['fromDisplayName'] as core.String
: null,
replyTo: json_.containsKey('replyTo')
? json_['replyTo'] as core.String
: null,
subject: json_.containsKey('subject')
? json_['subject'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (body != null) 'body': body!,
if (format != null) 'format': format!,
if (from != null) 'from': from!,
if (fromDisplayName != null) 'fromDisplayName': fromDisplayName!,
if (replyTo != null) 'replyTo': replyTo!,
if (subject != null) 'subject': subject!,
};
}
/// Response of getting account information.
class GetAccountInfoResponse {
/// The fixed string "identitytoolkit#GetAccountInfoResponse".
core.String? kind;
/// The info of the users.
core.List<UserInfo>? users;
GetAccountInfoResponse({
this.kind,
this.users,
});
GetAccountInfoResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
users: json_.containsKey('users')
? (json_['users'] as core.List)
.map((value) => UserInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (users != null) 'users': users!,
};
}
/// Response of getting a code for user confirmation (reset password, change
/// email etc.).
class GetOobConfirmationCodeResponse {
/// The email address that the email is sent to.
core.String? email;
/// The fixed string "identitytoolkit#GetOobConfirmationCodeResponse".
core.String? kind;
/// The code to be send to the user.
core.String? oobCode;
GetOobConfirmationCodeResponse({
this.email,
this.kind,
this.oobCode,
});
GetOobConfirmationCodeResponse.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
oobCode: json_.containsKey('oobCode')
? json_['oobCode'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (kind != null) 'kind': kind!,
if (oobCode != null) 'oobCode': oobCode!,
};
}
/// Response of getting recaptcha param.
class GetRecaptchaParamResponse {
/// The fixed string "identitytoolkit#GetRecaptchaParamResponse".
core.String? kind;
/// Site key registered at recaptcha.
core.String? recaptchaSiteKey;
/// The stoken field for the recaptcha widget, used to request captcha
/// challenge.
core.String? recaptchaStoken;
GetRecaptchaParamResponse({
this.kind,
this.recaptchaSiteKey,
this.recaptchaStoken,
});
GetRecaptchaParamResponse.fromJson(core.Map json_)
: this(
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
recaptchaSiteKey: json_.containsKey('recaptchaSiteKey')
? json_['recaptchaSiteKey'] as core.String
: null,
recaptchaStoken: json_.containsKey('recaptchaStoken')
? json_['recaptchaStoken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (kind != null) 'kind': kind!,
if (recaptchaSiteKey != null) 'recaptchaSiteKey': recaptchaSiteKey!,
if (recaptchaStoken != null) 'recaptchaStoken': recaptchaStoken!,
};
}
/// Request to get the IDP authentication URL.
class IdentitytoolkitRelyingpartyCreateAuthUriRequest {
/// The app ID of the mobile app, base64(CERT_SHA1):PACKAGE_NAME for Android,
/// BUNDLE_ID for iOS.
core.String? appId;
/// Explicitly specify the auth flow type.
///
/// Currently only support "CODE_FLOW" type. The field is only used for Google
/// provider.
core.String? authFlowType;
/// The relying party OAuth client ID.
core.String? clientId;
/// The opaque value used by the client to maintain context info between the
/// authentication request and the IDP callback.
core.String? context;
/// The URI to which the IDP redirects the user after the federated login
/// flow.
core.String? continueUri;
/// The query parameter that client can customize by themselves in auth url.
///
/// The following parameters are reserved for server so that they cannot be
/// customized by clients: client_id, response_type, scope, redirect_uri,
/// state, oauth_token.
core.Map<core.String, core.String>? customParameter;
/// The hosted domain to restrict sign-in to accounts at that domain for
/// Google Apps hosted accounts.
core.String? hostedDomain;
/// The email or federated ID of the user.
core.String? identifier;
/// The developer's consumer key for OpenId OAuth Extension
core.String? oauthConsumerKey;
/// Additional oauth scopes, beyond the basid user profile, that the user
/// would be prompted to grant
core.String? oauthScope;
/// Optional realm for OpenID protocol.
///
/// The sub string "scheme://domain:port" of the param "continueUri" is used
/// if this is not set.
core.String? openidRealm;
/// The native app package for OTA installation.
core.String? otaApp;
/// The IdP ID.
///
/// For white listed IdPs it's a short domain name e.g. google.com, aol.com,
/// live.net and yahoo.com. For other OpenID IdPs it's the OP identifier.
core.String? providerId;
/// The session_id passed by client.
core.String? sessionId;
/// For multi-tenant use cases, in order to construct sign-in URL with the
/// correct IDP parameters, Firebear needs to know which Tenant to retrieve
/// IDP configs from.
core.String? tenantId;
/// Tenant project number to be used for idp discovery.
core.String? tenantProjectNumber;
IdentitytoolkitRelyingpartyCreateAuthUriRequest({
this.appId,
this.authFlowType,
this.clientId,
this.context,
this.continueUri,
this.customParameter,
this.hostedDomain,
this.identifier,
this.oauthConsumerKey,
this.oauthScope,
this.openidRealm,
this.otaApp,
this.providerId,
this.sessionId,
this.tenantId,
this.tenantProjectNumber,
});
IdentitytoolkitRelyingpartyCreateAuthUriRequest.fromJson(core.Map json_)
: this(
appId:
json_.containsKey('appId') ? json_['appId'] as core.String : null,
authFlowType: json_.containsKey('authFlowType')
? json_['authFlowType'] as core.String
: null,
clientId: json_.containsKey('clientId')
? json_['clientId'] as core.String
: null,
context: json_.containsKey('context')
? json_['context'] as core.String
: null,
continueUri: json_.containsKey('continueUri')
? json_['continueUri'] as core.String
: null,
customParameter: json_.containsKey('customParameter')
? (json_['customParameter']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
hostedDomain: json_.containsKey('hostedDomain')
? json_['hostedDomain'] as core.String
: null,
identifier: json_.containsKey('identifier')
? json_['identifier'] as core.String
: null,
oauthConsumerKey: json_.containsKey('oauthConsumerKey')
? json_['oauthConsumerKey'] as core.String
: null,
oauthScope: json_.containsKey('oauthScope')
? json_['oauthScope'] as core.String
: null,
openidRealm: json_.containsKey('openidRealm')
? json_['openidRealm'] as core.String
: null,
otaApp: json_.containsKey('otaApp')
? json_['otaApp'] as core.String
: null,
providerId: json_.containsKey('providerId')
? json_['providerId'] as core.String
: null,
sessionId: json_.containsKey('sessionId')
? json_['sessionId'] as core.String
: null,
tenantId: json_.containsKey('tenantId')
? json_['tenantId'] as core.String
: null,
tenantProjectNumber: json_.containsKey('tenantProjectNumber')
? json_['tenantProjectNumber'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (appId != null) 'appId': appId!,
if (authFlowType != null) 'authFlowType': authFlowType!,
if (clientId != null) 'clientId': clientId!,
if (context != null) 'context': context!,
if (continueUri != null) 'continueUri': continueUri!,
if (customParameter != null) 'customParameter': customParameter!,
if (hostedDomain != null) 'hostedDomain': hostedDomain!,
if (identifier != null) 'identifier': identifier!,
if (oauthConsumerKey != null) 'oauthConsumerKey': oauthConsumerKey!,
if (oauthScope != null) 'oauthScope': oauthScope!,
if (openidRealm != null) 'openidRealm': openidRealm!,
if (otaApp != null) 'otaApp': otaApp!,
if (providerId != null) 'providerId': providerId!,
if (sessionId != null) 'sessionId': sessionId!,
if (tenantId != null) 'tenantId': tenantId!,
if (tenantProjectNumber != null)
'tenantProjectNumber': tenantProjectNumber!,
};
}
/// Request to delete account.
class IdentitytoolkitRelyingpartyDeleteAccountRequest {
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The GITKit token or STS id token of the authenticated user.
core.String? idToken;
/// The local ID of the user.
core.String? localId;
IdentitytoolkitRelyingpartyDeleteAccountRequest({
this.delegatedProjectNumber,
this.idToken,
this.localId,
});
IdentitytoolkitRelyingpartyDeleteAccountRequest.fromJson(core.Map json_)
: this(
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (idToken != null) 'idToken': idToken!,
if (localId != null) 'localId': localId!,
};
}
/// Request to download user account in batch.
class IdentitytoolkitRelyingpartyDownloadAccountRequest {
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The max number of results to return in the response.
core.int? maxResults;
/// The token for the next page.
///
/// This should be taken from the previous response.
core.String? nextPageToken;
/// Specify which project (field value is actually project id) to operate.
///
/// Only used when provided credential.
core.String? targetProjectId;
IdentitytoolkitRelyingpartyDownloadAccountRequest({
this.delegatedProjectNumber,
this.maxResults,
this.nextPageToken,
this.targetProjectId,
});
IdentitytoolkitRelyingpartyDownloadAccountRequest.fromJson(core.Map json_)
: this(
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
maxResults: json_.containsKey('maxResults')
? json_['maxResults'] as core.int
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
targetProjectId: json_.containsKey('targetProjectId')
? json_['targetProjectId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (maxResults != null) 'maxResults': maxResults!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (targetProjectId != null) 'targetProjectId': targetProjectId!,
};
}
/// Request to sign in with email.
class IdentitytoolkitRelyingpartyEmailLinkSigninRequest {
/// The email address of the user.
core.String? email;
/// Token for linking flow.
core.String? idToken;
/// The confirmation code.
core.String? oobCode;
IdentitytoolkitRelyingpartyEmailLinkSigninRequest({
this.email,
this.idToken,
this.oobCode,
});
IdentitytoolkitRelyingpartyEmailLinkSigninRequest.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
oobCode: json_.containsKey('oobCode')
? json_['oobCode'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (idToken != null) 'idToken': idToken!,
if (oobCode != null) 'oobCode': oobCode!,
};
}
/// Request to get the account information.
class IdentitytoolkitRelyingpartyGetAccountInfoRequest {
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The list of emails of the users to inquiry.
core.List<core.String>? email;
/// The GITKit token of the authenticated user.
core.String? idToken;
/// The list of local ID's of the users to inquiry.
core.List<core.String>? localId;
/// Privileged caller can query users by specified phone number.
core.List<core.String>? phoneNumber;
IdentitytoolkitRelyingpartyGetAccountInfoRequest({
this.delegatedProjectNumber,
this.email,
this.idToken,
this.localId,
this.phoneNumber,
});
IdentitytoolkitRelyingpartyGetAccountInfoRequest.fromJson(core.Map json_)
: this(
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
email: json_.containsKey('email')
? (json_['email'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
localId: json_.containsKey('localId')
? (json_['localId'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
phoneNumber: json_.containsKey('phoneNumber')
? (json_['phoneNumber'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (email != null) 'email': email!,
if (idToken != null) 'idToken': idToken!,
if (localId != null) 'localId': localId!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
};
}
/// Response of getting the project configuration.
class IdentitytoolkitRelyingpartyGetProjectConfigResponse {
/// Whether to allow password user sign in or sign up.
core.bool? allowPasswordUser;
/// Browser API key, needed when making http request to Apiary.
core.String? apiKey;
/// Authorized domains.
core.List<core.String>? authorizedDomains;
/// Change email template.
EmailTemplate? changeEmailTemplate;
core.String? dynamicLinksDomain;
/// Whether anonymous user is enabled.
core.bool? enableAnonymousUser;
/// OAuth2 provider configuration.
core.List<IdpConfig>? idpConfig;
/// Legacy reset password email template.
EmailTemplate? legacyResetPasswordTemplate;
/// Project ID of the relying party.
core.String? projectId;
/// Reset password email template.
EmailTemplate? resetPasswordTemplate;
/// Whether to use email sending provided by Firebear.
core.bool? useEmailSending;
/// Verify email template.
EmailTemplate? verifyEmailTemplate;
IdentitytoolkitRelyingpartyGetProjectConfigResponse({
this.allowPasswordUser,
this.apiKey,
this.authorizedDomains,
this.changeEmailTemplate,
this.dynamicLinksDomain,
this.enableAnonymousUser,
this.idpConfig,
this.legacyResetPasswordTemplate,
this.projectId,
this.resetPasswordTemplate,
this.useEmailSending,
this.verifyEmailTemplate,
});
IdentitytoolkitRelyingpartyGetProjectConfigResponse.fromJson(core.Map json_)
: this(
allowPasswordUser: json_.containsKey('allowPasswordUser')
? json_['allowPasswordUser'] as core.bool
: null,
apiKey: json_.containsKey('apiKey')
? json_['apiKey'] as core.String
: null,
authorizedDomains: json_.containsKey('authorizedDomains')
? (json_['authorizedDomains'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
changeEmailTemplate: json_.containsKey('changeEmailTemplate')
? EmailTemplate.fromJson(json_['changeEmailTemplate']
as core.Map<core.String, core.dynamic>)
: null,
dynamicLinksDomain: json_.containsKey('dynamicLinksDomain')
? json_['dynamicLinksDomain'] as core.String
: null,
enableAnonymousUser: json_.containsKey('enableAnonymousUser')
? json_['enableAnonymousUser'] as core.bool
: null,
idpConfig: json_.containsKey('idpConfig')
? (json_['idpConfig'] as core.List)
.map((value) => IdpConfig.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
legacyResetPasswordTemplate:
json_.containsKey('legacyResetPasswordTemplate')
? EmailTemplate.fromJson(json_['legacyResetPasswordTemplate']
as core.Map<core.String, core.dynamic>)
: null,
projectId: json_.containsKey('projectId')
? json_['projectId'] as core.String
: null,
resetPasswordTemplate: json_.containsKey('resetPasswordTemplate')
? EmailTemplate.fromJson(json_['resetPasswordTemplate']
as core.Map<core.String, core.dynamic>)
: null,
useEmailSending: json_.containsKey('useEmailSending')
? json_['useEmailSending'] as core.bool
: null,
verifyEmailTemplate: json_.containsKey('verifyEmailTemplate')
? EmailTemplate.fromJson(json_['verifyEmailTemplate']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (allowPasswordUser != null) 'allowPasswordUser': allowPasswordUser!,
if (apiKey != null) 'apiKey': apiKey!,
if (authorizedDomains != null) 'authorizedDomains': authorizedDomains!,
if (changeEmailTemplate != null)
'changeEmailTemplate': changeEmailTemplate!,
if (dynamicLinksDomain != null)
'dynamicLinksDomain': dynamicLinksDomain!,
if (enableAnonymousUser != null)
'enableAnonymousUser': enableAnonymousUser!,
if (idpConfig != null) 'idpConfig': idpConfig!,
if (legacyResetPasswordTemplate != null)
'legacyResetPasswordTemplate': legacyResetPasswordTemplate!,
if (projectId != null) 'projectId': projectId!,
if (resetPasswordTemplate != null)
'resetPasswordTemplate': resetPasswordTemplate!,
if (useEmailSending != null) 'useEmailSending': useEmailSending!,
if (verifyEmailTemplate != null)
'verifyEmailTemplate': verifyEmailTemplate!,
};
}
/// Respone of getting public keys.
typedef IdentitytoolkitRelyingpartyGetPublicKeysResponse
= core.Map<core.String, core.String>;
/// Request to reset the password.
class IdentitytoolkitRelyingpartyResetPasswordRequest {
/// The email address of the user.
core.String? email;
/// The new password inputted by the user.
core.String? newPassword;
/// The old password inputted by the user.
core.String? oldPassword;
/// The confirmation code.
core.String? oobCode;
IdentitytoolkitRelyingpartyResetPasswordRequest({
this.email,
this.newPassword,
this.oldPassword,
this.oobCode,
});
IdentitytoolkitRelyingpartyResetPasswordRequest.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
newPassword: json_.containsKey('newPassword')
? json_['newPassword'] as core.String
: null,
oldPassword: json_.containsKey('oldPassword')
? json_['oldPassword'] as core.String
: null,
oobCode: json_.containsKey('oobCode')
? json_['oobCode'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (newPassword != null) 'newPassword': newPassword!,
if (oldPassword != null) 'oldPassword': oldPassword!,
if (oobCode != null) 'oobCode': oobCode!,
};
}
/// Request for Identitytoolkit-SendVerificationCode
class IdentitytoolkitRelyingpartySendVerificationCodeRequest {
/// Receipt of successful app token validation with APNS.
core.String? iosReceipt;
/// Secret delivered to iOS app via APNS.
core.String? iosSecret;
/// The phone number to send the verification code to in E.164 format.
core.String? phoneNumber;
/// Recaptcha solution.
core.String? recaptchaToken;
IdentitytoolkitRelyingpartySendVerificationCodeRequest({
this.iosReceipt,
this.iosSecret,
this.phoneNumber,
this.recaptchaToken,
});
IdentitytoolkitRelyingpartySendVerificationCodeRequest.fromJson(
core.Map json_)
: this(
iosReceipt: json_.containsKey('iosReceipt')
? json_['iosReceipt'] as core.String
: null,
iosSecret: json_.containsKey('iosSecret')
? json_['iosSecret'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
recaptchaToken: json_.containsKey('recaptchaToken')
? json_['recaptchaToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (iosReceipt != null) 'iosReceipt': iosReceipt!,
if (iosSecret != null) 'iosSecret': iosSecret!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (recaptchaToken != null) 'recaptchaToken': recaptchaToken!,
};
}
/// Response for Identitytoolkit-SendVerificationCode
class IdentitytoolkitRelyingpartySendVerificationCodeResponse {
/// Encrypted session information
core.String? sessionInfo;
IdentitytoolkitRelyingpartySendVerificationCodeResponse({
this.sessionInfo,
});
IdentitytoolkitRelyingpartySendVerificationCodeResponse.fromJson(
core.Map json_)
: this(
sessionInfo: json_.containsKey('sessionInfo')
? json_['sessionInfo'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (sessionInfo != null) 'sessionInfo': sessionInfo!,
};
}
/// Request to set the account information.
class IdentitytoolkitRelyingpartySetAccountInfoRequest {
/// The captcha challenge.
core.String? captchaChallenge;
/// Response to the captcha.
core.String? captchaResponse;
/// The timestamp when the account is created.
core.String? createdAt;
/// The custom attributes to be set in the user's id token.
core.String? customAttributes;
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The attributes users request to delete.
core.List<core.String>? deleteAttribute;
/// The IDPs the user request to delete.
core.List<core.String>? deleteProvider;
/// Whether to disable the user.
core.bool? disableUser;
/// The name of the user.
core.String? displayName;
/// The email of the user.
core.String? email;
/// Mark the email as verified or not.
core.bool? emailVerified;
/// The GITKit token of the authenticated user.
core.String? idToken;
/// Instance id token of the app.
core.String? instanceId;
/// Last login timestamp.
core.String? lastLoginAt;
/// The local ID of the user.
core.String? localId;
/// The out-of-band code of the change email request.
core.String? oobCode;
/// The new password of the user.
core.String? password;
/// Privileged caller can update user with specified phone number.
core.String? phoneNumber;
/// The photo url of the user.
core.String? photoUrl;
/// The associated IDPs of the user.
core.List<core.String>? provider;
/// Whether return sts id token and refresh token instead of gitkit token.
core.bool? returnSecureToken;
/// Mark the user to upgrade to federated login.
core.bool? upgradeToFederatedLogin;
/// Timestamp in seconds for valid login token.
core.String? validSince;
IdentitytoolkitRelyingpartySetAccountInfoRequest({
this.captchaChallenge,
this.captchaResponse,
this.createdAt,
this.customAttributes,
this.delegatedProjectNumber,
this.deleteAttribute,
this.deleteProvider,
this.disableUser,
this.displayName,
this.email,
this.emailVerified,
this.idToken,
this.instanceId,
this.lastLoginAt,
this.localId,
this.oobCode,
this.password,
this.phoneNumber,
this.photoUrl,
this.provider,
this.returnSecureToken,
this.upgradeToFederatedLogin,
this.validSince,
});
IdentitytoolkitRelyingpartySetAccountInfoRequest.fromJson(core.Map json_)
: this(
captchaChallenge: json_.containsKey('captchaChallenge')
? json_['captchaChallenge'] as core.String
: null,
captchaResponse: json_.containsKey('captchaResponse')
? json_['captchaResponse'] as core.String
: null,
createdAt: json_.containsKey('createdAt')
? json_['createdAt'] as core.String
: null,
customAttributes: json_.containsKey('customAttributes')
? json_['customAttributes'] as core.String
: null,
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
deleteAttribute: json_.containsKey('deleteAttribute')
? (json_['deleteAttribute'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
deleteProvider: json_.containsKey('deleteProvider')
? (json_['deleteProvider'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
disableUser: json_.containsKey('disableUser')
? json_['disableUser'] as core.bool
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
emailVerified: json_.containsKey('emailVerified')
? json_['emailVerified'] as core.bool
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
lastLoginAt: json_.containsKey('lastLoginAt')
? json_['lastLoginAt'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
oobCode: json_.containsKey('oobCode')
? json_['oobCode'] as core.String
: null,
password: json_.containsKey('password')
? json_['password'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
provider: json_.containsKey('provider')
? (json_['provider'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
returnSecureToken: json_.containsKey('returnSecureToken')
? json_['returnSecureToken'] as core.bool
: null,
upgradeToFederatedLogin: json_.containsKey('upgradeToFederatedLogin')
? json_['upgradeToFederatedLogin'] as core.bool
: null,
validSince: json_.containsKey('validSince')
? json_['validSince'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (captchaChallenge != null) 'captchaChallenge': captchaChallenge!,
if (captchaResponse != null) 'captchaResponse': captchaResponse!,
if (createdAt != null) 'createdAt': createdAt!,
if (customAttributes != null) 'customAttributes': customAttributes!,
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (deleteAttribute != null) 'deleteAttribute': deleteAttribute!,
if (deleteProvider != null) 'deleteProvider': deleteProvider!,
if (disableUser != null) 'disableUser': disableUser!,
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (emailVerified != null) 'emailVerified': emailVerified!,
if (idToken != null) 'idToken': idToken!,
if (instanceId != null) 'instanceId': instanceId!,
if (lastLoginAt != null) 'lastLoginAt': lastLoginAt!,
if (localId != null) 'localId': localId!,
if (oobCode != null) 'oobCode': oobCode!,
if (password != null) 'password': password!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (provider != null) 'provider': provider!,
if (returnSecureToken != null) 'returnSecureToken': returnSecureToken!,
if (upgradeToFederatedLogin != null)
'upgradeToFederatedLogin': upgradeToFederatedLogin!,
if (validSince != null) 'validSince': validSince!,
};
}
/// Request to set the project configuration.
class IdentitytoolkitRelyingpartySetProjectConfigRequest {
/// Whether to allow password user sign in or sign up.
core.bool? allowPasswordUser;
/// Browser API key, needed when making http request to Apiary.
core.String? apiKey;
/// Authorized domains for widget redirect.
core.List<core.String>? authorizedDomains;
/// Change email template.
EmailTemplate? changeEmailTemplate;
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// Whether to enable anonymous user.
core.bool? enableAnonymousUser;
/// Oauth2 provider configuration.
core.List<IdpConfig>? idpConfig;
/// Legacy reset password email template.
EmailTemplate? legacyResetPasswordTemplate;
/// Reset password email template.
EmailTemplate? resetPasswordTemplate;
/// Whether to use email sending provided by Firebear.
core.bool? useEmailSending;
/// Verify email template.
EmailTemplate? verifyEmailTemplate;
IdentitytoolkitRelyingpartySetProjectConfigRequest({
this.allowPasswordUser,
this.apiKey,
this.authorizedDomains,
this.changeEmailTemplate,
this.delegatedProjectNumber,
this.enableAnonymousUser,
this.idpConfig,
this.legacyResetPasswordTemplate,
this.resetPasswordTemplate,
this.useEmailSending,
this.verifyEmailTemplate,
});
IdentitytoolkitRelyingpartySetProjectConfigRequest.fromJson(core.Map json_)
: this(
allowPasswordUser: json_.containsKey('allowPasswordUser')
? json_['allowPasswordUser'] as core.bool
: null,
apiKey: json_.containsKey('apiKey')
? json_['apiKey'] as core.String
: null,
authorizedDomains: json_.containsKey('authorizedDomains')
? (json_['authorizedDomains'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
changeEmailTemplate: json_.containsKey('changeEmailTemplate')
? EmailTemplate.fromJson(json_['changeEmailTemplate']
as core.Map<core.String, core.dynamic>)
: null,
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
enableAnonymousUser: json_.containsKey('enableAnonymousUser')
? json_['enableAnonymousUser'] as core.bool
: null,
idpConfig: json_.containsKey('idpConfig')
? (json_['idpConfig'] as core.List)
.map((value) => IdpConfig.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
legacyResetPasswordTemplate:
json_.containsKey('legacyResetPasswordTemplate')
? EmailTemplate.fromJson(json_['legacyResetPasswordTemplate']
as core.Map<core.String, core.dynamic>)
: null,
resetPasswordTemplate: json_.containsKey('resetPasswordTemplate')
? EmailTemplate.fromJson(json_['resetPasswordTemplate']
as core.Map<core.String, core.dynamic>)
: null,
useEmailSending: json_.containsKey('useEmailSending')
? json_['useEmailSending'] as core.bool
: null,
verifyEmailTemplate: json_.containsKey('verifyEmailTemplate')
? EmailTemplate.fromJson(json_['verifyEmailTemplate']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (allowPasswordUser != null) 'allowPasswordUser': allowPasswordUser!,
if (apiKey != null) 'apiKey': apiKey!,
if (authorizedDomains != null) 'authorizedDomains': authorizedDomains!,
if (changeEmailTemplate != null)
'changeEmailTemplate': changeEmailTemplate!,
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (enableAnonymousUser != null)
'enableAnonymousUser': enableAnonymousUser!,
if (idpConfig != null) 'idpConfig': idpConfig!,
if (legacyResetPasswordTemplate != null)
'legacyResetPasswordTemplate': legacyResetPasswordTemplate!,
if (resetPasswordTemplate != null)
'resetPasswordTemplate': resetPasswordTemplate!,
if (useEmailSending != null) 'useEmailSending': useEmailSending!,
if (verifyEmailTemplate != null)
'verifyEmailTemplate': verifyEmailTemplate!,
};
}
/// Response of setting the project configuration.
class IdentitytoolkitRelyingpartySetProjectConfigResponse {
/// Project ID of the relying party.
core.String? projectId;
IdentitytoolkitRelyingpartySetProjectConfigResponse({
this.projectId,
});
IdentitytoolkitRelyingpartySetProjectConfigResponse.fromJson(core.Map json_)
: this(
projectId: json_.containsKey('projectId')
? json_['projectId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (projectId != null) 'projectId': projectId!,
};
}
/// Request to sign out user.
class IdentitytoolkitRelyingpartySignOutUserRequest {
/// Instance id token of the app.
core.String? instanceId;
/// The local ID of the user.
core.String? localId;
IdentitytoolkitRelyingpartySignOutUserRequest({
this.instanceId,
this.localId,
});
IdentitytoolkitRelyingpartySignOutUserRequest.fromJson(core.Map json_)
: this(
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (instanceId != null) 'instanceId': instanceId!,
if (localId != null) 'localId': localId!,
};
}
/// Response of signing out user.
class IdentitytoolkitRelyingpartySignOutUserResponse {
/// The local ID of the user.
core.String? localId;
IdentitytoolkitRelyingpartySignOutUserResponse({
this.localId,
});
IdentitytoolkitRelyingpartySignOutUserResponse.fromJson(core.Map json_)
: this(
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (localId != null) 'localId': localId!,
};
}
/// Request to signup new user, create anonymous user or anonymous user reauth.
class IdentitytoolkitRelyingpartySignupNewUserRequest {
/// The captcha challenge.
core.String? captchaChallenge;
/// Response to the captcha.
core.String? captchaResponse;
/// Whether to disable the user.
///
/// Only can be used by service account.
core.bool? disabled;
/// The name of the user.
core.String? displayName;
/// The email of the user.
core.String? email;
/// Mark the email as verified or not.
///
/// Only can be used by service account.
core.bool? emailVerified;
/// The GITKit token of the authenticated user.
core.String? idToken;
/// Instance id token of the app.
core.String? instanceId;
/// Privileged caller can create user with specified user id.
core.String? localId;
/// The new password of the user.
core.String? password;
/// Privileged caller can create user with specified phone number.
core.String? phoneNumber;
/// The photo url of the user.
core.String? photoUrl;
/// For multi-tenant use cases, in order to construct sign-in URL with the
/// correct IDP parameters, Firebear needs to know which Tenant to retrieve
/// IDP configs from.
core.String? tenantId;
/// Tenant project number to be used for idp discovery.
core.String? tenantProjectNumber;
IdentitytoolkitRelyingpartySignupNewUserRequest({
this.captchaChallenge,
this.captchaResponse,
this.disabled,
this.displayName,
this.email,
this.emailVerified,
this.idToken,
this.instanceId,
this.localId,
this.password,
this.phoneNumber,
this.photoUrl,
this.tenantId,
this.tenantProjectNumber,
});
IdentitytoolkitRelyingpartySignupNewUserRequest.fromJson(core.Map json_)
: this(
captchaChallenge: json_.containsKey('captchaChallenge')
? json_['captchaChallenge'] as core.String
: null,
captchaResponse: json_.containsKey('captchaResponse')
? json_['captchaResponse'] as core.String
: null,
disabled: json_.containsKey('disabled')
? json_['disabled'] as core.bool
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
emailVerified: json_.containsKey('emailVerified')
? json_['emailVerified'] as core.bool
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
password: json_.containsKey('password')
? json_['password'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
tenantId: json_.containsKey('tenantId')
? json_['tenantId'] as core.String
: null,
tenantProjectNumber: json_.containsKey('tenantProjectNumber')
? json_['tenantProjectNumber'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (captchaChallenge != null) 'captchaChallenge': captchaChallenge!,
if (captchaResponse != null) 'captchaResponse': captchaResponse!,
if (disabled != null) 'disabled': disabled!,
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (emailVerified != null) 'emailVerified': emailVerified!,
if (idToken != null) 'idToken': idToken!,
if (instanceId != null) 'instanceId': instanceId!,
if (localId != null) 'localId': localId!,
if (password != null) 'password': password!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (tenantId != null) 'tenantId': tenantId!,
if (tenantProjectNumber != null)
'tenantProjectNumber': tenantProjectNumber!,
};
}
/// Request to upload user account in batch.
class IdentitytoolkitRelyingpartyUploadAccountRequest {
/// Whether allow overwrite existing account when user local_id exists.
core.bool? allowOverwrite;
core.int? blockSize;
/// The following 4 fields are for standard scrypt algorithm.
core.int? cpuMemCost;
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
core.int? dkLen;
/// The password hash algorithm.
core.String? hashAlgorithm;
/// Memory cost for hash calculation.
///
/// Used by scrypt similar algorithms.
core.int? memoryCost;
core.int? parallelization;
/// Rounds for hash calculation.
///
/// Used by scrypt and similar algorithms.
core.int? rounds;
/// The salt separator.
core.String? saltSeparator;
core.List<core.int> get saltSeparatorAsBytes =>
convert.base64.decode(saltSeparator!);
set saltSeparatorAsBytes(core.List<core.int> bytes_) {
saltSeparator =
convert.base64.encode(bytes_).replaceAll('/', '_').replaceAll('+', '-');
}
/// If true, backend will do sanity check(including duplicate email and
/// federated id) when uploading account.
core.bool? sanityCheck;
/// The key for to hash the password.
core.String? signerKey;
core.List<core.int> get signerKeyAsBytes => convert.base64.decode(signerKey!);
set signerKeyAsBytes(core.List<core.int> bytes_) {
signerKey =
convert.base64.encode(bytes_).replaceAll('/', '_').replaceAll('+', '-');
}
/// Specify which project (field value is actually project id) to operate.
///
/// Only used when provided credential.
core.String? targetProjectId;
/// The account info to be stored.
core.List<UserInfo>? users;
IdentitytoolkitRelyingpartyUploadAccountRequest({
this.allowOverwrite,
this.blockSize,
this.cpuMemCost,
this.delegatedProjectNumber,
this.dkLen,
this.hashAlgorithm,
this.memoryCost,
this.parallelization,
this.rounds,
this.saltSeparator,
this.sanityCheck,
this.signerKey,
this.targetProjectId,
this.users,
});
IdentitytoolkitRelyingpartyUploadAccountRequest.fromJson(core.Map json_)
: this(
allowOverwrite: json_.containsKey('allowOverwrite')
? json_['allowOverwrite'] as core.bool
: null,
blockSize: json_.containsKey('blockSize')
? json_['blockSize'] as core.int
: null,
cpuMemCost: json_.containsKey('cpuMemCost')
? json_['cpuMemCost'] as core.int
: null,
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
dkLen: json_.containsKey('dkLen') ? json_['dkLen'] as core.int : null,
hashAlgorithm: json_.containsKey('hashAlgorithm')
? json_['hashAlgorithm'] as core.String
: null,
memoryCost: json_.containsKey('memoryCost')
? json_['memoryCost'] as core.int
: null,
parallelization: json_.containsKey('parallelization')
? json_['parallelization'] as core.int
: null,
rounds:
json_.containsKey('rounds') ? json_['rounds'] as core.int : null,
saltSeparator: json_.containsKey('saltSeparator')
? json_['saltSeparator'] as core.String
: null,
sanityCheck: json_.containsKey('sanityCheck')
? json_['sanityCheck'] as core.bool
: null,
signerKey: json_.containsKey('signerKey')
? json_['signerKey'] as core.String
: null,
targetProjectId: json_.containsKey('targetProjectId')
? json_['targetProjectId'] as core.String
: null,
users: json_.containsKey('users')
? (json_['users'] as core.List)
.map((value) => UserInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (allowOverwrite != null) 'allowOverwrite': allowOverwrite!,
if (blockSize != null) 'blockSize': blockSize!,
if (cpuMemCost != null) 'cpuMemCost': cpuMemCost!,
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (dkLen != null) 'dkLen': dkLen!,
if (hashAlgorithm != null) 'hashAlgorithm': hashAlgorithm!,
if (memoryCost != null) 'memoryCost': memoryCost!,
if (parallelization != null) 'parallelization': parallelization!,
if (rounds != null) 'rounds': rounds!,
if (saltSeparator != null) 'saltSeparator': saltSeparator!,
if (sanityCheck != null) 'sanityCheck': sanityCheck!,
if (signerKey != null) 'signerKey': signerKey!,
if (targetProjectId != null) 'targetProjectId': targetProjectId!,
if (users != null) 'users': users!,
};
}
/// Request to verify the IDP assertion.
class IdentitytoolkitRelyingpartyVerifyAssertionRequest {
/// When it's true, automatically creates a new account if the user doesn't
/// exist.
///
/// When it's false, allows existing user to sign in normally and throws
/// exception if the user doesn't exist.
core.bool? autoCreate;
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The GITKit token of the authenticated user.
core.String? idToken;
/// Instance id token of the app.
core.String? instanceId;
/// The GITKit token for the non-trusted IDP pending to be confirmed by the
/// user.
core.String? pendingIdToken;
/// The post body if the request is a HTTP POST.
core.String? postBody;
/// The URI to which the IDP redirects the user back.
///
/// It may contain federated login result params added by the IDP.
core.String? requestUri;
/// Whether return 200 and IDP credential rather than throw exception when
/// federated id is already linked.
core.bool? returnIdpCredential;
/// Whether to return refresh tokens.
core.bool? returnRefreshToken;
/// Whether return sts id token and refresh token instead of gitkit token.
core.bool? returnSecureToken;
/// Session ID, which should match the one in previous createAuthUri request.
core.String? sessionId;
/// For multi-tenant use cases, in order to construct sign-in URL with the
/// correct IDP parameters, Firebear needs to know which Tenant to retrieve
/// IDP configs from.
core.String? tenantId;
/// Tenant project number to be used for idp discovery.
core.String? tenantProjectNumber;
IdentitytoolkitRelyingpartyVerifyAssertionRequest({
this.autoCreate,
this.delegatedProjectNumber,
this.idToken,
this.instanceId,
this.pendingIdToken,
this.postBody,
this.requestUri,
this.returnIdpCredential,
this.returnRefreshToken,
this.returnSecureToken,
this.sessionId,
this.tenantId,
this.tenantProjectNumber,
});
IdentitytoolkitRelyingpartyVerifyAssertionRequest.fromJson(core.Map json_)
: this(
autoCreate: json_.containsKey('autoCreate')
? json_['autoCreate'] as core.bool
: null,
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
pendingIdToken: json_.containsKey('pendingIdToken')
? json_['pendingIdToken'] as core.String
: null,
postBody: json_.containsKey('postBody')
? json_['postBody'] as core.String
: null,
requestUri: json_.containsKey('requestUri')
? json_['requestUri'] as core.String
: null,
returnIdpCredential: json_.containsKey('returnIdpCredential')
? json_['returnIdpCredential'] as core.bool
: null,
returnRefreshToken: json_.containsKey('returnRefreshToken')
? json_['returnRefreshToken'] as core.bool
: null,
returnSecureToken: json_.containsKey('returnSecureToken')
? json_['returnSecureToken'] as core.bool
: null,
sessionId: json_.containsKey('sessionId')
? json_['sessionId'] as core.String
: null,
tenantId: json_.containsKey('tenantId')
? json_['tenantId'] as core.String
: null,
tenantProjectNumber: json_.containsKey('tenantProjectNumber')
? json_['tenantProjectNumber'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (autoCreate != null) 'autoCreate': autoCreate!,
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (idToken != null) 'idToken': idToken!,
if (instanceId != null) 'instanceId': instanceId!,
if (pendingIdToken != null) 'pendingIdToken': pendingIdToken!,
if (postBody != null) 'postBody': postBody!,
if (requestUri != null) 'requestUri': requestUri!,
if (returnIdpCredential != null)
'returnIdpCredential': returnIdpCredential!,
if (returnRefreshToken != null)
'returnRefreshToken': returnRefreshToken!,
if (returnSecureToken != null) 'returnSecureToken': returnSecureToken!,
if (sessionId != null) 'sessionId': sessionId!,
if (tenantId != null) 'tenantId': tenantId!,
if (tenantProjectNumber != null)
'tenantProjectNumber': tenantProjectNumber!,
};
}
/// Request to verify a custom token
class IdentitytoolkitRelyingpartyVerifyCustomTokenRequest {
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// Instance id token of the app.
core.String? instanceId;
/// Whether return sts id token and refresh token instead of gitkit token.
core.bool? returnSecureToken;
/// The custom token to verify
core.String? token;
IdentitytoolkitRelyingpartyVerifyCustomTokenRequest({
this.delegatedProjectNumber,
this.instanceId,
this.returnSecureToken,
this.token,
});
IdentitytoolkitRelyingpartyVerifyCustomTokenRequest.fromJson(core.Map json_)
: this(
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
returnSecureToken: json_.containsKey('returnSecureToken')
? json_['returnSecureToken'] as core.bool
: null,
token:
json_.containsKey('token') ? json_['token'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (instanceId != null) 'instanceId': instanceId!,
if (returnSecureToken != null) 'returnSecureToken': returnSecureToken!,
if (token != null) 'token': token!,
};
}
/// Request to verify the password.
class IdentitytoolkitRelyingpartyVerifyPasswordRequest {
/// The captcha challenge.
core.String? captchaChallenge;
/// Response to the captcha.
core.String? captchaResponse;
/// GCP project number of the requesting delegated app.
///
/// Currently only intended for Firebase V1 migration.
core.String? delegatedProjectNumber;
/// The email of the user.
core.String? email;
/// The GITKit token of the authenticated user.
core.String? idToken;
/// Instance id token of the app.
core.String? instanceId;
/// The password inputed by the user.
core.String? password;
/// The GITKit token for the non-trusted IDP, which is to be confirmed by the
/// user.
core.String? pendingIdToken;
/// Whether return sts id token and refresh token instead of gitkit token.
core.bool? returnSecureToken;
/// For multi-tenant use cases, in order to construct sign-in URL with the
/// correct IDP parameters, Firebear needs to know which Tenant to retrieve
/// IDP configs from.
core.String? tenantId;
/// Tenant project number to be used for idp discovery.
core.String? tenantProjectNumber;
IdentitytoolkitRelyingpartyVerifyPasswordRequest({
this.captchaChallenge,
this.captchaResponse,
this.delegatedProjectNumber,
this.email,
this.idToken,
this.instanceId,
this.password,
this.pendingIdToken,
this.returnSecureToken,
this.tenantId,
this.tenantProjectNumber,
});
IdentitytoolkitRelyingpartyVerifyPasswordRequest.fromJson(core.Map json_)
: this(
captchaChallenge: json_.containsKey('captchaChallenge')
? json_['captchaChallenge'] as core.String
: null,
captchaResponse: json_.containsKey('captchaResponse')
? json_['captchaResponse'] as core.String
: null,
delegatedProjectNumber: json_.containsKey('delegatedProjectNumber')
? json_['delegatedProjectNumber'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
password: json_.containsKey('password')
? json_['password'] as core.String
: null,
pendingIdToken: json_.containsKey('pendingIdToken')
? json_['pendingIdToken'] as core.String
: null,
returnSecureToken: json_.containsKey('returnSecureToken')
? json_['returnSecureToken'] as core.bool
: null,
tenantId: json_.containsKey('tenantId')
? json_['tenantId'] as core.String
: null,
tenantProjectNumber: json_.containsKey('tenantProjectNumber')
? json_['tenantProjectNumber'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (captchaChallenge != null) 'captchaChallenge': captchaChallenge!,
if (captchaResponse != null) 'captchaResponse': captchaResponse!,
if (delegatedProjectNumber != null)
'delegatedProjectNumber': delegatedProjectNumber!,
if (email != null) 'email': email!,
if (idToken != null) 'idToken': idToken!,
if (instanceId != null) 'instanceId': instanceId!,
if (password != null) 'password': password!,
if (pendingIdToken != null) 'pendingIdToken': pendingIdToken!,
if (returnSecureToken != null) 'returnSecureToken': returnSecureToken!,
if (tenantId != null) 'tenantId': tenantId!,
if (tenantProjectNumber != null)
'tenantProjectNumber': tenantProjectNumber!,
};
}
/// Request for Identitytoolkit-VerifyPhoneNumber
class IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest {
core.String? code;
core.String? idToken;
core.String? operation;
core.String? phoneNumber;
/// The session info previously returned by
/// IdentityToolkit-SendVerificationCode.
core.String? sessionInfo;
core.String? temporaryProof;
core.String? verificationProof;
IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest({
this.code,
this.idToken,
this.operation,
this.phoneNumber,
this.sessionInfo,
this.temporaryProof,
this.verificationProof,
});
IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest.fromJson(core.Map json_)
: this(
code: json_.containsKey('code') ? json_['code'] as core.String : null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
operation: json_.containsKey('operation')
? json_['operation'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
sessionInfo: json_.containsKey('sessionInfo')
? json_['sessionInfo'] as core.String
: null,
temporaryProof: json_.containsKey('temporaryProof')
? json_['temporaryProof'] as core.String
: null,
verificationProof: json_.containsKey('verificationProof')
? json_['verificationProof'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (code != null) 'code': code!,
if (idToken != null) 'idToken': idToken!,
if (operation != null) 'operation': operation!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (sessionInfo != null) 'sessionInfo': sessionInfo!,
if (temporaryProof != null) 'temporaryProof': temporaryProof!,
if (verificationProof != null) 'verificationProof': verificationProof!,
};
}
/// Response for Identitytoolkit-VerifyPhoneNumber
class IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse {
core.String? expiresIn;
core.String? idToken;
core.bool? isNewUser;
core.String? localId;
core.String? phoneNumber;
core.String? refreshToken;
core.String? temporaryProof;
core.String? temporaryProofExpiresIn;
core.String? verificationProof;
core.String? verificationProofExpiresIn;
IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse({
this.expiresIn,
this.idToken,
this.isNewUser,
this.localId,
this.phoneNumber,
this.refreshToken,
this.temporaryProof,
this.temporaryProofExpiresIn,
this.verificationProof,
this.verificationProofExpiresIn,
});
IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse.fromJson(core.Map json_)
: this(
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
isNewUser: json_.containsKey('isNewUser')
? json_['isNewUser'] as core.bool
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
temporaryProof: json_.containsKey('temporaryProof')
? json_['temporaryProof'] as core.String
: null,
temporaryProofExpiresIn: json_.containsKey('temporaryProofExpiresIn')
? json_['temporaryProofExpiresIn'] as core.String
: null,
verificationProof: json_.containsKey('verificationProof')
? json_['verificationProof'] as core.String
: null,
verificationProofExpiresIn:
json_.containsKey('verificationProofExpiresIn')
? json_['verificationProofExpiresIn'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (isNewUser != null) 'isNewUser': isNewUser!,
if (localId != null) 'localId': localId!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (refreshToken != null) 'refreshToken': refreshToken!,
if (temporaryProof != null) 'temporaryProof': temporaryProof!,
if (temporaryProofExpiresIn != null)
'temporaryProofExpiresIn': temporaryProofExpiresIn!,
if (verificationProof != null) 'verificationProof': verificationProof!,
if (verificationProofExpiresIn != null)
'verificationProofExpiresIn': verificationProofExpiresIn!,
};
}
/// Template for a single idp configuration.
class IdpConfig {
/// OAuth2 client ID.
core.String? clientId;
/// Whether this IDP is enabled.
core.bool? enabled;
/// Percent of users who will be prompted/redirected federated login for this
/// IDP.
core.int? experimentPercent;
/// OAuth2 provider.
core.String? provider;
/// OAuth2 client secret.
core.String? secret;
/// Whitelisted client IDs for audience check.
core.List<core.String>? whitelistedAudiences;
IdpConfig({
this.clientId,
this.enabled,
this.experimentPercent,
this.provider,
this.secret,
this.whitelistedAudiences,
});
IdpConfig.fromJson(core.Map json_)
: this(
clientId: json_.containsKey('clientId')
? json_['clientId'] as core.String
: null,
enabled: json_.containsKey('enabled')
? json_['enabled'] as core.bool
: null,
experimentPercent: json_.containsKey('experimentPercent')
? json_['experimentPercent'] as core.int
: null,
provider: json_.containsKey('provider')
? json_['provider'] as core.String
: null,
secret: json_.containsKey('secret')
? json_['secret'] as core.String
: null,
whitelistedAudiences: json_.containsKey('whitelistedAudiences')
? (json_['whitelistedAudiences'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (clientId != null) 'clientId': clientId!,
if (enabled != null) 'enabled': enabled!,
if (experimentPercent != null) 'experimentPercent': experimentPercent!,
if (provider != null) 'provider': provider!,
if (secret != null) 'secret': secret!,
if (whitelistedAudiences != null)
'whitelistedAudiences': whitelistedAudiences!,
};
}
/// Request of getting a code for user confirmation (reset password, change
/// email etc.)
class Relyingparty {
/// whether or not to install the android app on the device where the link is
/// opened
core.bool? androidInstallApp;
/// minimum version of the app.
///
/// if the version on the device is lower than this version then the user is
/// taken to the play store to upgrade the app
core.String? androidMinimumVersion;
/// android package name of the android app to handle the action code
core.String? androidPackageName;
/// whether or not the app can handle the oob code without first going to web
core.bool? canHandleCodeInApp;
/// The recaptcha response from the user.
core.String? captchaResp;
/// The recaptcha challenge presented to the user.
core.String? challenge;
/// The url to continue to the Gitkit app
core.String? continueUrl;
/// The email of the user.
core.String? email;
/// iOS app store id to download the app if it's not already installed
core.String? iOSAppStoreId;
/// the iOS bundle id of iOS app to handle the action code
core.String? iOSBundleId;
/// The user's Gitkit login token for email change.
core.String? idToken;
/// The fixed string "identitytoolkit#relyingparty".
core.String? kind;
/// The new email if the code is for email change.
core.String? newEmail;
/// The request type.
core.String? requestType;
/// The IP address of the user.
core.String? userIp;
Relyingparty({
this.androidInstallApp,
this.androidMinimumVersion,
this.androidPackageName,
this.canHandleCodeInApp,
this.captchaResp,
this.challenge,
this.continueUrl,
this.email,
this.iOSAppStoreId,
this.iOSBundleId,
this.idToken,
this.kind,
this.newEmail,
this.requestType,
this.userIp,
});
Relyingparty.fromJson(core.Map json_)
: this(
androidInstallApp: json_.containsKey('androidInstallApp')
? json_['androidInstallApp'] as core.bool
: null,
androidMinimumVersion: json_.containsKey('androidMinimumVersion')
? json_['androidMinimumVersion'] as core.String
: null,
androidPackageName: json_.containsKey('androidPackageName')
? json_['androidPackageName'] as core.String
: null,
canHandleCodeInApp: json_.containsKey('canHandleCodeInApp')
? json_['canHandleCodeInApp'] as core.bool
: null,
captchaResp: json_.containsKey('captchaResp')
? json_['captchaResp'] as core.String
: null,
challenge: json_.containsKey('challenge')
? json_['challenge'] as core.String
: null,
continueUrl: json_.containsKey('continueUrl')
? json_['continueUrl'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
iOSAppStoreId: json_.containsKey('iOSAppStoreId')
? json_['iOSAppStoreId'] as core.String
: null,
iOSBundleId: json_.containsKey('iOSBundleId')
? json_['iOSBundleId'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
newEmail: json_.containsKey('newEmail')
? json_['newEmail'] as core.String
: null,
requestType: json_.containsKey('requestType')
? json_['requestType'] as core.String
: null,
userIp: json_.containsKey('userIp')
? json_['userIp'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (androidInstallApp != null) 'androidInstallApp': androidInstallApp!,
if (androidMinimumVersion != null)
'androidMinimumVersion': androidMinimumVersion!,
if (androidPackageName != null)
'androidPackageName': androidPackageName!,
if (canHandleCodeInApp != null)
'canHandleCodeInApp': canHandleCodeInApp!,
if (captchaResp != null) 'captchaResp': captchaResp!,
if (challenge != null) 'challenge': challenge!,
if (continueUrl != null) 'continueUrl': continueUrl!,
if (email != null) 'email': email!,
if (iOSAppStoreId != null) 'iOSAppStoreId': iOSAppStoreId!,
if (iOSBundleId != null) 'iOSBundleId': iOSBundleId!,
if (idToken != null) 'idToken': idToken!,
if (kind != null) 'kind': kind!,
if (newEmail != null) 'newEmail': newEmail!,
if (requestType != null) 'requestType': requestType!,
if (userIp != null) 'userIp': userIp!,
};
}
/// Response of resetting the password.
class ResetPasswordResponse {
/// The user's email.
///
/// If the out-of-band code is for email recovery, the user's original email.
core.String? email;
/// The fixed string "identitytoolkit#ResetPasswordResponse".
core.String? kind;
/// If the out-of-band code is for email recovery, the user's new email.
core.String? newEmail;
/// The request type.
core.String? requestType;
ResetPasswordResponse({
this.email,
this.kind,
this.newEmail,
this.requestType,
});
ResetPasswordResponse.fromJson(core.Map json_)
: this(
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
newEmail: json_.containsKey('newEmail')
? json_['newEmail'] as core.String
: null,
requestType: json_.containsKey('requestType')
? json_['requestType'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (email != null) 'email': email!,
if (kind != null) 'kind': kind!,
if (newEmail != null) 'newEmail': newEmail!,
if (requestType != null) 'requestType': requestType!,
};
}
class SetAccountInfoResponseProviderUserInfo {
/// The user's display name at the IDP.
core.String? displayName;
/// User's identifier at IDP.
core.String? federatedId;
/// The user's photo url at the IDP.
core.String? photoUrl;
/// The IdP ID.
///
/// For whitelisted IdPs it's a short domain name, e.g., google.com, aol.com,
/// live.net and yahoo.com. For other OpenID IdPs it's the OP identifier.
core.String? providerId;
SetAccountInfoResponseProviderUserInfo({
this.displayName,
this.federatedId,
this.photoUrl,
this.providerId,
});
SetAccountInfoResponseProviderUserInfo.fromJson(core.Map json_)
: this(
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
federatedId: json_.containsKey('federatedId')
? json_['federatedId'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
providerId: json_.containsKey('providerId')
? json_['providerId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (federatedId != null) 'federatedId': federatedId!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (providerId != null) 'providerId': providerId!,
};
}
/// Respone of setting the account information.
class SetAccountInfoResponse {
/// The name of the user.
core.String? displayName;
/// The email of the user.
core.String? email;
/// If email has been verified.
core.bool? emailVerified;
/// If idToken is STS id token, then this field will be expiration time of STS
/// id token in seconds.
core.String? expiresIn;
/// The Gitkit id token to login the newly sign up user.
core.String? idToken;
/// The fixed string "identitytoolkit#SetAccountInfoResponse".
core.String? kind;
/// The local ID of the user.
core.String? localId;
/// The new email the user attempts to change to.
core.String? newEmail;
/// The user's hashed password.
core.String? passwordHash;
core.List<core.int> get passwordHashAsBytes =>
convert.base64.decode(passwordHash!);
set passwordHashAsBytes(core.List<core.int> bytes_) {
passwordHash =
convert.base64.encode(bytes_).replaceAll('/', '_').replaceAll('+', '-');
}
/// The photo url of the user.
core.String? photoUrl;
/// The user's profiles at the associated IdPs.
core.List<SetAccountInfoResponseProviderUserInfo>? providerUserInfo;
/// If idToken is STS id token, then this field will be refresh token.
core.String? refreshToken;
SetAccountInfoResponse({
this.displayName,
this.email,
this.emailVerified,
this.expiresIn,
this.idToken,
this.kind,
this.localId,
this.newEmail,
this.passwordHash,
this.photoUrl,
this.providerUserInfo,
this.refreshToken,
});
SetAccountInfoResponse.fromJson(core.Map json_)
: this(
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
emailVerified: json_.containsKey('emailVerified')
? json_['emailVerified'] as core.bool
: null,
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
newEmail: json_.containsKey('newEmail')
? json_['newEmail'] as core.String
: null,
passwordHash: json_.containsKey('passwordHash')
? json_['passwordHash'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
providerUserInfo: json_.containsKey('providerUserInfo')
? (json_['providerUserInfo'] as core.List)
.map((value) =>
SetAccountInfoResponseProviderUserInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (emailVerified != null) 'emailVerified': emailVerified!,
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (kind != null) 'kind': kind!,
if (localId != null) 'localId': localId!,
if (newEmail != null) 'newEmail': newEmail!,
if (passwordHash != null) 'passwordHash': passwordHash!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (providerUserInfo != null) 'providerUserInfo': providerUserInfo!,
if (refreshToken != null) 'refreshToken': refreshToken!,
};
}
/// Response of signing up new user, creating anonymous user or anonymous user
/// reauth.
class SignupNewUserResponse {
/// The name of the user.
core.String? displayName;
/// The email of the user.
core.String? email;
/// If idToken is STS id token, then this field will be expiration time of STS
/// id token in seconds.
core.String? expiresIn;
/// The Gitkit id token to login the newly sign up user.
core.String? idToken;
/// The fixed string "identitytoolkit#SignupNewUserResponse".
core.String? kind;
/// The RP local ID of the user.
core.String? localId;
/// If idToken is STS id token, then this field will be refresh token.
core.String? refreshToken;
SignupNewUserResponse({
this.displayName,
this.email,
this.expiresIn,
this.idToken,
this.kind,
this.localId,
this.refreshToken,
});
SignupNewUserResponse.fromJson(core.Map json_)
: this(
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (kind != null) 'kind': kind!,
if (localId != null) 'localId': localId!,
if (refreshToken != null) 'refreshToken': refreshToken!,
};
}
class UploadAccountResponseError {
/// The index of the malformed account, starting from 0.
core.int? index;
/// Detailed error message for the account info.
core.String? message;
UploadAccountResponseError({
this.index,
this.message,
});
UploadAccountResponseError.fromJson(core.Map json_)
: this(
index: json_.containsKey('index') ? json_['index'] as core.int : null,
message: json_.containsKey('message')
? json_['message'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (index != null) 'index': index!,
if (message != null) 'message': message!,
};
}
/// Respone of uploading accounts in batch.
class UploadAccountResponse {
/// The error encountered while processing the account info.
core.List<UploadAccountResponseError>? error;
/// The fixed string "identitytoolkit#UploadAccountResponse".
core.String? kind;
UploadAccountResponse({
this.error,
this.kind,
});
UploadAccountResponse.fromJson(core.Map json_)
: this(
error: json_.containsKey('error')
? (json_['error'] as core.List)
.map((value) => UploadAccountResponseError.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (error != null) 'error': error!,
if (kind != null) 'kind': kind!,
};
}
class UserInfoProviderUserInfo {
/// The user's display name at the IDP.
core.String? displayName;
/// User's email at IDP.
core.String? email;
/// User's identifier at IDP.
core.String? federatedId;
/// User's phone number.
core.String? phoneNumber;
/// The user's photo url at the IDP.
core.String? photoUrl;
/// The IdP ID.
///
/// For white listed IdPs it's a short domain name, e.g., google.com, aol.com,
/// live.net and yahoo.com. For other OpenID IdPs it's the OP identifier.
core.String? providerId;
/// User's raw identifier directly returned from IDP.
core.String? rawId;
/// User's screen name at Twitter or login name at Github.
core.String? screenName;
UserInfoProviderUserInfo({
this.displayName,
this.email,
this.federatedId,
this.phoneNumber,
this.photoUrl,
this.providerId,
this.rawId,
this.screenName,
});
UserInfoProviderUserInfo.fromJson(core.Map json_)
: this(
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
federatedId: json_.containsKey('federatedId')
? json_['federatedId'] as core.String
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
providerId: json_.containsKey('providerId')
? json_['providerId'] as core.String
: null,
rawId:
json_.containsKey('rawId') ? json_['rawId'] as core.String : null,
screenName: json_.containsKey('screenName')
? json_['screenName'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (federatedId != null) 'federatedId': federatedId!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (providerId != null) 'providerId': providerId!,
if (rawId != null) 'rawId': rawId!,
if (screenName != null) 'screenName': screenName!,
};
}
/// Template for an individual account info.
class UserInfo {
/// User creation timestamp.
core.String? createdAt;
/// The custom attributes to be set in the user's id token.
core.String? customAttributes;
/// Whether the user is authenticated by the developer.
core.bool? customAuth;
/// Whether the user is disabled.
core.bool? disabled;
/// The name of the user.
core.String? displayName;
/// The email of the user.
core.String? email;
/// Whether the email has been verified.
core.bool? emailVerified;
/// last login timestamp.
core.String? lastLoginAt;
/// The local ID of the user.
core.String? localId;
/// The user's hashed password.
core.String? passwordHash;
core.List<core.int> get passwordHashAsBytes =>
convert.base64.decode(passwordHash!);
set passwordHashAsBytes(core.List<core.int> bytes_) {
passwordHash =
convert.base64.encode(bytes_).replaceAll('/', '_').replaceAll('+', '-');
}
/// The timestamp when the password was last updated.
core.double? passwordUpdatedAt;
/// User's phone number.
core.String? phoneNumber;
/// The URL of the user profile photo.
core.String? photoUrl;
/// The IDP of the user.
core.List<UserInfoProviderUserInfo>? providerUserInfo;
/// The user's plain text password.
core.String? rawPassword;
/// The user's password salt.
core.String? salt;
core.List<core.int> get saltAsBytes => convert.base64.decode(salt!);
set saltAsBytes(core.List<core.int> bytes_) {
salt =
convert.base64.encode(bytes_).replaceAll('/', '_').replaceAll('+', '-');
}
/// User's screen name at Twitter or login name at Github.
core.String? screenName;
/// Timestamp in seconds for valid login token.
core.String? validSince;
/// Version of the user's password.
core.int? version;
UserInfo({
this.createdAt,
this.customAttributes,
this.customAuth,
this.disabled,
this.displayName,
this.email,
this.emailVerified,
this.lastLoginAt,
this.localId,
this.passwordHash,
this.passwordUpdatedAt,
this.phoneNumber,
this.photoUrl,
this.providerUserInfo,
this.rawPassword,
this.salt,
this.screenName,
this.validSince,
this.version,
});
UserInfo.fromJson(core.Map json_)
: this(
createdAt: json_.containsKey('createdAt')
? json_['createdAt'] as core.String
: null,
customAttributes: json_.containsKey('customAttributes')
? json_['customAttributes'] as core.String
: null,
customAuth: json_.containsKey('customAuth')
? json_['customAuth'] as core.bool
: null,
disabled: json_.containsKey('disabled')
? json_['disabled'] as core.bool
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
emailVerified: json_.containsKey('emailVerified')
? json_['emailVerified'] as core.bool
: null,
lastLoginAt: json_.containsKey('lastLoginAt')
? json_['lastLoginAt'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
passwordHash: json_.containsKey('passwordHash')
? json_['passwordHash'] as core.String
: null,
passwordUpdatedAt: json_.containsKey('passwordUpdatedAt')
? (json_['passwordUpdatedAt'] as core.num).toDouble()
: null,
phoneNumber: json_.containsKey('phoneNumber')
? json_['phoneNumber'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
providerUserInfo: json_.containsKey('providerUserInfo')
? (json_['providerUserInfo'] as core.List)
.map((value) => UserInfoProviderUserInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
rawPassword: json_.containsKey('rawPassword')
? json_['rawPassword'] as core.String
: null,
salt: json_.containsKey('salt') ? json_['salt'] as core.String : null,
screenName: json_.containsKey('screenName')
? json_['screenName'] as core.String
: null,
validSince: json_.containsKey('validSince')
? json_['validSince'] as core.String
: null,
version: json_.containsKey('version')
? json_['version'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (createdAt != null) 'createdAt': createdAt!,
if (customAttributes != null) 'customAttributes': customAttributes!,
if (customAuth != null) 'customAuth': customAuth!,
if (disabled != null) 'disabled': disabled!,
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (emailVerified != null) 'emailVerified': emailVerified!,
if (lastLoginAt != null) 'lastLoginAt': lastLoginAt!,
if (localId != null) 'localId': localId!,
if (passwordHash != null) 'passwordHash': passwordHash!,
if (passwordUpdatedAt != null) 'passwordUpdatedAt': passwordUpdatedAt!,
if (phoneNumber != null) 'phoneNumber': phoneNumber!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (providerUserInfo != null) 'providerUserInfo': providerUserInfo!,
if (rawPassword != null) 'rawPassword': rawPassword!,
if (salt != null) 'salt': salt!,
if (screenName != null) 'screenName': screenName!,
if (validSince != null) 'validSince': validSince!,
if (version != null) 'version': version!,
};
}
/// Response of verifying the IDP assertion.
class VerifyAssertionResponse {
/// The action code.
core.String? action;
/// URL for OTA app installation.
core.String? appInstallationUrl;
/// The custom scheme used by mobile app.
core.String? appScheme;
/// The opaque value used by the client to maintain context info between the
/// authentication request and the IDP callback.
core.String? context;
/// The birth date of the IdP account.
core.String? dateOfBirth;
/// The display name of the user.
core.String? displayName;
/// The email returned by the IdP.
///
/// NOTE: The federated login user may not own the email.
core.String? email;
/// It's true if the email is recycled.
core.bool? emailRecycled;
/// The value is true if the IDP is also the email provider.
///
/// It means the user owns the email.
core.bool? emailVerified;
/// Client error code.
core.String? errorMessage;
/// If idToken is STS id token, then this field will be expiration time of STS
/// id token in seconds.
core.String? expiresIn;
/// The unique ID identifies the IdP account.
core.String? federatedId;
/// The first name of the user.
core.String? firstName;
/// The full name of the user.
core.String? fullName;
/// The ID token.
core.String? idToken;
/// It's the identifier param in the createAuthUri request if the identifier
/// is an email.
///
/// It can be used to check whether the user input email is different from the
/// asserted email.
core.String? inputEmail;
/// True if it's a new user sign-in, false if it's a returning user.
core.bool? isNewUser;
/// The fixed string "identitytoolkit#VerifyAssertionResponse".
core.String? kind;
/// The language preference of the user.
core.String? language;
/// The last name of the user.
core.String? lastName;
/// The RP local ID if it's already been mapped to the IdP account identified
/// by the federated ID.
core.String? localId;
/// Whether the assertion is from a non-trusted IDP and need account linking
/// confirmation.
core.bool? needConfirmation;
/// Whether need client to supply email to complete the federated login flow.
core.bool? needEmail;
/// The nick name of the user.
core.String? nickName;
/// The OAuth2 access token.
core.String? oauthAccessToken;
/// The OAuth2 authorization code.
core.String? oauthAuthorizationCode;
/// The lifetime in seconds of the OAuth2 access token.
core.int? oauthExpireIn;
/// The OIDC id token.
core.String? oauthIdToken;
/// The user approved request token for the OpenID OAuth extension.
core.String? oauthRequestToken;
/// The scope for the OpenID OAuth extension.
core.String? oauthScope;
/// The OAuth1 access token secret.
core.String? oauthTokenSecret;
/// The original email stored in the mapping storage.
///
/// It's returned when the federated ID is associated to a different email.
core.String? originalEmail;
/// The URI of the public accessible profiel picture.
core.String? photoUrl;
/// The IdP ID.
///
/// For white listed IdPs it's a short domain name e.g. google.com, aol.com,
/// live.net and yahoo.com. If the "providerId" param is set to OpenID OP
/// identifer other than the whilte listed IdPs the OP identifier is returned.
/// If the "identifier" param is federated ID in the createAuthUri request.
/// The domain part of the federated ID is returned.
core.String? providerId;
/// Raw IDP-returned user info.
core.String? rawUserInfo;
/// If idToken is STS id token, then this field will be refresh token.
core.String? refreshToken;
/// The screen_name of a Twitter user or the login name at Github.
core.String? screenName;
/// The timezone of the user.
core.String? timeZone;
/// When action is 'map', contains the idps which can be used for
/// confirmation.
core.List<core.String>? verifiedProvider;
VerifyAssertionResponse({
this.action,
this.appInstallationUrl,
this.appScheme,
this.context,
this.dateOfBirth,
this.displayName,
this.email,
this.emailRecycled,
this.emailVerified,
this.errorMessage,
this.expiresIn,
this.federatedId,
this.firstName,
this.fullName,
this.idToken,
this.inputEmail,
this.isNewUser,
this.kind,
this.language,
this.lastName,
this.localId,
this.needConfirmation,
this.needEmail,
this.nickName,
this.oauthAccessToken,
this.oauthAuthorizationCode,
this.oauthExpireIn,
this.oauthIdToken,
this.oauthRequestToken,
this.oauthScope,
this.oauthTokenSecret,
this.originalEmail,
this.photoUrl,
this.providerId,
this.rawUserInfo,
this.refreshToken,
this.screenName,
this.timeZone,
this.verifiedProvider,
});
VerifyAssertionResponse.fromJson(core.Map json_)
: this(
action: json_.containsKey('action')
? json_['action'] as core.String
: null,
appInstallationUrl: json_.containsKey('appInstallationUrl')
? json_['appInstallationUrl'] as core.String
: null,
appScheme: json_.containsKey('appScheme')
? json_['appScheme'] as core.String
: null,
context: json_.containsKey('context')
? json_['context'] as core.String
: null,
dateOfBirth: json_.containsKey('dateOfBirth')
? json_['dateOfBirth'] as core.String
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
emailRecycled: json_.containsKey('emailRecycled')
? json_['emailRecycled'] as core.bool
: null,
emailVerified: json_.containsKey('emailVerified')
? json_['emailVerified'] as core.bool
: null,
errorMessage: json_.containsKey('errorMessage')
? json_['errorMessage'] as core.String
: null,
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
federatedId: json_.containsKey('federatedId')
? json_['federatedId'] as core.String
: null,
firstName: json_.containsKey('firstName')
? json_['firstName'] as core.String
: null,
fullName: json_.containsKey('fullName')
? json_['fullName'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
inputEmail: json_.containsKey('inputEmail')
? json_['inputEmail'] as core.String
: null,
isNewUser: json_.containsKey('isNewUser')
? json_['isNewUser'] as core.bool
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
language: json_.containsKey('language')
? json_['language'] as core.String
: null,
lastName: json_.containsKey('lastName')
? json_['lastName'] as core.String
: null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
needConfirmation: json_.containsKey('needConfirmation')
? json_['needConfirmation'] as core.bool
: null,
needEmail: json_.containsKey('needEmail')
? json_['needEmail'] as core.bool
: null,
nickName: json_.containsKey('nickName')
? json_['nickName'] as core.String
: null,
oauthAccessToken: json_.containsKey('oauthAccessToken')
? json_['oauthAccessToken'] as core.String
: null,
oauthAuthorizationCode: json_.containsKey('oauthAuthorizationCode')
? json_['oauthAuthorizationCode'] as core.String
: null,
oauthExpireIn: json_.containsKey('oauthExpireIn')
? json_['oauthExpireIn'] as core.int
: null,
oauthIdToken: json_.containsKey('oauthIdToken')
? json_['oauthIdToken'] as core.String
: null,
oauthRequestToken: json_.containsKey('oauthRequestToken')
? json_['oauthRequestToken'] as core.String
: null,
oauthScope: json_.containsKey('oauthScope')
? json_['oauthScope'] as core.String
: null,
oauthTokenSecret: json_.containsKey('oauthTokenSecret')
? json_['oauthTokenSecret'] as core.String
: null,
originalEmail: json_.containsKey('originalEmail')
? json_['originalEmail'] as core.String
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
providerId: json_.containsKey('providerId')
? json_['providerId'] as core.String
: null,
rawUserInfo: json_.containsKey('rawUserInfo')
? json_['rawUserInfo'] as core.String
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
screenName: json_.containsKey('screenName')
? json_['screenName'] as core.String
: null,
timeZone: json_.containsKey('timeZone')
? json_['timeZone'] as core.String
: null,
verifiedProvider: json_.containsKey('verifiedProvider')
? (json_['verifiedProvider'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (action != null) 'action': action!,
if (appInstallationUrl != null)
'appInstallationUrl': appInstallationUrl!,
if (appScheme != null) 'appScheme': appScheme!,
if (context != null) 'context': context!,
if (dateOfBirth != null) 'dateOfBirth': dateOfBirth!,
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (emailRecycled != null) 'emailRecycled': emailRecycled!,
if (emailVerified != null) 'emailVerified': emailVerified!,
if (errorMessage != null) 'errorMessage': errorMessage!,
if (expiresIn != null) 'expiresIn': expiresIn!,
if (federatedId != null) 'federatedId': federatedId!,
if (firstName != null) 'firstName': firstName!,
if (fullName != null) 'fullName': fullName!,
if (idToken != null) 'idToken': idToken!,
if (inputEmail != null) 'inputEmail': inputEmail!,
if (isNewUser != null) 'isNewUser': isNewUser!,
if (kind != null) 'kind': kind!,
if (language != null) 'language': language!,
if (lastName != null) 'lastName': lastName!,
if (localId != null) 'localId': localId!,
if (needConfirmation != null) 'needConfirmation': needConfirmation!,
if (needEmail != null) 'needEmail': needEmail!,
if (nickName != null) 'nickName': nickName!,
if (oauthAccessToken != null) 'oauthAccessToken': oauthAccessToken!,
if (oauthAuthorizationCode != null)
'oauthAuthorizationCode': oauthAuthorizationCode!,
if (oauthExpireIn != null) 'oauthExpireIn': oauthExpireIn!,
if (oauthIdToken != null) 'oauthIdToken': oauthIdToken!,
if (oauthRequestToken != null) 'oauthRequestToken': oauthRequestToken!,
if (oauthScope != null) 'oauthScope': oauthScope!,
if (oauthTokenSecret != null) 'oauthTokenSecret': oauthTokenSecret!,
if (originalEmail != null) 'originalEmail': originalEmail!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (providerId != null) 'providerId': providerId!,
if (rawUserInfo != null) 'rawUserInfo': rawUserInfo!,
if (refreshToken != null) 'refreshToken': refreshToken!,
if (screenName != null) 'screenName': screenName!,
if (timeZone != null) 'timeZone': timeZone!,
if (verifiedProvider != null) 'verifiedProvider': verifiedProvider!,
};
}
/// Response from verifying a custom token
class VerifyCustomTokenResponse {
/// If idToken is STS id token, then this field will be expiration time of STS
/// id token in seconds.
core.String? expiresIn;
/// The GITKit token for authenticated user.
core.String? idToken;
/// True if it's a new user sign-in, false if it's a returning user.
core.bool? isNewUser;
/// The fixed string "identitytoolkit#VerifyCustomTokenResponse".
core.String? kind;
/// If idToken is STS id token, then this field will be refresh token.
core.String? refreshToken;
VerifyCustomTokenResponse({
this.expiresIn,
this.idToken,
this.isNewUser,
this.kind,
this.refreshToken,
});
VerifyCustomTokenResponse.fromJson(core.Map json_)
: this(
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
isNewUser: json_.containsKey('isNewUser')
? json_['isNewUser'] as core.bool
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (isNewUser != null) 'isNewUser': isNewUser!,
if (kind != null) 'kind': kind!,
if (refreshToken != null) 'refreshToken': refreshToken!,
};
}
/// Request of verifying the password.
class VerifyPasswordResponse {
/// The name of the user.
core.String? displayName;
/// The email returned by the IdP.
///
/// NOTE: The federated login user may not own the email.
core.String? email;
/// If idToken is STS id token, then this field will be expiration time of STS
/// id token in seconds.
core.String? expiresIn;
/// The GITKit token for authenticated user.
core.String? idToken;
/// The fixed string "identitytoolkit#VerifyPasswordResponse".
core.String? kind;
/// The RP local ID if it's already been mapped to the IdP account identified
/// by the federated ID.
core.String? localId;
/// The OAuth2 access token.
core.String? oauthAccessToken;
/// The OAuth2 authorization code.
core.String? oauthAuthorizationCode;
/// The lifetime in seconds of the OAuth2 access token.
core.int? oauthExpireIn;
/// The URI of the user's photo at IdP
core.String? photoUrl;
/// If idToken is STS id token, then this field will be refresh token.
core.String? refreshToken;
/// Whether the email is registered.
core.bool? registered;
VerifyPasswordResponse({
this.displayName,
this.email,
this.expiresIn,
this.idToken,
this.kind,
this.localId,
this.oauthAccessToken,
this.oauthAuthorizationCode,
this.oauthExpireIn,
this.photoUrl,
this.refreshToken,
this.registered,
});
VerifyPasswordResponse.fromJson(core.Map json_)
: this(
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
expiresIn: json_.containsKey('expiresIn')
? json_['expiresIn'] as core.String
: null,
idToken: json_.containsKey('idToken')
? json_['idToken'] as core.String
: null,
kind: json_.containsKey('kind') ? json_['kind'] as core.String : null,
localId: json_.containsKey('localId')
? json_['localId'] as core.String
: null,
oauthAccessToken: json_.containsKey('oauthAccessToken')
? json_['oauthAccessToken'] as core.String
: null,
oauthAuthorizationCode: json_.containsKey('oauthAuthorizationCode')
? json_['oauthAuthorizationCode'] as core.String
: null,
oauthExpireIn: json_.containsKey('oauthExpireIn')
? json_['oauthExpireIn'] as core.int
: null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
refreshToken: json_.containsKey('refreshToken')
? json_['refreshToken'] as core.String
: null,
registered: json_.containsKey('registered')
? json_['registered'] as core.bool
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (email != null) 'email': email!,
if (expiresIn != null) 'expiresIn': expiresIn!,
if (idToken != null) 'idToken': idToken!,
if (kind != null) 'kind': kind!,
if (localId != null) 'localId': localId!,
if (oauthAccessToken != null) 'oauthAccessToken': oauthAccessToken!,
if (oauthAuthorizationCode != null)
'oauthAuthorizationCode': oauthAuthorizationCode!,
if (oauthExpireIn != null) 'oauthExpireIn': oauthExpireIn!,
if (photoUrl != null) 'photoUrl': photoUrl!,
if (refreshToken != null) 'refreshToken': refreshToken!,
if (registered != null) 'registered': registered!,
};
}
|
googleapis.dart/generated/googleapis/lib/identitytoolkit/v3.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/identitytoolkit/v3.dart', 'repo_id': 'googleapis.dart', 'token_count': 55629}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Apps Script API - v1
///
/// Manages and executes Google Apps Script projects.
///
/// For more information, see <https://developers.google.com/apps-script/api/>
///
/// Create an instance of [ScriptApi] to access these resources:
///
/// - [ProcessesResource]
/// - [ProjectsResource]
/// - [ProjectsDeploymentsResource]
/// - [ProjectsVersionsResource]
/// - [ScriptsResource]
library script_v1;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../shared.dart';
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
/// Manages and executes Google Apps Script projects.
class ScriptApi {
/// Read, compose, send, and permanently delete all your email from Gmail
static const mailGoogleComScope = 'https://mail.google.com/';
/// See, edit, share, and permanently delete all the calendars you can access
/// using Google Calendar
static const wwwGoogleComCalendarFeedsScope =
'https://www.google.com/calendar/feeds';
/// See, edit, download, and permanently delete your contacts
static const wwwGoogleComM8FeedsScope = 'https://www.google.com/m8/feeds';
/// View and manage the provisioning of groups on your domain
static const adminDirectoryGroupScope =
'https://www.googleapis.com/auth/admin.directory.group';
/// View and manage the provisioning of users on your domain
static const adminDirectoryUserScope =
'https://www.googleapis.com/auth/admin.directory.user';
/// See, edit, create, and delete all your Google Docs documents
static const documentsScope = 'https://www.googleapis.com/auth/documents';
/// See, edit, create, and delete all of your Google Drive files
static const driveScope = 'https://www.googleapis.com/auth/drive';
/// View and manage your forms in Google Drive
static const formsScope = 'https://www.googleapis.com/auth/forms';
/// View and manage forms that this application has been installed in
static const formsCurrentonlyScope =
'https://www.googleapis.com/auth/forms.currentonly';
/// View and manage your Google Groups
static const groupsScope = 'https://www.googleapis.com/auth/groups';
/// Create and update Google Apps Script deployments
static const scriptDeploymentsScope =
'https://www.googleapis.com/auth/script.deployments';
/// View Google Apps Script deployments
static const scriptDeploymentsReadonlyScope =
'https://www.googleapis.com/auth/script.deployments.readonly';
/// View Google Apps Script project's metrics
static const scriptMetricsScope =
'https://www.googleapis.com/auth/script.metrics';
/// View Google Apps Script processes
static const scriptProcessesScope =
'https://www.googleapis.com/auth/script.processes';
/// Create and update Google Apps Script projects
static const scriptProjectsScope =
'https://www.googleapis.com/auth/script.projects';
/// View Google Apps Script projects
static const scriptProjectsReadonlyScope =
'https://www.googleapis.com/auth/script.projects.readonly';
/// See, edit, create, and delete all your Google Sheets spreadsheets
static const spreadsheetsScope =
'https://www.googleapis.com/auth/spreadsheets';
/// See your primary Google Account email address
static const userinfoEmailScope =
'https://www.googleapis.com/auth/userinfo.email';
final commons.ApiRequester _requester;
ProcessesResource get processes => ProcessesResource(_requester);
ProjectsResource get projects => ProjectsResource(_requester);
ScriptsResource get scripts => ScriptsResource(_requester);
ScriptApi(http.Client client,
{core.String rootUrl = 'https://script.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class ProcessesResource {
final commons.ApiRequester _requester;
ProcessesResource(commons.ApiRequester client) : _requester = client;
/// List information about processes made by or on behalf of a user, such as
/// process type and current status.
///
/// Request parameters:
///
/// [pageSize] - The maximum number of returned processes per page of results.
/// Defaults to 50.
///
/// [pageToken] - The token for continuing a previous list request on the next
/// page. This should be set to the value of `nextPageToken` from a previous
/// response.
///
/// [userProcessFilter_deploymentId] - Optional field used to limit returned
/// processes to those originating from projects with a specific deployment
/// ID.
///
/// [userProcessFilter_endTime] - Optional field used to limit returned
/// processes to those that completed on or before the given timestamp.
///
/// [userProcessFilter_functionName] - Optional field used to limit returned
/// processes to those originating from a script function with the given
/// function name.
///
/// [userProcessFilter_projectName] - Optional field used to limit returned
/// processes to those originating from projects with project names containing
/// a specific string.
///
/// [userProcessFilter_scriptId] - Optional field used to limit returned
/// processes to those originating from projects with a specific script ID.
///
/// [userProcessFilter_startTime] - Optional field used to limit returned
/// processes to those that were started on or after the given timestamp.
///
/// [userProcessFilter_statuses] - Optional field used to limit returned
/// processes to those having one of the specified process statuses.
///
/// [userProcessFilter_types] - Optional field used to limit returned
/// processes to those having one of the specified process types.
///
/// [userProcessFilter_userAccessLevels] - Optional field used to limit
/// returned processes to those having one of the specified user access
/// levels.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListUserProcessesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListUserProcessesResponse> list({
core.int? pageSize,
core.String? pageToken,
core.String? userProcessFilter_deploymentId,
core.String? userProcessFilter_endTime,
core.String? userProcessFilter_functionName,
core.String? userProcessFilter_projectName,
core.String? userProcessFilter_scriptId,
core.String? userProcessFilter_startTime,
core.List<core.String>? userProcessFilter_statuses,
core.List<core.String>? userProcessFilter_types,
core.List<core.String>? userProcessFilter_userAccessLevels,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if (userProcessFilter_deploymentId != null)
'userProcessFilter.deploymentId': [userProcessFilter_deploymentId],
if (userProcessFilter_endTime != null)
'userProcessFilter.endTime': [userProcessFilter_endTime],
if (userProcessFilter_functionName != null)
'userProcessFilter.functionName': [userProcessFilter_functionName],
if (userProcessFilter_projectName != null)
'userProcessFilter.projectName': [userProcessFilter_projectName],
if (userProcessFilter_scriptId != null)
'userProcessFilter.scriptId': [userProcessFilter_scriptId],
if (userProcessFilter_startTime != null)
'userProcessFilter.startTime': [userProcessFilter_startTime],
if (userProcessFilter_statuses != null)
'userProcessFilter.statuses': userProcessFilter_statuses,
if (userProcessFilter_types != null)
'userProcessFilter.types': userProcessFilter_types,
if (userProcessFilter_userAccessLevels != null)
'userProcessFilter.userAccessLevels':
userProcessFilter_userAccessLevels,
if ($fields != null) 'fields': [$fields],
};
const url_ = 'v1/processes';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListUserProcessesResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// List information about a script's executed processes, such as process type
/// and current status.
///
/// Request parameters:
///
/// [pageSize] - The maximum number of returned processes per page of results.
/// Defaults to 50.
///
/// [pageToken] - The token for continuing a previous list request on the next
/// page. This should be set to the value of `nextPageToken` from a previous
/// response.
///
/// [scriptId] - The script ID of the project whose processes are listed.
///
/// [scriptProcessFilter_deploymentId] - Optional field used to limit returned
/// processes to those originating from projects with a specific deployment
/// ID.
///
/// [scriptProcessFilter_endTime] - Optional field used to limit returned
/// processes to those that completed on or before the given timestamp.
///
/// [scriptProcessFilter_functionName] - Optional field used to limit returned
/// processes to those originating from a script function with the given
/// function name.
///
/// [scriptProcessFilter_startTime] - Optional field used to limit returned
/// processes to those that were started on or after the given timestamp.
///
/// [scriptProcessFilter_statuses] - Optional field used to limit returned
/// processes to those having one of the specified process statuses.
///
/// [scriptProcessFilter_types] - Optional field used to limit returned
/// processes to those having one of the specified process types.
///
/// [scriptProcessFilter_userAccessLevels] - Optional field used to limit
/// returned processes to those having one of the specified user access
/// levels.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListScriptProcessesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListScriptProcessesResponse> listScriptProcesses({
core.int? pageSize,
core.String? pageToken,
core.String? scriptId,
core.String? scriptProcessFilter_deploymentId,
core.String? scriptProcessFilter_endTime,
core.String? scriptProcessFilter_functionName,
core.String? scriptProcessFilter_startTime,
core.List<core.String>? scriptProcessFilter_statuses,
core.List<core.String>? scriptProcessFilter_types,
core.List<core.String>? scriptProcessFilter_userAccessLevels,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if (scriptId != null) 'scriptId': [scriptId],
if (scriptProcessFilter_deploymentId != null)
'scriptProcessFilter.deploymentId': [scriptProcessFilter_deploymentId],
if (scriptProcessFilter_endTime != null)
'scriptProcessFilter.endTime': [scriptProcessFilter_endTime],
if (scriptProcessFilter_functionName != null)
'scriptProcessFilter.functionName': [scriptProcessFilter_functionName],
if (scriptProcessFilter_startTime != null)
'scriptProcessFilter.startTime': [scriptProcessFilter_startTime],
if (scriptProcessFilter_statuses != null)
'scriptProcessFilter.statuses': scriptProcessFilter_statuses,
if (scriptProcessFilter_types != null)
'scriptProcessFilter.types': scriptProcessFilter_types,
if (scriptProcessFilter_userAccessLevels != null)
'scriptProcessFilter.userAccessLevels':
scriptProcessFilter_userAccessLevels,
if ($fields != null) 'fields': [$fields],
};
const url_ = 'v1/processes:listScriptProcesses';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListScriptProcessesResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsResource {
final commons.ApiRequester _requester;
ProjectsDeploymentsResource get deployments =>
ProjectsDeploymentsResource(_requester);
ProjectsVersionsResource get versions => ProjectsVersionsResource(_requester);
ProjectsResource(commons.ApiRequester client) : _requester = client;
/// Creates a new, empty script project with no script files and a base
/// manifest file.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Project].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Project> create(
CreateProjectRequest request, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
const url_ = 'v1/projects';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Project.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets a script project's metadata.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Project].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Project> get(
core.String scriptId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/projects/' + commons.escapeVariable('$scriptId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Project.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets the content of the script project, including the code source and
/// metadata for each script file.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [versionNumber] - The version number of the project to retrieve. If not
/// provided, the project's HEAD version is returned.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Content].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Content> getContent(
core.String scriptId, {
core.int? versionNumber,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (versionNumber != null) 'versionNumber': ['${versionNumber}'],
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/content';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Content.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Get metrics data for scripts, such as number of executions and active
/// users.
///
/// Request parameters:
///
/// [scriptId] - Required field indicating the script to get metrics for.
///
/// [metricsFilter_deploymentId] - Optional field indicating a specific
/// deployment to retrieve metrics from.
///
/// [metricsGranularity] - Required field indicating what granularity of
/// metrics are returned.
/// Possible string values are:
/// - "UNSPECIFIED_GRANULARITY" : Default metric granularity used to query no
/// metrics.
/// - "WEEKLY" : Represents weekly metrics.
/// - "DAILY" : Represents daily metrics over a period of 7 days.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Metrics].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Metrics> getMetrics(
core.String scriptId, {
core.String? metricsFilter_deploymentId,
core.String? metricsGranularity,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (metricsFilter_deploymentId != null)
'metricsFilter.deploymentId': [metricsFilter_deploymentId],
if (metricsGranularity != null)
'metricsGranularity': [metricsGranularity],
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/metrics';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Metrics.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Updates the content of the specified script project.
///
/// This content is stored as the HEAD version, and is used when the script is
/// executed as a trigger, in the script editor, in add-on preview mode, or as
/// a web app or Apps Script API in development mode. This clears all the
/// existing files in the project.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Content].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Content> updateContent(
Content request,
core.String scriptId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/content';
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Content.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsDeploymentsResource {
final commons.ApiRequester _requester;
ProjectsDeploymentsResource(commons.ApiRequester client)
: _requester = client;
/// Creates a deployment of an Apps Script project.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Deployment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Deployment> create(
DeploymentConfig request,
core.String scriptId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/deployments';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Deployment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Deletes a deployment of an Apps Script project.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [deploymentId] - The deployment ID to be undeployed.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String scriptId,
core.String deploymentId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/projects/' +
commons.escapeVariable('$scriptId') +
'/deployments/' +
commons.escapeVariable('$deploymentId');
final response_ = await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
);
return Empty.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets a deployment of an Apps Script project.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [deploymentId] - The deployment ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Deployment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Deployment> get(
core.String scriptId,
core.String deploymentId, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/projects/' +
commons.escapeVariable('$scriptId') +
'/deployments/' +
commons.escapeVariable('$deploymentId');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Deployment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists the deployments of an Apps Script project.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [pageSize] - The maximum number of deployments on each returned page.
/// Defaults to 50.
///
/// [pageToken] - The token for continuing a previous list request on the next
/// page. This should be set to the value of `nextPageToken` from a previous
/// response.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListDeploymentsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListDeploymentsResponse> list(
core.String scriptId, {
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/deployments';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListDeploymentsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Updates a deployment of an Apps Script project.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [deploymentId] - The deployment ID for this deployment.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Deployment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Deployment> update(
UpdateDeploymentRequest request,
core.String scriptId,
core.String deploymentId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/projects/' +
commons.escapeVariable('$scriptId') +
'/deployments/' +
commons.escapeVariable('$deploymentId');
final response_ = await _requester.request(
url_,
'PUT',
body: body_,
queryParams: queryParams_,
);
return Deployment.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsVersionsResource {
final commons.ApiRequester _requester;
ProjectsVersionsResource(commons.ApiRequester client) : _requester = client;
/// Creates a new immutable version using the current code, with a unique
/// version number.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Version].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Version> create(
Version request,
core.String scriptId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/versions';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Version.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets a version of a script project.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [versionNumber] - The version number.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Version].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Version> get(
core.String scriptId,
core.int versionNumber, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/projects/' +
commons.escapeVariable('$scriptId') +
'/versions/' +
commons.escapeVariable('$versionNumber');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Version.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// List the versions of a script project.
///
/// Request parameters:
///
/// [scriptId] - The script project's Drive ID.
///
/// [pageSize] - The maximum number of versions on each returned page.
/// Defaults to 50.
///
/// [pageToken] - The token for continuing a previous list request on the next
/// page. This should be set to the value of `nextPageToken` from a previous
/// response.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListVersionsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListVersionsResponse> list(
core.String scriptId, {
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/projects/' + commons.escapeVariable('$scriptId') + '/versions';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListVersionsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ScriptsResource {
final commons.ApiRequester _requester;
ScriptsResource(commons.ApiRequester client) : _requester = client;
/// Runs a function in an Apps Script project.
///
/// The script project must be deployed for use with the Apps Script API and
/// the calling application must share the same Cloud Platform project. This
/// method requires authorization with an OAuth 2.0 token that includes at
/// least one of the scopes listed in the
/// \[Authorization\](#authorization-scopes) section; script projects that do
/// not require authorization cannot be executed through this API. To find the
/// correct scopes to include in the authentication token, open the script
/// project **Overview** page and scroll down to "Project OAuth Scopes." The
/// error `403, PERMISSION_DENIED: The caller does not have permission`
/// indicates that the Cloud Platform project used to authorize the request is
/// not the same as the one used by the script.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [scriptId] - The script ID of the script to be executed. Find the script
/// ID on the **Project settings** page under "IDs."
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> run(
ExecutionRequest request,
core.String scriptId, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/scripts/' + commons.escapeVariable('$scriptId') + ':run';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Operation.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
/// The Content resource.
class Content {
/// The list of script project files.
///
/// One of the files is a script manifest; it must be named "appsscript", must
/// have type of JSON, and include the manifest configurations for the
/// project.
core.List<File>? files;
/// The script project's Drive ID.
core.String? scriptId;
Content({
this.files,
this.scriptId,
});
Content.fromJson(core.Map json_)
: this(
files: json_.containsKey('files')
? (json_['files'] as core.List)
.map((value) => File.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
scriptId: json_.containsKey('scriptId')
? json_['scriptId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (files != null) 'files': files!,
if (scriptId != null) 'scriptId': scriptId!,
};
}
/// Request to create a script project.
///
/// Request to create a script project.
class CreateProjectRequest {
/// The Drive ID of a parent file that the created script project is bound to.
///
/// This is usually the ID of a Google Doc, Google Sheet, Google Form, or
/// Google Slides file. If not set, a standalone script project is created.
core.String? parentId;
/// The title for the project.
core.String? title;
CreateProjectRequest({
this.parentId,
this.title,
});
CreateProjectRequest.fromJson(core.Map json_)
: this(
parentId: json_.containsKey('parentId')
? json_['parentId'] as core.String
: null,
title:
json_.containsKey('title') ? json_['title'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (parentId != null) 'parentId': parentId!,
if (title != null) 'title': title!,
};
}
/// Representation of a single script deployment.
class Deployment {
/// The deployment configuration.
DeploymentConfig? deploymentConfig;
/// The deployment ID for this deployment.
core.String? deploymentId;
/// The deployment's entry points.
core.List<EntryPoint>? entryPoints;
/// Last modified date time stamp.
core.String? updateTime;
Deployment({
this.deploymentConfig,
this.deploymentId,
this.entryPoints,
this.updateTime,
});
Deployment.fromJson(core.Map json_)
: this(
deploymentConfig: json_.containsKey('deploymentConfig')
? DeploymentConfig.fromJson(json_['deploymentConfig']
as core.Map<core.String, core.dynamic>)
: null,
deploymentId: json_.containsKey('deploymentId')
? json_['deploymentId'] as core.String
: null,
entryPoints: json_.containsKey('entryPoints')
? (json_['entryPoints'] as core.List)
.map((value) => EntryPoint.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (deploymentConfig != null) 'deploymentConfig': deploymentConfig!,
if (deploymentId != null) 'deploymentId': deploymentId!,
if (entryPoints != null) 'entryPoints': entryPoints!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// Metadata the defines how a deployment is configured.
class DeploymentConfig {
/// The description for this deployment.
core.String? description;
/// The manifest file name for this deployment.
core.String? manifestFileName;
/// The script project's Drive ID.
core.String? scriptId;
/// The version number on which this deployment is based.
core.int? versionNumber;
DeploymentConfig({
this.description,
this.manifestFileName,
this.scriptId,
this.versionNumber,
});
DeploymentConfig.fromJson(core.Map json_)
: this(
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
manifestFileName: json_.containsKey('manifestFileName')
? json_['manifestFileName'] as core.String
: null,
scriptId: json_.containsKey('scriptId')
? json_['scriptId'] as core.String
: null,
versionNumber: json_.containsKey('versionNumber')
? json_['versionNumber'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (description != null) 'description': description!,
if (manifestFileName != null) 'manifestFileName': manifestFileName!,
if (scriptId != null) 'scriptId': scriptId!,
if (versionNumber != null) 'versionNumber': versionNumber!,
};
}
/// A generic empty message that you can re-use to avoid defining duplicated
/// empty messages in your APIs.
///
/// A typical example is to use it as the request or the response type of an API
/// method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns
/// (google.protobuf.Empty); }
typedef Empty = $Empty;
/// A configuration that defines how a deployment is accessed externally.
class EntryPoint {
/// Add-on properties.
GoogleAppsScriptTypeAddOnEntryPoint? addOn;
/// The type of the entry point.
/// Possible string values are:
/// - "ENTRY_POINT_TYPE_UNSPECIFIED" : An unspecified entry point.
/// - "WEB_APP" : A web application entry point.
/// - "EXECUTION_API" : An API executable entry point.
/// - "ADD_ON" : An Add-On entry point.
core.String? entryPointType;
/// An entry point specification for Apps Script API execution calls.
GoogleAppsScriptTypeExecutionApiEntryPoint? executionApi;
/// An entry point specification for web apps.
GoogleAppsScriptTypeWebAppEntryPoint? webApp;
EntryPoint({
this.addOn,
this.entryPointType,
this.executionApi,
this.webApp,
});
EntryPoint.fromJson(core.Map json_)
: this(
addOn: json_.containsKey('addOn')
? GoogleAppsScriptTypeAddOnEntryPoint.fromJson(
json_['addOn'] as core.Map<core.String, core.dynamic>)
: null,
entryPointType: json_.containsKey('entryPointType')
? json_['entryPointType'] as core.String
: null,
executionApi: json_.containsKey('executionApi')
? GoogleAppsScriptTypeExecutionApiEntryPoint.fromJson(
json_['executionApi'] as core.Map<core.String, core.dynamic>)
: null,
webApp: json_.containsKey('webApp')
? GoogleAppsScriptTypeWebAppEntryPoint.fromJson(
json_['webApp'] as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (addOn != null) 'addOn': addOn!,
if (entryPointType != null) 'entryPointType': entryPointType!,
if (executionApi != null) 'executionApi': executionApi!,
if (webApp != null) 'webApp': webApp!,
};
}
/// A request to run the function in a script.
///
/// The script is identified by the specified `script_id`. Executing a function
/// on a script returns results based on the implementation of the script.
class ExecutionRequest {
/// If `true` and the user is an owner of the script, the script runs at the
/// most recently saved version rather than the version deployed for use with
/// the Apps Script API.
///
/// Optional; default is `false`.
core.bool? devMode;
/// The name of the function to execute in the given script.
///
/// The name does not include parentheses or parameters. It can reference a
/// function in an included library such as `Library.libFunction1`.
core.String? function;
/// The parameters to be passed to the function being executed.
///
/// The object type for each parameter should match the expected type in Apps
/// Script. Parameters cannot be Apps Script-specific object types (such as a
/// `Document` or a `Calendar`); they can only be primitive types such as
/// `string`, `number`, `array`, `object`, or `boolean`. Optional.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.List<core.Object?>? parameters;
/// *Deprecated*.
///
/// For use with Android add-ons only. An ID that represents the user's
/// current session in the Android app for Google Docs or Sheets, included as
/// extra data in the
/// [Intent](https://developer.android.com/guide/components/intents-filters.html)
/// that launches the add-on. When an Android add-on is run with a session
/// state, it gains the privileges of a
/// [bound](https://developers.google.com/apps-script/guides/bound)
/// script—that is, it can access information like the user's current cursor
/// position (in Docs) or selected cell (in Sheets). To retrieve the state,
/// call
/// `Intent.getStringExtra("com.google.android.apps.docs.addons.SessionState")`.
/// Optional.
core.String? sessionState;
ExecutionRequest({
this.devMode,
this.function,
this.parameters,
this.sessionState,
});
ExecutionRequest.fromJson(core.Map json_)
: this(
devMode: json_.containsKey('devMode')
? json_['devMode'] as core.bool
: null,
function: json_.containsKey('function')
? json_['function'] as core.String
: null,
parameters: json_.containsKey('parameters')
? json_['parameters'] as core.List
: null,
sessionState: json_.containsKey('sessionState')
? json_['sessionState'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (devMode != null) 'devMode': devMode!,
if (function != null) 'function': function!,
if (parameters != null) 'parameters': parameters!,
if (sessionState != null) 'sessionState': sessionState!,
};
}
/// An individual file within a script project.
///
/// A file is a third-party source code created by one or more developers. It
/// can be a server-side JS code, HTML, or a configuration file. Each script
/// project can contain multiple files.
class File {
/// Creation date timestamp.
///
/// This read-only field is only visible to users who have WRITER permission
/// for the script project.
core.String? createTime;
/// The defined set of functions in the script file, if any.
GoogleAppsScriptTypeFunctionSet? functionSet;
/// The user who modified the file most recently.
///
/// This read-only field is only visible to users who have WRITER permission
/// for the script project.
GoogleAppsScriptTypeUser? lastModifyUser;
/// The name of the file.
///
/// The file extension is not part of the file name, which can be identified
/// from the type field.
core.String? name;
/// The file content.
core.String? source;
/// The type of the file.
/// Possible string values are:
/// - "ENUM_TYPE_UNSPECIFIED" : Undetermined file type; never actually used.
/// - "SERVER_JS" : An Apps Script server-side code file.
/// - "HTML" : A file containing client-side HTML.
/// - "JSON" : A file in JSON format. This type is only used for the script
/// project's manifest. The manifest file content must match the structure of
/// a valid \[ScriptManifest\](/apps-script/concepts/manifests)
core.String? type;
/// Last modified date timestamp.
///
/// This read-only field is only visible to users who have WRITER permission
/// for the script project.
core.String? updateTime;
File({
this.createTime,
this.functionSet,
this.lastModifyUser,
this.name,
this.source,
this.type,
this.updateTime,
});
File.fromJson(core.Map json_)
: this(
createTime: json_.containsKey('createTime')
? json_['createTime'] as core.String
: null,
functionSet: json_.containsKey('functionSet')
? GoogleAppsScriptTypeFunctionSet.fromJson(
json_['functionSet'] as core.Map<core.String, core.dynamic>)
: null,
lastModifyUser: json_.containsKey('lastModifyUser')
? GoogleAppsScriptTypeUser.fromJson(json_['lastModifyUser']
as core.Map<core.String, core.dynamic>)
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
source: json_.containsKey('source')
? json_['source'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (functionSet != null) 'functionSet': functionSet!,
if (lastModifyUser != null) 'lastModifyUser': lastModifyUser!,
if (name != null) 'name': name!,
if (source != null) 'source': source!,
if (type != null) 'type': type!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// An add-on entry point.
class GoogleAppsScriptTypeAddOnEntryPoint {
/// The add-on's required list of supported container types.
/// Possible string values are:
/// - "UNKNOWN_ADDON_TYPE" : Default value, unknown add-on type.
/// - "GMAIL" : Add-on type for Gmail.
/// - "DATA_STUDIO" : Add-on type for Data Studio.
core.String? addOnType;
/// The add-on's optional description.
core.String? description;
/// The add-on's optional help URL.
core.String? helpUrl;
/// The add-on's required post install tip URL.
core.String? postInstallTipUrl;
/// The add-on's optional report issue URL.
core.String? reportIssueUrl;
/// The add-on's required title.
core.String? title;
GoogleAppsScriptTypeAddOnEntryPoint({
this.addOnType,
this.description,
this.helpUrl,
this.postInstallTipUrl,
this.reportIssueUrl,
this.title,
});
GoogleAppsScriptTypeAddOnEntryPoint.fromJson(core.Map json_)
: this(
addOnType: json_.containsKey('addOnType')
? json_['addOnType'] as core.String
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
helpUrl: json_.containsKey('helpUrl')
? json_['helpUrl'] as core.String
: null,
postInstallTipUrl: json_.containsKey('postInstallTipUrl')
? json_['postInstallTipUrl'] as core.String
: null,
reportIssueUrl: json_.containsKey('reportIssueUrl')
? json_['reportIssueUrl'] as core.String
: null,
title:
json_.containsKey('title') ? json_['title'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (addOnType != null) 'addOnType': addOnType!,
if (description != null) 'description': description!,
if (helpUrl != null) 'helpUrl': helpUrl!,
if (postInstallTipUrl != null) 'postInstallTipUrl': postInstallTipUrl!,
if (reportIssueUrl != null) 'reportIssueUrl': reportIssueUrl!,
if (title != null) 'title': title!,
};
}
/// API executable entry point configuration.
class GoogleAppsScriptTypeExecutionApiConfig {
/// Who has permission to run the API executable.
/// Possible string values are:
/// - "UNKNOWN_ACCESS" : Default value, should not be used.
/// - "MYSELF" : Only the user who deployed the web app or executable can
/// access it. Note that this is not necessarily the owner of the script
/// project.
/// - "DOMAIN" : Only users in the same domain as the user who deployed the
/// web app or executable can access it.
/// - "ANYONE" : Any logged in user can access the web app or executable.
/// - "ANYONE_ANONYMOUS" : Any user, logged in or not, can access the web app
/// or executable.
core.String? access;
GoogleAppsScriptTypeExecutionApiConfig({
this.access,
});
GoogleAppsScriptTypeExecutionApiConfig.fromJson(core.Map json_)
: this(
access: json_.containsKey('access')
? json_['access'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (access != null) 'access': access!,
};
}
/// An API executable entry point.
class GoogleAppsScriptTypeExecutionApiEntryPoint {
/// The entry point's configuration.
GoogleAppsScriptTypeExecutionApiConfig? entryPointConfig;
GoogleAppsScriptTypeExecutionApiEntryPoint({
this.entryPointConfig,
});
GoogleAppsScriptTypeExecutionApiEntryPoint.fromJson(core.Map json_)
: this(
entryPointConfig: json_.containsKey('entryPointConfig')
? GoogleAppsScriptTypeExecutionApiConfig.fromJson(
json_['entryPointConfig']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (entryPointConfig != null) 'entryPointConfig': entryPointConfig!,
};
}
/// Represents a function in a script project.
class GoogleAppsScriptTypeFunction {
/// The function name in the script project.
core.String? name;
/// The ordered list of parameter names of the function in the script project.
core.List<core.String>? parameters;
GoogleAppsScriptTypeFunction({
this.name,
this.parameters,
});
GoogleAppsScriptTypeFunction.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
parameters: json_.containsKey('parameters')
? (json_['parameters'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (parameters != null) 'parameters': parameters!,
};
}
/// A set of functions.
///
/// No duplicates are permitted.
class GoogleAppsScriptTypeFunctionSet {
/// A list of functions composing the set.
core.List<GoogleAppsScriptTypeFunction>? values;
GoogleAppsScriptTypeFunctionSet({
this.values,
});
GoogleAppsScriptTypeFunctionSet.fromJson(core.Map json_)
: this(
values: json_.containsKey('values')
? (json_['values'] as core.List)
.map((value) => GoogleAppsScriptTypeFunction.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (values != null) 'values': values!,
};
}
/// Representation of a single script process execution that was started from
/// the script editor, a trigger, an application, or using the Apps Script API.
///
/// This is distinct from the `Operation` resource, which only represents
/// executions started via the Apps Script API.
class GoogleAppsScriptTypeProcess {
/// Duration the execution spent executing.
core.String? duration;
/// Name of the function the started the execution.
core.String? functionName;
/// The executions status.
/// Possible string values are:
/// - "PROCESS_STATUS_UNSPECIFIED" : Unspecified status.
/// - "RUNNING" : The process is currently running.
/// - "PAUSED" : The process has paused.
/// - "COMPLETED" : The process has completed.
/// - "CANCELED" : The process was cancelled.
/// - "FAILED" : The process failed.
/// - "TIMED_OUT" : The process timed out.
/// - "UNKNOWN" : Process status unknown.
/// - "DELAYED" : The process is delayed, waiting for quota.
core.String? processStatus;
/// The executions type.
/// Possible string values are:
/// - "PROCESS_TYPE_UNSPECIFIED" : Unspecified type.
/// - "ADD_ON" : The process was started from an add-on entry point.
/// - "EXECUTION_API" : The process was started using the Apps Script API.
/// - "TIME_DRIVEN" : The process was started from a time-based trigger.
/// - "TRIGGER" : The process was started from an event-based trigger.
/// - "WEBAPP" : The process was started from a web app entry point.
/// - "EDITOR" : The process was started using the Apps Script IDE.
/// - "SIMPLE_TRIGGER" : The process was started from a G Suite simple
/// trigger.
/// - "MENU" : The process was started from a G Suite menu item.
/// - "BATCH_TASK" : The process was started as a task in a batch job.
core.String? processType;
/// Name of the script being executed.
core.String? projectName;
/// Which version of maestro to use to execute the script.
/// Possible string values are:
/// - "RUNTIME_VERSION_UNSPECIFIED" : Runtime version unset / unknown.
/// - "DEPRECATED_ES5" : Legacy rhino version of the Apps script runtime
/// - "V8" : Current default V8 version of the apps script runtime.
core.String? runtimeVersion;
/// Time the execution started.
core.String? startTime;
/// The executing users access level to the script.
/// Possible string values are:
/// - "USER_ACCESS_LEVEL_UNSPECIFIED" : User access level unspecified
/// - "NONE" : The user has no access.
/// - "READ" : The user has read-only access.
/// - "WRITE" : The user has write access.
/// - "OWNER" : The user is an owner.
core.String? userAccessLevel;
GoogleAppsScriptTypeProcess({
this.duration,
this.functionName,
this.processStatus,
this.processType,
this.projectName,
this.runtimeVersion,
this.startTime,
this.userAccessLevel,
});
GoogleAppsScriptTypeProcess.fromJson(core.Map json_)
: this(
duration: json_.containsKey('duration')
? json_['duration'] as core.String
: null,
functionName: json_.containsKey('functionName')
? json_['functionName'] as core.String
: null,
processStatus: json_.containsKey('processStatus')
? json_['processStatus'] as core.String
: null,
processType: json_.containsKey('processType')
? json_['processType'] as core.String
: null,
projectName: json_.containsKey('projectName')
? json_['projectName'] as core.String
: null,
runtimeVersion: json_.containsKey('runtimeVersion')
? json_['runtimeVersion'] as core.String
: null,
startTime: json_.containsKey('startTime')
? json_['startTime'] as core.String
: null,
userAccessLevel: json_.containsKey('userAccessLevel')
? json_['userAccessLevel'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (duration != null) 'duration': duration!,
if (functionName != null) 'functionName': functionName!,
if (processStatus != null) 'processStatus': processStatus!,
if (processType != null) 'processType': processType!,
if (projectName != null) 'projectName': projectName!,
if (runtimeVersion != null) 'runtimeVersion': runtimeVersion!,
if (startTime != null) 'startTime': startTime!,
if (userAccessLevel != null) 'userAccessLevel': userAccessLevel!,
};
}
/// A simple user profile resource.
class GoogleAppsScriptTypeUser {
/// The user's domain.
core.String? domain;
/// The user's identifying email address.
core.String? email;
/// The user's display name.
core.String? name;
/// The user's photo.
core.String? photoUrl;
GoogleAppsScriptTypeUser({
this.domain,
this.email,
this.name,
this.photoUrl,
});
GoogleAppsScriptTypeUser.fromJson(core.Map json_)
: this(
domain: json_.containsKey('domain')
? json_['domain'] as core.String
: null,
email:
json_.containsKey('email') ? json_['email'] as core.String : null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
photoUrl: json_.containsKey('photoUrl')
? json_['photoUrl'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (domain != null) 'domain': domain!,
if (email != null) 'email': email!,
if (name != null) 'name': name!,
if (photoUrl != null) 'photoUrl': photoUrl!,
};
}
/// Web app entry point configuration.
class GoogleAppsScriptTypeWebAppConfig {
/// Who has permission to run the web app.
/// Possible string values are:
/// - "UNKNOWN_ACCESS" : Default value, should not be used.
/// - "MYSELF" : Only the user who deployed the web app or executable can
/// access it. Note that this is not necessarily the owner of the script
/// project.
/// - "DOMAIN" : Only users in the same domain as the user who deployed the
/// web app or executable can access it.
/// - "ANYONE" : Any logged in user can access the web app or executable.
/// - "ANYONE_ANONYMOUS" : Any user, logged in or not, can access the web app
/// or executable.
core.String? access;
/// Who to execute the web app as.
/// Possible string values are:
/// - "UNKNOWN_EXECUTE_AS" : Default value, should not be used.
/// - "USER_ACCESSING" : The script runs as the user accessing the web app.
/// - "USER_DEPLOYING" : The script runs as the user who deployed the web app.
/// Note that this is not necessarily the owner of the script project.
core.String? executeAs;
GoogleAppsScriptTypeWebAppConfig({
this.access,
this.executeAs,
});
GoogleAppsScriptTypeWebAppConfig.fromJson(core.Map json_)
: this(
access: json_.containsKey('access')
? json_['access'] as core.String
: null,
executeAs: json_.containsKey('executeAs')
? json_['executeAs'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (access != null) 'access': access!,
if (executeAs != null) 'executeAs': executeAs!,
};
}
/// A web application entry point.
class GoogleAppsScriptTypeWebAppEntryPoint {
/// The entry point's configuration.
GoogleAppsScriptTypeWebAppConfig? entryPointConfig;
/// The URL for the web application.
core.String? url;
GoogleAppsScriptTypeWebAppEntryPoint({
this.entryPointConfig,
this.url,
});
GoogleAppsScriptTypeWebAppEntryPoint.fromJson(core.Map json_)
: this(
entryPointConfig: json_.containsKey('entryPointConfig')
? GoogleAppsScriptTypeWebAppConfig.fromJson(
json_['entryPointConfig']
as core.Map<core.String, core.dynamic>)
: null,
url: json_.containsKey('url') ? json_['url'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (entryPointConfig != null) 'entryPointConfig': entryPointConfig!,
if (url != null) 'url': url!,
};
}
/// Response with the list of deployments for the specified Apps Script project.
class ListDeploymentsResponse {
/// The list of deployments.
core.List<Deployment>? deployments;
/// The token that can be used in the next call to get the next page of
/// results.
core.String? nextPageToken;
ListDeploymentsResponse({
this.deployments,
this.nextPageToken,
});
ListDeploymentsResponse.fromJson(core.Map json_)
: this(
deployments: json_.containsKey('deployments')
? (json_['deployments'] as core.List)
.map((value) => Deployment.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (deployments != null) 'deployments': deployments!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
};
}
/// Response with the list of Process resources.
class ListScriptProcessesResponse {
/// Token for the next page of results.
///
/// If empty, there are no more pages remaining.
core.String? nextPageToken;
/// List of processes matching request parameters.
core.List<GoogleAppsScriptTypeProcess>? processes;
ListScriptProcessesResponse({
this.nextPageToken,
this.processes,
});
ListScriptProcessesResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
processes: json_.containsKey('processes')
? (json_['processes'] as core.List)
.map((value) => GoogleAppsScriptTypeProcess.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (processes != null) 'processes': processes!,
};
}
/// Response with the list of Process resources.
class ListUserProcessesResponse {
/// Token for the next page of results.
///
/// If empty, there are no more pages remaining.
core.String? nextPageToken;
/// List of processes matching request parameters.
core.List<GoogleAppsScriptTypeProcess>? processes;
ListUserProcessesResponse({
this.nextPageToken,
this.processes,
});
ListUserProcessesResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
processes: json_.containsKey('processes')
? (json_['processes'] as core.List)
.map((value) => GoogleAppsScriptTypeProcess.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (processes != null) 'processes': processes!,
};
}
/// Response with the list of the versions for the specified script project.
class ListVersionsResponse {
/// The token use to fetch the next page of records.
///
/// if not exist in the response, that means no more versions to list.
core.String? nextPageToken;
/// The list of versions.
core.List<Version>? versions;
ListVersionsResponse({
this.nextPageToken,
this.versions,
});
ListVersionsResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
versions: json_.containsKey('versions')
? (json_['versions'] as core.List)
.map((value) => Version.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (versions != null) 'versions': versions!,
};
}
/// Resource containing usage stats for a given script, based on the supplied
/// filter and mask present in the request.
class Metrics {
/// Number of active users.
core.List<MetricsValue>? activeUsers;
/// Number of failed executions.
core.List<MetricsValue>? failedExecutions;
/// Number of total executions.
core.List<MetricsValue>? totalExecutions;
Metrics({
this.activeUsers,
this.failedExecutions,
this.totalExecutions,
});
Metrics.fromJson(core.Map json_)
: this(
activeUsers: json_.containsKey('activeUsers')
? (json_['activeUsers'] as core.List)
.map((value) => MetricsValue.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
failedExecutions: json_.containsKey('failedExecutions')
? (json_['failedExecutions'] as core.List)
.map((value) => MetricsValue.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
totalExecutions: json_.containsKey('totalExecutions')
? (json_['totalExecutions'] as core.List)
.map((value) => MetricsValue.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (activeUsers != null) 'activeUsers': activeUsers!,
if (failedExecutions != null) 'failedExecutions': failedExecutions!,
if (totalExecutions != null) 'totalExecutions': totalExecutions!,
};
}
/// Metrics value that holds number of executions counted.
class MetricsValue {
/// Required field indicating the end time of the interval.
core.String? endTime;
/// Required field indicating the start time of the interval.
core.String? startTime;
/// Indicates the number of executions counted.
core.String? value;
MetricsValue({
this.endTime,
this.startTime,
this.value,
});
MetricsValue.fromJson(core.Map json_)
: this(
endTime: json_.containsKey('endTime')
? json_['endTime'] as core.String
: null,
startTime: json_.containsKey('startTime')
? json_['startTime'] as core.String
: null,
value:
json_.containsKey('value') ? json_['value'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (endTime != null) 'endTime': endTime!,
if (startTime != null) 'startTime': startTime!,
if (value != null) 'value': value!,
};
}
/// A representation of an execution of an Apps Script function started with
/// run.
///
/// The execution response does not arrive until the function finishes
/// executing. The maximum execution runtime is listed in the \[Apps Script
/// quotas guide\](/apps-script/guides/services/quotas#current_limitations).
/// After execution has started, it can have one of four outcomes: - If the
/// script function returns successfully, the response field contains an
/// ExecutionResponse object with the function's return value in the object's
/// `result` field. - If the script function (or Apps Script itself) throws an
/// exception, the error field contains a Status object. The `Status` object's
/// `details` field contains an array with a single ExecutionError object that
/// provides information about the nature of the error. - If the execution has
/// not yet completed, the done field is `false` and the neither the `response`
/// nor `error` fields are present. - If the `run` call itself fails (for
/// example, because of a malformed request or an authorization error), the
/// method returns an HTTP response code in the 4XX range with a different
/// format for the response body. Client libraries automatically convert a 4XX
/// response into an exception class.
class Operation {
/// This field indicates whether the script execution has completed.
///
/// A completed execution has a populated `response` field containing the
/// ExecutionResponse from function that was executed.
core.bool? done;
/// If a `run` call succeeds but the script function (or Apps Script itself)
/// throws an exception, this field contains a Status object.
///
/// The `Status` object's `details` field contains an array with a single
/// ExecutionError object that provides information about the nature of the
/// error.
Status? error;
/// If the script function returns successfully, this field contains an
/// ExecutionResponse object with the function's return value.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object?>? response;
Operation({
this.done,
this.error,
this.response,
});
Operation.fromJson(core.Map json_)
: this(
done: json_.containsKey('done') ? json_['done'] as core.bool : null,
error: json_.containsKey('error')
? Status.fromJson(
json_['error'] as core.Map<core.String, core.dynamic>)
: null,
response: json_.containsKey('response')
? json_['response'] as core.Map<core.String, core.dynamic>
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (done != null) 'done': done!,
if (error != null) 'error': error!,
if (response != null) 'response': response!,
};
}
/// The script project resource.
class Project {
/// When the script was created.
core.String? createTime;
/// User who originally created the script.
GoogleAppsScriptTypeUser? creator;
/// User who last modified the script.
GoogleAppsScriptTypeUser? lastModifyUser;
/// The parent's Drive ID that the script will be attached to.
///
/// This is usually the ID of a Google Document or Google Sheet. This filed is
/// optional, and if not set, a stand-alone script will be created.
core.String? parentId;
/// The script project's Drive ID.
core.String? scriptId;
/// The title for the project.
core.String? title;
/// When the script was last updated.
core.String? updateTime;
Project({
this.createTime,
this.creator,
this.lastModifyUser,
this.parentId,
this.scriptId,
this.title,
this.updateTime,
});
Project.fromJson(core.Map json_)
: this(
createTime: json_.containsKey('createTime')
? json_['createTime'] as core.String
: null,
creator: json_.containsKey('creator')
? GoogleAppsScriptTypeUser.fromJson(
json_['creator'] as core.Map<core.String, core.dynamic>)
: null,
lastModifyUser: json_.containsKey('lastModifyUser')
? GoogleAppsScriptTypeUser.fromJson(json_['lastModifyUser']
as core.Map<core.String, core.dynamic>)
: null,
parentId: json_.containsKey('parentId')
? json_['parentId'] as core.String
: null,
scriptId: json_.containsKey('scriptId')
? json_['scriptId'] as core.String
: null,
title:
json_.containsKey('title') ? json_['title'] as core.String : null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (creator != null) 'creator': creator!,
if (lastModifyUser != null) 'lastModifyUser': lastModifyUser!,
if (parentId != null) 'parentId': parentId!,
if (scriptId != null) 'scriptId': scriptId!,
if (title != null) 'title': title!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// If a `run` call succeeds but the script function (or Apps Script itself)
/// throws an exception, the response body's error field contains this `Status`
/// object.
class Status {
/// The status code.
///
/// For this API, this value either: - 10, indicating a `SCRIPT_TIMEOUT`
/// error, - 3, indicating an `INVALID_ARGUMENT` error, or - 1, indicating a
/// `CANCELLED` execution.
core.int? code;
/// An array that contains a single ExecutionError object that provides
/// information about the nature of the error.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.List<core.Map<core.String, core.Object?>>? details;
/// A developer-facing error message, which is in English.
///
/// Any user-facing error message is localized and sent in the details field,
/// or localized by the client.
core.String? message;
Status({
this.code,
this.details,
this.message,
});
Status.fromJson(core.Map json_)
: this(
code: json_.containsKey('code') ? json_['code'] as core.int : null,
details: json_.containsKey('details')
? (json_['details'] as core.List)
.map((value) => value as core.Map<core.String, core.dynamic>)
.toList()
: null,
message: json_.containsKey('message')
? json_['message'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (code != null) 'code': code!,
if (details != null) 'details': details!,
if (message != null) 'message': message!,
};
}
/// Request with deployment information to update an existing deployment.
class UpdateDeploymentRequest {
/// The deployment configuration.
DeploymentConfig? deploymentConfig;
UpdateDeploymentRequest({
this.deploymentConfig,
});
UpdateDeploymentRequest.fromJson(core.Map json_)
: this(
deploymentConfig: json_.containsKey('deploymentConfig')
? DeploymentConfig.fromJson(json_['deploymentConfig']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (deploymentConfig != null) 'deploymentConfig': deploymentConfig!,
};
}
/// A resource representing a script project version.
///
/// A version is a "snapshot" of a script project and is similar to a read-only
/// branched release. When creating deployments, the version to use must be
/// specified.
class Version {
/// When the version was created.
core.String? createTime;
/// The description for this version.
core.String? description;
/// The script project's Drive ID.
core.String? scriptId;
/// The incremental ID that is created by Apps Script when a version is
/// created.
///
/// This is system assigned number and is immutable once created.
core.int? versionNumber;
Version({
this.createTime,
this.description,
this.scriptId,
this.versionNumber,
});
Version.fromJson(core.Map json_)
: this(
createTime: json_.containsKey('createTime')
? json_['createTime'] as core.String
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
scriptId: json_.containsKey('scriptId')
? json_['scriptId'] as core.String
: null,
versionNumber: json_.containsKey('versionNumber')
? json_['versionNumber'] as core.int
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (description != null) 'description': description!,
if (scriptId != null) 'scriptId': scriptId!,
if (versionNumber != null) 'versionNumber': versionNumber!,
};
}
|
googleapis.dart/generated/googleapis/lib/script/v1.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/script/v1.dart', 'repo_id': 'googleapis.dart', 'token_count': 27322}
|
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
/// Workload Manager API - v1
///
/// Workload Manager is a service that provides tooling for enterprise workloads
/// to automate the deployment and validation of your workloads against best
/// practices and recommendations.
///
/// For more information, see <https://cloud.google.com/workload-manager/docs>
///
/// Create an instance of [WorkloadManagerApi] to access these resources:
///
/// - [ProjectsResource]
/// - [ProjectsLocationsResource]
/// - [ProjectsLocationsEvaluationsResource]
/// - [ProjectsLocationsEvaluationsExecutionsResource]
/// - [ProjectsLocationsEvaluationsExecutionsResultsResource]
/// - [ProjectsLocationsEvaluationsExecutionsScannedResourcesResource]
/// - [ProjectsLocationsInsightsResource]
/// - [ProjectsLocationsOperationsResource]
/// - [ProjectsLocationsRulesResource]
library workloadmanager_v1;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../shared.dart';
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
/// Workload Manager is a service that provides tooling for enterprise workloads
/// to automate the deployment and validation of your workloads against best
/// practices and recommendations.
class WorkloadManagerApi {
/// See, edit, configure, and delete your Google Cloud data and see the email
/// address for your Google Account.
static const cloudPlatformScope =
'https://www.googleapis.com/auth/cloud-platform';
final commons.ApiRequester _requester;
ProjectsResource get projects => ProjectsResource(_requester);
WorkloadManagerApi(http.Client client,
{core.String rootUrl = 'https://workloadmanager.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, requestHeaders);
}
class ProjectsResource {
final commons.ApiRequester _requester;
ProjectsLocationsResource get locations =>
ProjectsLocationsResource(_requester);
ProjectsResource(commons.ApiRequester client) : _requester = client;
}
class ProjectsLocationsResource {
final commons.ApiRequester _requester;
ProjectsLocationsEvaluationsResource get evaluations =>
ProjectsLocationsEvaluationsResource(_requester);
ProjectsLocationsInsightsResource get insights =>
ProjectsLocationsInsightsResource(_requester);
ProjectsLocationsOperationsResource get operations =>
ProjectsLocationsOperationsResource(_requester);
ProjectsLocationsRulesResource get rules =>
ProjectsLocationsRulesResource(_requester);
ProjectsLocationsResource(commons.ApiRequester client) : _requester = client;
/// Gets information about a location.
///
/// Request parameters:
///
/// [name] - Resource name for the location.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Location].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Location> get(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Location.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists information about the supported locations for this service.
///
/// Request parameters:
///
/// [name] - The resource that owns the locations collection, if applicable.
/// Value must have pattern `^projects/\[^/\]+$`.
///
/// [filter] - A filter to narrow down results to a preferred subset. The
/// filtering language accepts strings like `"displayName=tokyo"`, and is
/// documented in more detail in \[AIP-160\](https://google.aip.dev/160).
///
/// [pageSize] - The maximum number of results to return. If not set, the
/// service selects a default.
///
/// [pageToken] - A page token received from the `next_page_token` field in
/// the response. Send that page token to receive the subsequent page.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListLocationsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListLocationsResponse> list(
core.String name, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name') + '/locations';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListLocationsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsEvaluationsResource {
final commons.ApiRequester _requester;
ProjectsLocationsEvaluationsExecutionsResource get executions =>
ProjectsLocationsEvaluationsExecutionsResource(_requester);
ProjectsLocationsEvaluationsResource(commons.ApiRequester client)
: _requester = client;
/// Creates a new Evaluation in a given project and location.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - Required. The resource prefix of the evaluation location using
/// the form: `projects/{project_id}/locations/{location_id}`
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [evaluationId] - Required. Id of the requesting object
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and the request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> create(
Evaluation request,
core.String parent, {
core.String? evaluationId,
core.String? requestId,
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if (evaluationId != null) 'evaluationId': [evaluationId],
if (requestId != null) 'requestId': [requestId],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/evaluations';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Operation.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets details of a single Evaluation.
///
/// Request parameters:
///
/// [name] - Required. Name of the resource
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Evaluation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Evaluation> get(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Evaluation.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Lists Evaluations in a given project and location.
///
/// Request parameters:
///
/// [parent] - Required. Parent value for ListEvaluationsRequest
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [filter] - Filtering results
///
/// [orderBy] - Hint for how to order the results
///
/// [pageSize] - Requested page size. Server may return fewer items than
/// requested. If unspecified, server will pick an appropriate default.
///
/// [pageToken] - A token identifying a page of results the server should
/// return.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListEvaluationsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListEvaluationsResponse> list(
core.String parent, {
core.String? filter,
core.String? orderBy,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (orderBy != null) 'orderBy': [orderBy],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/evaluations';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListEvaluationsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsEvaluationsExecutionsResource {
final commons.ApiRequester _requester;
ProjectsLocationsEvaluationsExecutionsResultsResource get results =>
ProjectsLocationsEvaluationsExecutionsResultsResource(_requester);
ProjectsLocationsEvaluationsExecutionsScannedResourcesResource
get scannedResources =>
ProjectsLocationsEvaluationsExecutionsScannedResourcesResource(
_requester);
ProjectsLocationsEvaluationsExecutionsResource(commons.ApiRequester client)
: _requester = client;
/// Gets details of a single Execution.
///
/// Request parameters:
///
/// [name] - Required. Name of the resource
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+/executions/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Execution].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Execution> get(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Execution.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists Executions in a given project and location.
///
/// Request parameters:
///
/// [parent] - Required. The resource prefix of the Execution using the form:
/// 'projects/{project}/locations/{location}/evaluations/{evaluation}'
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+$`.
///
/// [filter] - Filtering results
///
/// [orderBy] - Field to sort by. See https://google.aip.dev/132#ordering for
/// more details.
///
/// [pageSize] - Requested page size. Server may return fewer items than
/// requested. If unspecified, server will pick an appropriate default.
///
/// [pageToken] - A token identifying a page of results the server should
/// return.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListExecutionsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListExecutionsResponse> list(
core.String parent, {
core.String? filter,
core.String? orderBy,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (orderBy != null) 'orderBy': [orderBy],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/executions';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListExecutionsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
/// Creates a new Execution in a given project and location.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Required. The resource name of the Execution using the form:
/// 'projects/{project}/locations/{location}/evaluations/{evaluation}/executions/{execution}'
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> run(
RunEvaluationRequest request,
core.String name, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name') + '/executions:run';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Operation.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsEvaluationsExecutionsResultsResource {
final commons.ApiRequester _requester;
ProjectsLocationsEvaluationsExecutionsResultsResource(
commons.ApiRequester client)
: _requester = client;
/// List the running result of a single Execution.
///
/// Request parameters:
///
/// [parent] - Required. The execution results. Format: {parent}/evaluations /
/// * /executions / * /results
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+/executions/\[^/\]+$`.
///
/// [filter] - Filtering results
///
/// [pageSize] - Requested page size. Server may return fewer items than
/// requested. If unspecified, server will pick an appropriate default.
///
/// [pageToken] - A token identifying a page of results the server should
/// return.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListExecutionResultsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListExecutionResultsResponse> list(
core.String parent, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/results';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListExecutionResultsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsEvaluationsExecutionsScannedResourcesResource {
final commons.ApiRequester _requester;
ProjectsLocationsEvaluationsExecutionsScannedResourcesResource(
commons.ApiRequester client)
: _requester = client;
/// List all scanned resources for a single Execution.
///
/// Request parameters:
///
/// [parent] - Required. parent for ListScannedResourcesRequest
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/evaluations/\[^/\]+/executions/\[^/\]+$`.
///
/// [filter] - Filtering results
///
/// [orderBy] - Field to sort by. See https://google.aip.dev/132#ordering for
/// more details.
///
/// [pageSize] - Requested page size. Server may return fewer items than
/// requested. If unspecified, server will pick an appropriate default.
///
/// [pageToken] - A token identifying a page of results the server should
/// return.
///
/// [rule] - rule name
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListScannedResourcesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListScannedResourcesResponse> list(
core.String parent, {
core.String? filter,
core.String? orderBy,
core.int? pageSize,
core.String? pageToken,
core.String? rule,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (orderBy != null) 'orderBy': [orderBy],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if (rule != null) 'rule': [rule],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/scannedResources';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListScannedResourcesResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsInsightsResource {
final commons.ApiRequester _requester;
ProjectsLocationsInsightsResource(commons.ApiRequester client)
: _requester = client;
/// Write the data insights to workload manager data warehouse.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [location] - Required. The GCP location. The format is:
/// projects/{project}/locations/{location}.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [WriteInsightResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<WriteInsightResponse> writeInsight(
WriteInsightRequest request,
core.String location, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ =
'v1/' + core.Uri.encodeFull('$location') + '/insights:writeInsight';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return WriteInsightResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsOperationsResource {
final commons.ApiRequester _requester;
ProjectsLocationsOperationsResource(commons.ApiRequester client)
: _requester = client;
/// Starts asynchronous cancellation on a long-running operation.
///
/// The server makes a best effort to cancel the operation, but success is not
/// guaranteed. If the server doesn't support this method, it returns
/// `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation
/// or other methods to check whether the cancellation succeeded or whether
/// the operation completed despite cancellation. On successful cancellation,
/// the operation is not deleted; instead, it becomes an operation with an
/// Operation.error value with a google.rpc.Status.code of 1, corresponding to
/// `Code.CANCELLED`.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the operation resource to be cancelled.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/operations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> cancel(
CancelOperationRequest request,
core.String name, {
core.String? $fields,
}) async {
final body_ = convert.json.encode(request);
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name') + ':cancel';
final response_ = await _requester.request(
url_,
'POST',
body: body_,
queryParams: queryParams_,
);
return Empty.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Deletes a long-running operation.
///
/// This method indicates that the client is no longer interested in the
/// operation result. It does not cancel the operation. If the server doesn't
/// support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
///
/// Request parameters:
///
/// [name] - The name of the operation resource to be deleted.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/operations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'DELETE',
queryParams: queryParams_,
);
return Empty.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Gets the latest state of a long-running operation.
///
/// Clients can use this method to poll the operation result at intervals as
/// recommended by the API service.
///
/// Request parameters:
///
/// [name] - The name of the operation resource.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/operations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> get(
core.String name, {
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name');
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return Operation.fromJson(response_ as core.Map<core.String, core.dynamic>);
}
/// Lists operations that match the specified filter in the request.
///
/// If the server doesn't support this method, it returns `UNIMPLEMENTED`.
///
/// Request parameters:
///
/// [name] - The name of the operation's parent resource.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [filter] - The standard list filter.
///
/// [pageSize] - The standard list page size.
///
/// [pageToken] - The standard list page token.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListOperationsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListOperationsResponse> list(
core.String name, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$name') + '/operations';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListOperationsResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsRulesResource {
final commons.ApiRequester _requester;
ProjectsLocationsRulesResource(commons.ApiRequester client)
: _requester = client;
/// Lists rules in a given project.
///
/// Request parameters:
///
/// [parent] - Required. The \[project\] on which to execute the request. The
/// format is: projects/{project_id}/locations/{location} Currently, the
/// pre-defined rules are global available to all projects and all regions
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [customRulesBucket] - The Cloud Storage bucket name for custom rules.
///
/// [filter] - Filter based on primary_category, secondary_category
///
/// [pageSize] - Requested page size. Server may return fewer items than
/// requested. If unspecified, server will pick an appropriate default.
///
/// [pageToken] - A token identifying a page of results the server should
/// return.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListRulesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListRulesResponse> list(
core.String parent, {
core.String? customRulesBucket,
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final queryParams_ = <core.String, core.List<core.String>>{
if (customRulesBucket != null) 'customRulesBucket': [customRulesBucket],
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final url_ = 'v1/' + core.Uri.encodeFull('$parent') + '/rules';
final response_ = await _requester.request(
url_,
'GET',
queryParams: queryParams_,
);
return ListRulesResponse.fromJson(
response_ as core.Map<core.String, core.dynamic>);
}
}
/// The request message for Operations.CancelOperation.
typedef CancelOperationRequest = $Empty;
/// A generic empty message that you can re-use to avoid defining duplicated
/// empty messages in your APIs.
///
/// A typical example is to use it as the request or the response type of an API
/// method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns
/// (google.protobuf.Empty); }
typedef Empty = $Empty;
/// LINT.IfChange Message describing Evaluation object
class Evaluation {
/// Create time stamp
///
/// Output only.
core.String? createTime;
/// The Cloud Storage bucket name for custom rules.
core.String? customRulesBucket;
/// Description of the Evaluation
core.String? description;
/// Labels as key value pairs
core.Map<core.String, core.String>? labels;
/// name of resource names have the form
/// 'projects/{project_id}/locations/{location_id}/evaluations/{evaluation_id}'
core.String? name;
/// annotations as key value pairs
ResourceFilter? resourceFilter;
/// The updated rule ids if exist.
///
/// Output only.
ResourceStatus? resourceStatus;
/// the name of the rule
core.List<core.String>? ruleNames;
/// The updated rule ids if exist.
///
/// Output only.
core.List<core.String>? ruleVersions;
/// crontab format schedule for scheduled evaluation, currently only support
/// the following schedule: "0 * / 1 * * *", "0 * / 6 * * *", "0 * / 12 * *
/// *", "0 0 * / 1 * *", "0 0 * / 7 * *",
core.String? schedule;
/// Update time stamp
///
/// Output only.
core.String? updateTime;
Evaluation({
this.createTime,
this.customRulesBucket,
this.description,
this.labels,
this.name,
this.resourceFilter,
this.resourceStatus,
this.ruleNames,
this.ruleVersions,
this.schedule,
this.updateTime,
});
Evaluation.fromJson(core.Map json_)
: this(
createTime: json_.containsKey('createTime')
? json_['createTime'] as core.String
: null,
customRulesBucket: json_.containsKey('customRulesBucket')
? json_['customRulesBucket'] as core.String
: null,
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
labels: json_.containsKey('labels')
? (json_['labels'] as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
resourceFilter: json_.containsKey('resourceFilter')
? ResourceFilter.fromJson(json_['resourceFilter']
as core.Map<core.String, core.dynamic>)
: null,
resourceStatus: json_.containsKey('resourceStatus')
? ResourceStatus.fromJson(json_['resourceStatus']
as core.Map<core.String, core.dynamic>)
: null,
ruleNames: json_.containsKey('ruleNames')
? (json_['ruleNames'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
ruleVersions: json_.containsKey('ruleVersions')
? (json_['ruleVersions'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
schedule: json_.containsKey('schedule')
? json_['schedule'] as core.String
: null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (customRulesBucket != null) 'customRulesBucket': customRulesBucket!,
if (description != null) 'description': description!,
if (labels != null) 'labels': labels!,
if (name != null) 'name': name!,
if (resourceFilter != null) 'resourceFilter': resourceFilter!,
if (resourceStatus != null) 'resourceStatus': resourceStatus!,
if (ruleNames != null) 'ruleNames': ruleNames!,
if (ruleVersions != null) 'ruleVersions': ruleVersions!,
if (schedule != null) 'schedule': schedule!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// Message describing Execution object
class Execution {
/// End time stamp
///
/// Output only.
core.String? endTime;
/// Evaluation ID
///
/// Output only.
core.String? evaluationId;
/// Inventory time stamp
///
/// Output only.
core.String? inventoryTime;
/// Labels as key value pairs
core.Map<core.String, core.String>? labels;
/// The name of execution resource.
///
/// The format is
/// projects/{project}/locations/{location}/evaluations/{evaluation}/executions/{execution}
core.String? name;
/// type represent whether the execution executed directly by user or
/// scheduled according evaluation.schedule field.
/// Possible string values are:
/// - "TYPE_UNSPECIFIED" : type of execution is unspecified
/// - "ONE_TIME" : type of execution is one time
/// - "SCHEDULED" : type of execution is scheduled
core.String? runType;
/// Start time stamp
///
/// Output only.
core.String? startTime;
/// State
///
/// Output only.
/// Possible string values are:
/// - "STATE_UNSPECIFIED" : state of execution is unspecified
/// - "RUNNING" : the execution is running in backend service
/// - "SUCCEEDED" : the execution run success
/// - "FAILED" : the execution run failed
core.String? state;
Execution({
this.endTime,
this.evaluationId,
this.inventoryTime,
this.labels,
this.name,
this.runType,
this.startTime,
this.state,
});
Execution.fromJson(core.Map json_)
: this(
endTime: json_.containsKey('endTime')
? json_['endTime'] as core.String
: null,
evaluationId: json_.containsKey('evaluationId')
? json_['evaluationId'] as core.String
: null,
inventoryTime: json_.containsKey('inventoryTime')
? json_['inventoryTime'] as core.String
: null,
labels: json_.containsKey('labels')
? (json_['labels'] as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
runType: json_.containsKey('runType')
? json_['runType'] as core.String
: null,
startTime: json_.containsKey('startTime')
? json_['startTime'] as core.String
: null,
state:
json_.containsKey('state') ? json_['state'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (endTime != null) 'endTime': endTime!,
if (evaluationId != null) 'evaluationId': evaluationId!,
if (inventoryTime != null) 'inventoryTime': inventoryTime!,
if (labels != null) 'labels': labels!,
if (name != null) 'name': name!,
if (runType != null) 'runType': runType!,
if (startTime != null) 'startTime': startTime!,
if (state != null) 'state': state!,
};
}
/// Message describing the result of an execution
class ExecutionResult {
/// the document url of the rule
core.String? documentationUrl;
/// the violate resource
Resource? resource;
/// the rule which violate in execution
core.String? rule;
/// severity of violation
core.String? severity;
/// the details of violation in result
ViolationDetails? violationDetails;
/// the violation message of an execution
core.String? violationMessage;
ExecutionResult({
this.documentationUrl,
this.resource,
this.rule,
this.severity,
this.violationDetails,
this.violationMessage,
});
ExecutionResult.fromJson(core.Map json_)
: this(
documentationUrl: json_.containsKey('documentationUrl')
? json_['documentationUrl'] as core.String
: null,
resource: json_.containsKey('resource')
? Resource.fromJson(
json_['resource'] as core.Map<core.String, core.dynamic>)
: null,
rule: json_.containsKey('rule') ? json_['rule'] as core.String : null,
severity: json_.containsKey('severity')
? json_['severity'] as core.String
: null,
violationDetails: json_.containsKey('violationDetails')
? ViolationDetails.fromJson(json_['violationDetails']
as core.Map<core.String, core.dynamic>)
: null,
violationMessage: json_.containsKey('violationMessage')
? json_['violationMessage'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (documentationUrl != null) 'documentationUrl': documentationUrl!,
if (resource != null) 'resource': resource!,
if (rule != null) 'rule': rule!,
if (severity != null) 'severity': severity!,
if (violationDetails != null) 'violationDetails': violationDetails!,
if (violationMessage != null) 'violationMessage': violationMessage!,
};
}
/// Message describing compute engine instance filter
class GceInstanceFilter {
/// Service account of compute engine
core.List<core.String>? serviceAccounts;
GceInstanceFilter({
this.serviceAccounts,
});
GceInstanceFilter.fromJson(core.Map json_)
: this(
serviceAccounts: json_.containsKey('serviceAccounts')
? (json_['serviceAccounts'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (serviceAccounts != null) 'serviceAccounts': serviceAccounts!,
};
}
/// A presentation of host resource usage where the workload runs.
class Insight {
/// The instance id where the insight is generated from
///
/// Required.
core.String? instanceId;
/// The insights data for sap system discovery.
///
/// This is a copy of SAP System proto and should get updated whenever that
/// one changes.
SapDiscovery? sapDiscovery;
/// The insights data for the sap workload validation.
SapValidation? sapValidation;
/// Create time stamp
///
/// Output only.
core.String? sentTime;
/// The insights data for the sqlserver workload validation.
SqlserverValidation? sqlserverValidation;
Insight({
this.instanceId,
this.sapDiscovery,
this.sapValidation,
this.sentTime,
this.sqlserverValidation,
});
Insight.fromJson(core.Map json_)
: this(
instanceId: json_.containsKey('instanceId')
? json_['instanceId'] as core.String
: null,
sapDiscovery: json_.containsKey('sapDiscovery')
? SapDiscovery.fromJson(
json_['sapDiscovery'] as core.Map<core.String, core.dynamic>)
: null,
sapValidation: json_.containsKey('sapValidation')
? SapValidation.fromJson(
json_['sapValidation'] as core.Map<core.String, core.dynamic>)
: null,
sentTime: json_.containsKey('sentTime')
? json_['sentTime'] as core.String
: null,
sqlserverValidation: json_.containsKey('sqlserverValidation')
? SqlserverValidation.fromJson(json_['sqlserverValidation']
as core.Map<core.String, core.dynamic>)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (instanceId != null) 'instanceId': instanceId!,
if (sapDiscovery != null) 'sapDiscovery': sapDiscovery!,
if (sapValidation != null) 'sapValidation': sapValidation!,
if (sentTime != null) 'sentTime': sentTime!,
if (sqlserverValidation != null)
'sqlserverValidation': sqlserverValidation!,
};
}
/// Message for response to listing Evaluations
class ListEvaluationsResponse {
/// The list of Evaluation
core.List<Evaluation>? evaluations;
/// A token identifying a page of results the server should return.
core.String? nextPageToken;
/// Locations that could not be reached.
core.List<core.String>? unreachable;
ListEvaluationsResponse({
this.evaluations,
this.nextPageToken,
this.unreachable,
});
ListEvaluationsResponse.fromJson(core.Map json_)
: this(
evaluations: json_.containsKey('evaluations')
? (json_['evaluations'] as core.List)
.map((value) => Evaluation.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
unreachable: json_.containsKey('unreachable')
? (json_['unreachable'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (evaluations != null) 'evaluations': evaluations!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (unreachable != null) 'unreachable': unreachable!,
};
}
/// Message for response of list execution results
class ListExecutionResultsResponse {
/// The versions from the specified publisher.
core.List<ExecutionResult>? executionResults;
/// A token, which can be sent as `page_token` to retrieve the next page.
///
/// If this field is omitted, there are no subsequent pages.
core.String? nextPageToken;
ListExecutionResultsResponse({
this.executionResults,
this.nextPageToken,
});
ListExecutionResultsResponse.fromJson(core.Map json_)
: this(
executionResults: json_.containsKey('executionResults')
? (json_['executionResults'] as core.List)
.map((value) => ExecutionResult.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (executionResults != null) 'executionResults': executionResults!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
};
}
/// Message for response to listing Executions
class ListExecutionsResponse {
/// The list of Execution
core.List<Execution>? executions;
/// A token identifying a page of results the server should return.
core.String? nextPageToken;
/// Locations that could not be reached.
core.List<core.String>? unreachable;
ListExecutionsResponse({
this.executions,
this.nextPageToken,
this.unreachable,
});
ListExecutionsResponse.fromJson(core.Map json_)
: this(
executions: json_.containsKey('executions')
? (json_['executions'] as core.List)
.map((value) => Execution.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
unreachable: json_.containsKey('unreachable')
? (json_['unreachable'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (executions != null) 'executions': executions!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (unreachable != null) 'unreachable': unreachable!,
};
}
/// The response message for Locations.ListLocations.
class ListLocationsResponse {
/// A list of locations that matches the specified filter in the request.
core.List<Location>? locations;
/// The standard List next-page token.
core.String? nextPageToken;
ListLocationsResponse({
this.locations,
this.nextPageToken,
});
ListLocationsResponse.fromJson(core.Map json_)
: this(
locations: json_.containsKey('locations')
? (json_['locations'] as core.List)
.map((value) => Location.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (locations != null) 'locations': locations!,
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
};
}
/// The response message for Operations.ListOperations.
class ListOperationsResponse {
/// The standard List next-page token.
core.String? nextPageToken;
/// A list of operations that matches the specified filter in the request.
core.List<Operation>? operations;
ListOperationsResponse({
this.nextPageToken,
this.operations,
});
ListOperationsResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
operations: json_.containsKey('operations')
? (json_['operations'] as core.List)
.map((value) => Operation.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (operations != null) 'operations': operations!,
};
}
/// Mesesage of response of list rules
class ListRulesResponse {
/// A token identifying a page of results the server should return.
core.String? nextPageToken;
/// all rules in response
core.List<Rule>? rules;
ListRulesResponse({
this.nextPageToken,
this.rules,
});
ListRulesResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
rules: json_.containsKey('rules')
? (json_['rules'] as core.List)
.map((value) => Rule.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (rules != null) 'rules': rules!,
};
}
/// Message for response to list scanned resources
class ListScannedResourcesResponse {
/// A token, which can be sent as `page_token` to retrieve the next page.
///
/// If this field is omitted, there are no subsequent pages.
core.String? nextPageToken;
/// All scanned resources in response
core.List<ScannedResource>? scannedResources;
ListScannedResourcesResponse({
this.nextPageToken,
this.scannedResources,
});
ListScannedResourcesResponse.fromJson(core.Map json_)
: this(
nextPageToken: json_.containsKey('nextPageToken')
? json_['nextPageToken'] as core.String
: null,
scannedResources: json_.containsKey('scannedResources')
? (json_['scannedResources'] as core.List)
.map((value) => ScannedResource.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (scannedResources != null) 'scannedResources': scannedResources!,
};
}
/// A resource that represents a Google Cloud location.
typedef Location = $Location00;
/// This resource represents a long-running operation that is the result of a
/// network API call.
class Operation {
/// If the value is `false`, it means the operation is still in progress.
///
/// If `true`, the operation is completed, and either `error` or `response` is
/// available.
core.bool? done;
/// The error result of the operation in case of failure or cancellation.
Status? error;
/// Service-specific metadata associated with the operation.
///
/// It typically contains progress information and common metadata such as
/// create time. Some services might not provide such metadata. Any method
/// that returns a long-running operation should document the metadata type,
/// if any.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object?>? metadata;
/// The server-assigned name, which is only unique within the same service
/// that originally returns it.
///
/// If you use the default HTTP mapping, the `name` should be a resource name
/// ending with `operations/{unique_id}`.
core.String? name;
/// The normal response of the operation in case of success.
///
/// If the original method returns no data on success, such as `Delete`, the
/// response is `google.protobuf.Empty`. If the original method is standard
/// `Get`/`Create`/`Update`, the response should be the resource. For other
/// methods, the response should have the type `XxxResponse`, where `Xxx` is
/// the original method name. For example, if the original method name is
/// `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object?>? response;
Operation({
this.done,
this.error,
this.metadata,
this.name,
this.response,
});
Operation.fromJson(core.Map json_)
: this(
done: json_.containsKey('done') ? json_['done'] as core.bool : null,
error: json_.containsKey('error')
? Status.fromJson(
json_['error'] as core.Map<core.String, core.dynamic>)
: null,
metadata: json_.containsKey('metadata')
? json_['metadata'] as core.Map<core.String, core.dynamic>
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
response: json_.containsKey('response')
? json_['response'] as core.Map<core.String, core.dynamic>
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (done != null) 'done': done!,
if (error != null) 'error': error!,
if (metadata != null) 'metadata': metadata!,
if (name != null) 'name': name!,
if (response != null) 'response': response!,
};
}
/// Message represent resource in execution result
class Resource {
/// the name of the resource
core.String? name;
/// the service account accosiate with resource
core.String? serviceAccount;
/// the type of reresource
core.String? type;
Resource({
this.name,
this.serviceAccount,
this.type,
});
Resource.fromJson(core.Map json_)
: this(
name: json_.containsKey('name') ? json_['name'] as core.String : null,
serviceAccount: json_.containsKey('serviceAccount')
? json_['serviceAccount'] as core.String
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (name != null) 'name': name!,
if (serviceAccount != null) 'serviceAccount': serviceAccount!,
if (type != null) 'type': type!,
};
}
/// Message describing resource filters
class ResourceFilter {
/// Filter compute engine resource
GceInstanceFilter? gceInstanceFilter;
/// The label used for filter resource
core.Map<core.String, core.String>? inclusionLabels;
/// The id pattern for filter resource
core.List<core.String>? resourceIdPatterns;
/// The scopes of evaluation resource
core.List<core.String>? scopes;
ResourceFilter({
this.gceInstanceFilter,
this.inclusionLabels,
this.resourceIdPatterns,
this.scopes,
});
ResourceFilter.fromJson(core.Map json_)
: this(
gceInstanceFilter: json_.containsKey('gceInstanceFilter')
? GceInstanceFilter.fromJson(json_['gceInstanceFilter']
as core.Map<core.String, core.dynamic>)
: null,
inclusionLabels: json_.containsKey('inclusionLabels')
? (json_['inclusionLabels']
as core.Map<core.String, core.dynamic>)
.map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
resourceIdPatterns: json_.containsKey('resourceIdPatterns')
? (json_['resourceIdPatterns'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
scopes: json_.containsKey('scopes')
? (json_['scopes'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (gceInstanceFilter != null) 'gceInstanceFilter': gceInstanceFilter!,
if (inclusionLabels != null) 'inclusionLabels': inclusionLabels!,
if (resourceIdPatterns != null)
'resourceIdPatterns': resourceIdPatterns!,
if (scopes != null) 'scopes': scopes!,
};
}
/// Message describing resource status
class ResourceStatus {
/// Historical: Used before 2023-05-22 the new version of rule id if exists
@core.Deprecated(
'Not supported. Member documentation may have more information.',
)
core.List<core.String>? rulesNewerVersions;
/// State of the resource
/// Possible string values are:
/// - "STATE_UNSPECIFIED" : The state has not been populated in this message.
/// - "CREATING" : Resource has an active Create operation.
/// - "ACTIVE" : Resource has no outstanding operations on it or has active
/// Update operations.
/// - "DELETING" : Resource has an active Delete operation.
core.String? state;
ResourceStatus({
this.rulesNewerVersions,
this.state,
});
ResourceStatus.fromJson(core.Map json_)
: this(
rulesNewerVersions: json_.containsKey('rulesNewerVersions')
? (json_['rulesNewerVersions'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
state:
json_.containsKey('state') ? json_['state'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (rulesNewerVersions != null)
'rulesNewerVersions': rulesNewerVersions!,
if (state != null) 'state': state!,
};
}
/// Message represent a rule
class Rule {
/// descrite rule in plain language
core.String? description;
/// the name display in UI
core.String? displayName;
/// the message template for rule
core.String? errorMessage;
/// rule name
core.String? name;
/// the primary category
core.String? primaryCategory;
/// the remediation for the rule
core.String? remediation;
/// the version of the rule
///
/// Output only.
core.String? revisionId;
/// the secondary category
core.String? secondaryCategory;
/// the severity of the rule
core.String? severity;
/// the docuement url for the rule
core.String? uri;
Rule({
this.description,
this.displayName,
this.errorMessage,
this.name,
this.primaryCategory,
this.remediation,
this.revisionId,
this.secondaryCategory,
this.severity,
this.uri,
});
Rule.fromJson(core.Map json_)
: this(
description: json_.containsKey('description')
? json_['description'] as core.String
: null,
displayName: json_.containsKey('displayName')
? json_['displayName'] as core.String
: null,
errorMessage: json_.containsKey('errorMessage')
? json_['errorMessage'] as core.String
: null,
name: json_.containsKey('name') ? json_['name'] as core.String : null,
primaryCategory: json_.containsKey('primaryCategory')
? json_['primaryCategory'] as core.String
: null,
remediation: json_.containsKey('remediation')
? json_['remediation'] as core.String
: null,
revisionId: json_.containsKey('revisionId')
? json_['revisionId'] as core.String
: null,
secondaryCategory: json_.containsKey('secondaryCategory')
? json_['secondaryCategory'] as core.String
: null,
severity: json_.containsKey('severity')
? json_['severity'] as core.String
: null,
uri: json_.containsKey('uri') ? json_['uri'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (description != null) 'description': description!,
if (displayName != null) 'displayName': displayName!,
if (errorMessage != null) 'errorMessage': errorMessage!,
if (name != null) 'name': name!,
if (primaryCategory != null) 'primaryCategory': primaryCategory!,
if (remediation != null) 'remediation': remediation!,
if (revisionId != null) 'revisionId': revisionId!,
if (secondaryCategory != null) 'secondaryCategory': secondaryCategory!,
if (severity != null) 'severity': severity!,
if (uri != null) 'uri': uri!,
};
}
/// Message for creating a Execution
class RunEvaluationRequest {
/// The resource being created
///
/// Required.
Execution? execution;
/// Id of the requesting object If auto-generating Id server-side, remove this
/// field and execution_id from the method_signature of Create RPC
///
/// Required.
core.String? executionId;
/// An optional request ID to identify requests.
///
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and the request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// Optional.
core.String? requestId;
RunEvaluationRequest({
this.execution,
this.executionId,
this.requestId,
});
RunEvaluationRequest.fromJson(core.Map json_)
: this(
execution: json_.containsKey('execution')
? Execution.fromJson(
json_['execution'] as core.Map<core.String, core.dynamic>)
: null,
executionId: json_.containsKey('executionId')
? json_['executionId'] as core.String
: null,
requestId: json_.containsKey('requestId')
? json_['requestId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (execution != null) 'execution': execution!,
if (executionId != null) 'executionId': executionId!,
if (requestId != null) 'requestId': requestId!,
};
}
/// LINT.IfChange The schema of SAP system discovery data.
class SapDiscovery {
/// An SAP system may run without an application layer.
SapDiscoveryComponent? applicationLayer;
/// An SAP System must have a database.
SapDiscoveryComponent? databaseLayer;
/// The metadata for SAP system discovery data.
SapDiscoveryMetadata? metadata;
/// A combination of database SID, database instance URI and tenant DB name to
/// make a unique identifier per-system.
core.String? systemId;
/// Unix timestamp this system has been updated last.
core.String? updateTime;
SapDiscovery({
this.applicationLayer,
this.databaseLayer,
this.metadata,
this.systemId,
this.updateTime,
});
SapDiscovery.fromJson(core.Map json_)
: this(
applicationLayer: json_.containsKey('applicationLayer')
? SapDiscoveryComponent.fromJson(json_['applicationLayer']
as core.Map<core.String, core.dynamic>)
: null,
databaseLayer: json_.containsKey('databaseLayer')
? SapDiscoveryComponent.fromJson(
json_['databaseLayer'] as core.Map<core.String, core.dynamic>)
: null,
metadata: json_.containsKey('metadata')
? SapDiscoveryMetadata.fromJson(
json_['metadata'] as core.Map<core.String, core.dynamic>)
: null,
systemId: json_.containsKey('systemId')
? json_['systemId'] as core.String
: null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (applicationLayer != null) 'applicationLayer': applicationLayer!,
if (databaseLayer != null) 'databaseLayer': databaseLayer!,
if (metadata != null) 'metadata': metadata!,
if (systemId != null) 'systemId': systemId!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// Message describing the system component.
class SapDiscoveryComponent {
/// The component is a SAP application.
///
/// Optional.
SapDiscoveryComponentApplicationProperties? applicationProperties;
/// The component is a SAP database.
///
/// Optional.
SapDiscoveryComponentDatabaseProperties? databaseProperties;
/// Pantheon Project in which the resources reside.
core.String? hostProject;
/// The resources in a component.
core.List<SapDiscoveryResource>? resources;
/// The sap identifier, used by the SAP software and helps differentiate
/// systems for customers.
core.String? sid;
SapDiscoveryComponent({
this.applicationProperties,
this.databaseProperties,
this.hostProject,
this.resources,
this.sid,
});
SapDiscoveryComponent.fromJson(core.Map json_)
: this(
applicationProperties: json_.containsKey('applicationProperties')
? SapDiscoveryComponentApplicationProperties.fromJson(
json_['applicationProperties']
as core.Map<core.String, core.dynamic>)
: null,
databaseProperties: json_.containsKey('databaseProperties')
? SapDiscoveryComponentDatabaseProperties.fromJson(
json_['databaseProperties']
as core.Map<core.String, core.dynamic>)
: null,
hostProject: json_.containsKey('hostProject')
? json_['hostProject'] as core.String
: null,
resources: json_.containsKey('resources')
? (json_['resources'] as core.List)
.map((value) => SapDiscoveryResource.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
sid: json_.containsKey('sid') ? json_['sid'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (applicationProperties != null)
'applicationProperties': applicationProperties!,
if (databaseProperties != null)
'databaseProperties': databaseProperties!,
if (hostProject != null) 'hostProject': hostProject!,
if (resources != null) 'resources': resources!,
if (sid != null) 'sid': sid!,
};
}
/// A set of properties describing an SAP Application layer.
class SapDiscoveryComponentApplicationProperties {
/// Type of the application.
///
/// Netweaver, etc.
///
/// Required.
/// Possible string values are:
/// - "APPLICATION_TYPE_UNSPECIFIED" : Unspecified application type
/// - "NETWEAVER" : SAP Netweaver
core.String? applicationType;
/// Resource URI of the recognized ASCS host of the application.
///
/// Required.
core.String? ascsUri;
/// Resource URI of the recognized shared NFS of the application.
///
/// May be empty if the application server has only a single node.
///
/// Optional.
core.String? nfsUri;
SapDiscoveryComponentApplicationProperties({
this.applicationType,
this.ascsUri,
this.nfsUri,
});
SapDiscoveryComponentApplicationProperties.fromJson(core.Map json_)
: this(
applicationType: json_.containsKey('applicationType')
? json_['applicationType'] as core.String
: null,
ascsUri: json_.containsKey('ascsUri')
? json_['ascsUri'] as core.String
: null,
nfsUri: json_.containsKey('nfsUri')
? json_['nfsUri'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (applicationType != null) 'applicationType': applicationType!,
if (ascsUri != null) 'ascsUri': ascsUri!,
if (nfsUri != null) 'nfsUri': nfsUri!,
};
}
/// A set of properties describing an SAP Database layer.
class SapDiscoveryComponentDatabaseProperties {
/// Type of the database.
///
/// HANA, DB2, etc.
///
/// Required.
/// Possible string values are:
/// - "DATABASE_TYPE_UNSPECIFIED" : Unspecified database type.
/// - "HANA" : SAP HANA
/// - "MAX_DB" : SAP MAX_DB
/// - "DB2" : IBM DB2
core.String? databaseType;
/// URI of the recognized primary instance of the database.
///
/// Required.
core.String? primaryInstanceUri;
/// URI of the recognized shared NFS of the database.
///
/// May be empty if the database has only a single node.
///
/// Optional.
core.String? sharedNfsUri;
SapDiscoveryComponentDatabaseProperties({
this.databaseType,
this.primaryInstanceUri,
this.sharedNfsUri,
});
SapDiscoveryComponentDatabaseProperties.fromJson(core.Map json_)
: this(
databaseType: json_.containsKey('databaseType')
? json_['databaseType'] as core.String
: null,
primaryInstanceUri: json_.containsKey('primaryInstanceUri')
? json_['primaryInstanceUri'] as core.String
: null,
sharedNfsUri: json_.containsKey('sharedNfsUri')
? json_['sharedNfsUri'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (databaseType != null) 'databaseType': databaseType!,
if (primaryInstanceUri != null)
'primaryInstanceUri': primaryInstanceUri!,
if (sharedNfsUri != null) 'sharedNfsUri': sharedNfsUri!,
};
}
/// Message describing SAP discovery system metadata
class SapDiscoveryMetadata {
/// Customer region string for customer's use.
///
/// Does not represent GCP region.
core.String? customerRegion;
/// Customer defined, something like "E-commerce pre prod"
core.String? definedSystem;
/// Should be "prod", "QA", "dev", "staging", etc.
core.String? environmentType;
/// This sap product name
core.String? sapProduct;
SapDiscoveryMetadata({
this.customerRegion,
this.definedSystem,
this.environmentType,
this.sapProduct,
});
SapDiscoveryMetadata.fromJson(core.Map json_)
: this(
customerRegion: json_.containsKey('customerRegion')
? json_['customerRegion'] as core.String
: null,
definedSystem: json_.containsKey('definedSystem')
? json_['definedSystem'] as core.String
: null,
environmentType: json_.containsKey('environmentType')
? json_['environmentType'] as core.String
: null,
sapProduct: json_.containsKey('sapProduct')
? json_['sapProduct'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (customerRegion != null) 'customerRegion': customerRegion!,
if (definedSystem != null) 'definedSystem': definedSystem!,
if (environmentType != null) 'environmentType': environmentType!,
if (sapProduct != null) 'sapProduct': sapProduct!,
};
}
/// Message describing a resource.
class SapDiscoveryResource {
/// A list of resource URIs related to this resource.
core.List<core.String>? relatedResources;
/// ComputeInstance, ComputeDisk, VPC, Bare Metal server, etc.
///
/// Required.
/// Possible string values are:
/// - "RESOURCE_KIND_UNSPECIFIED" : Unspecified resource kind.
/// - "RESOURCE_KIND_INSTANCE" : This is a compute instance.
/// - "RESOURCE_KIND_DISK" : This is a compute disk.
/// - "RESOURCE_KIND_ADDRESS" : This is a compute address.
/// - "RESOURCE_KIND_FILESTORE" : This is a filestore instance.
/// - "RESOURCE_KIND_HEALTH_CHECK" : This is a compute health check.
/// - "RESOURCE_KIND_FORWARDING_RULE" : This is a compute forwarding rule.
/// - "RESOURCE_KIND_BACKEND_SERVICE" : This is a compute backend service.
/// - "RESOURCE_KIND_SUBNETWORK" : This is a compute subnetwork.
/// - "RESOURCE_KIND_NETWORK" : This is a compute network.
/// - "RESOURCE_KIND_PUBLIC_ADDRESS" : This is a public accessible IP Address.
/// - "RESOURCE_KIND_INSTANCE_GROUP" : This is a compute instance group.
core.String? resourceKind;
/// The type of this resource.
///
/// Required.
/// Possible string values are:
/// - "RESOURCE_TYPE_UNSPECIFIED" : Undefined resource type.
/// - "RESOURCE_TYPE_COMPUTE" : This is a compute resource.
/// - "RESOURCE_TYPE_STORAGE" : This a storage resource.
/// - "RESOURCE_TYPE_NETWORK" : This is a network resource.
core.String? resourceType;
/// URI of the resource, includes project, location, and name.
core.String? resourceUri;
/// Unix timestamp of when this resource last had its discovery data updated.
core.String? updateTime;
SapDiscoveryResource({
this.relatedResources,
this.resourceKind,
this.resourceType,
this.resourceUri,
this.updateTime,
});
SapDiscoveryResource.fromJson(core.Map json_)
: this(
relatedResources: json_.containsKey('relatedResources')
? (json_['relatedResources'] as core.List)
.map((value) => value as core.String)
.toList()
: null,
resourceKind: json_.containsKey('resourceKind')
? json_['resourceKind'] as core.String
: null,
resourceType: json_.containsKey('resourceType')
? json_['resourceType'] as core.String
: null,
resourceUri: json_.containsKey('resourceUri')
? json_['resourceUri'] as core.String
: null,
updateTime: json_.containsKey('updateTime')
? json_['updateTime'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (relatedResources != null) 'relatedResources': relatedResources!,
if (resourceKind != null) 'resourceKind': resourceKind!,
if (resourceType != null) 'resourceType': resourceType!,
if (resourceUri != null) 'resourceUri': resourceUri!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// A presentation of SAP workload insight.
///
/// The schema of SAP workloads validation related data.
class SapValidation {
/// A list of SAP validation metrics data.
core.List<SapValidationValidationDetail>? validationDetails;
SapValidation({
this.validationDetails,
});
SapValidation.fromJson(core.Map json_)
: this(
validationDetails: json_.containsKey('validationDetails')
? (json_['validationDetails'] as core.List)
.map((value) => SapValidationValidationDetail.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (validationDetails != null) 'validationDetails': validationDetails!,
};
}
/// Message describing the SAP validation metrics.
class SapValidationValidationDetail {
/// The pairs of metrics data: field name & field value.
core.Map<core.String, core.String>? details;
/// The SAP system that the validation data is from.
/// Possible string values are:
/// - "SAP_VALIDATION_TYPE_UNSPECIFIED" : Unspecified type.
/// - "SYSTEM" : The SAP system named SYSTEM.
/// - "COROSYNC" : The SAP system named COROSYNC.
/// - "PACEMAKER" : The SAP system named PACEMAKER.
/// - "HANA" : The SAP system named HANA.
/// - "NETWEAVER" : The SAP system named NETWEAVER.
core.String? sapValidationType;
SapValidationValidationDetail({
this.details,
this.sapValidationType,
});
SapValidationValidationDetail.fromJson(core.Map json_)
: this(
details: json_.containsKey('details')
? (json_['details'] as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
sapValidationType: json_.containsKey('sapValidationType')
? json_['sapValidationType'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (details != null) 'details': details!,
if (sapValidationType != null) 'sapValidationType': sapValidationType!,
};
}
/// Message of scanned resource
class ScannedResource {
/// resource name
core.String? resource;
ScannedResource({
this.resource,
});
ScannedResource.fromJson(core.Map json_)
: this(
resource: json_.containsKey('resource')
? json_['resource'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (resource != null) 'resource': resource!,
};
}
/// A presentation of SQLServer workload insight.
///
/// The schema of SqlServer workloads validation related data.
class SqlserverValidation {
/// The agent version collected this data point
core.String? agentVersion;
/// The instance_name of the instance that the Insight data comes from.
///
/// According to https://linter.aip.dev/122/name-suffix: field names should
/// not use the _name suffix unless the field would be ambiguous without it.
///
/// Required.
core.String? instance;
/// The project_id of the cloud project that the Insight data comes from.
///
/// Required.
core.String? projectId;
/// A list of SqlServer validation metrics data.
core.List<SqlserverValidationValidationDetail>? validationDetails;
SqlserverValidation({
this.agentVersion,
this.instance,
this.projectId,
this.validationDetails,
});
SqlserverValidation.fromJson(core.Map json_)
: this(
agentVersion: json_.containsKey('agentVersion')
? json_['agentVersion'] as core.String
: null,
instance: json_.containsKey('instance')
? json_['instance'] as core.String
: null,
projectId: json_.containsKey('projectId')
? json_['projectId'] as core.String
: null,
validationDetails: json_.containsKey('validationDetails')
? (json_['validationDetails'] as core.List)
.map((value) => SqlserverValidationValidationDetail.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (agentVersion != null) 'agentVersion': agentVersion!,
if (instance != null) 'instance': instance!,
if (projectId != null) 'projectId': projectId!,
if (validationDetails != null) 'validationDetails': validationDetails!,
};
}
/// Message containing collected data names and values.
class SqlserverValidationDetails {
/// Collected data is in format.
///
/// Required.
core.Map<core.String, core.String>? fields;
SqlserverValidationDetails({
this.fields,
});
SqlserverValidationDetails.fromJson(core.Map json_)
: this(
fields: json_.containsKey('fields')
? (json_['fields'] as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (fields != null) 'fields': fields!,
};
}
/// Message describing the Sqlserver validation metrics.
class SqlserverValidationValidationDetail {
/// Details wraps map that represents collected data names and values.
///
/// Required.
core.List<SqlserverValidationDetails>? details;
/// The Sqlserver system that the validation data is from.
/// Possible string values are:
/// - "SQLSERVER_VALIDATION_TYPE_UNSPECIFIED" : Unspecified type.
/// - "OS" : The Sqlserver system named OS.
/// - "DB_LOG_DISK_SEPARATION" : The LOG_DISK_SEPARATION table.
/// - "DB_MAX_PARALLELISM" : The MAX_PARALLELISM table.
/// - "DB_CXPACKET_WAITS" : The CXPACKET_WAITS table.
/// - "DB_TRANSACTION_LOG_HANDLING" : The TRANSACTION_LOG_HANDLING table.
/// - "DB_VIRTUAL_LOG_FILE_COUNT" : The VIRTUAL_LOG_FILE_COUNT table.
/// - "DB_BUFFER_POOL_EXTENSION" : The BUFFER_POOL_EXTENSION table.
/// - "DB_MAX_SERVER_MEMORY" : The MAX_SERVER_MEMORY table.
/// - "INSTANCE_METRICS" : The INSTANCE_METRICS table.
core.String? type;
SqlserverValidationValidationDetail({
this.details,
this.type,
});
SqlserverValidationValidationDetail.fromJson(core.Map json_)
: this(
details: json_.containsKey('details')
? (json_['details'] as core.List)
.map((value) => SqlserverValidationDetails.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList()
: null,
type: json_.containsKey('type') ? json_['type'] as core.String : null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (details != null) 'details': details!,
if (type != null) 'type': type!,
};
}
/// The `Status` type defines a logical error model that is suitable for
/// different programming environments, including REST APIs and RPC APIs.
///
/// It is used by [gRPC](https://github.com/grpc). Each `Status` message
/// contains three pieces of data: error code, error message, and error details.
/// You can find out more about this error model and how to work with it in the
/// [API Design Guide](https://cloud.google.com/apis/design/errors).
typedef Status = $Status;
/// Message describing the violdation in execution result
class ViolationDetails {
/// the name of asset
core.String? asset;
/// observed
core.Map<core.String, core.String>? observed;
/// the service account associate with resource
core.String? serviceAccount;
ViolationDetails({
this.asset,
this.observed,
this.serviceAccount,
});
ViolationDetails.fromJson(core.Map json_)
: this(
asset:
json_.containsKey('asset') ? json_['asset'] as core.String : null,
observed: json_.containsKey('observed')
? (json_['observed'] as core.Map<core.String, core.dynamic>).map(
(key, value) => core.MapEntry(
key,
value as core.String,
),
)
: null,
serviceAccount: json_.containsKey('serviceAccount')
? json_['serviceAccount'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (asset != null) 'asset': asset!,
if (observed != null) 'observed': observed!,
if (serviceAccount != null) 'serviceAccount': serviceAccount!,
};
}
/// Request for sending the data insights.
class WriteInsightRequest {
/// The metrics data details.
///
/// Required.
Insight? insight;
/// An optional request ID to identify requests.
///
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and the request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// Optional.
core.String? requestId;
WriteInsightRequest({
this.insight,
this.requestId,
});
WriteInsightRequest.fromJson(core.Map json_)
: this(
insight: json_.containsKey('insight')
? Insight.fromJson(
json_['insight'] as core.Map<core.String, core.dynamic>)
: null,
requestId: json_.containsKey('requestId')
? json_['requestId'] as core.String
: null,
);
core.Map<core.String, core.dynamic> toJson() => {
if (insight != null) 'insight': insight!,
if (requestId != null) 'requestId': requestId!,
};
}
/// The response for write insights request.
typedef WriteInsightResponse = $Empty;
|
googleapis.dart/generated/googleapis/lib/workloadmanager/v1.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/lib/workloadmanager/v1.dart', 'repo_id': 'googleapis.dart', 'token_count': 32225}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/adsense/v2.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAccount = 0;
api.Account buildAccount() {
final o = api.Account();
buildCounterAccount++;
if (buildCounterAccount < 3) {
o.createTime = 'foo';
o.displayName = 'foo';
o.name = 'foo';
o.pendingTasks = buildUnnamed0();
o.premium = true;
o.state = 'foo';
o.timeZone = buildTimeZone();
}
buildCounterAccount--;
return o;
}
void checkAccount(api.Account o) {
buildCounterAccount++;
if (buildCounterAccount < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed0(o.pendingTasks!);
unittest.expect(o.premium!, unittest.isTrue);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
checkTimeZone(o.timeZone!);
}
buildCounterAccount--;
}
core.int buildCounterAdBlockingRecoveryTag = 0;
api.AdBlockingRecoveryTag buildAdBlockingRecoveryTag() {
final o = api.AdBlockingRecoveryTag();
buildCounterAdBlockingRecoveryTag++;
if (buildCounterAdBlockingRecoveryTag < 3) {
o.errorProtectionCode = 'foo';
o.tag = 'foo';
}
buildCounterAdBlockingRecoveryTag--;
return o;
}
void checkAdBlockingRecoveryTag(api.AdBlockingRecoveryTag o) {
buildCounterAdBlockingRecoveryTag++;
if (buildCounterAdBlockingRecoveryTag < 3) {
unittest.expect(
o.errorProtectionCode!,
unittest.equals('foo'),
);
unittest.expect(
o.tag!,
unittest.equals('foo'),
);
}
buildCounterAdBlockingRecoveryTag--;
}
core.int buildCounterAdClient = 0;
api.AdClient buildAdClient() {
final o = api.AdClient();
buildCounterAdClient++;
if (buildCounterAdClient < 3) {
o.name = 'foo';
o.productCode = 'foo';
o.reportingDimensionId = 'foo';
o.state = 'foo';
}
buildCounterAdClient--;
return o;
}
void checkAdClient(api.AdClient o) {
buildCounterAdClient++;
if (buildCounterAdClient < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.productCode!,
unittest.equals('foo'),
);
unittest.expect(
o.reportingDimensionId!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterAdClient--;
}
core.int buildCounterAdClientAdCode = 0;
api.AdClientAdCode buildAdClientAdCode() {
final o = api.AdClientAdCode();
buildCounterAdClientAdCode++;
if (buildCounterAdClientAdCode < 3) {
o.adCode = 'foo';
o.ampBody = 'foo';
o.ampHead = 'foo';
}
buildCounterAdClientAdCode--;
return o;
}
void checkAdClientAdCode(api.AdClientAdCode o) {
buildCounterAdClientAdCode++;
if (buildCounterAdClientAdCode < 3) {
unittest.expect(
o.adCode!,
unittest.equals('foo'),
);
unittest.expect(
o.ampBody!,
unittest.equals('foo'),
);
unittest.expect(
o.ampHead!,
unittest.equals('foo'),
);
}
buildCounterAdClientAdCode--;
}
core.int buildCounterAdUnit = 0;
api.AdUnit buildAdUnit() {
final o = api.AdUnit();
buildCounterAdUnit++;
if (buildCounterAdUnit < 3) {
o.contentAdsSettings = buildContentAdsSettings();
o.displayName = 'foo';
o.name = 'foo';
o.reportingDimensionId = 'foo';
o.state = 'foo';
}
buildCounterAdUnit--;
return o;
}
void checkAdUnit(api.AdUnit o) {
buildCounterAdUnit++;
if (buildCounterAdUnit < 3) {
checkContentAdsSettings(o.contentAdsSettings!);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.reportingDimensionId!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterAdUnit--;
}
core.int buildCounterAdUnitAdCode = 0;
api.AdUnitAdCode buildAdUnitAdCode() {
final o = api.AdUnitAdCode();
buildCounterAdUnitAdCode++;
if (buildCounterAdUnitAdCode < 3) {
o.adCode = 'foo';
}
buildCounterAdUnitAdCode--;
return o;
}
void checkAdUnitAdCode(api.AdUnitAdCode o) {
buildCounterAdUnitAdCode++;
if (buildCounterAdUnitAdCode < 3) {
unittest.expect(
o.adCode!,
unittest.equals('foo'),
);
}
buildCounterAdUnitAdCode--;
}
core.int buildCounterAlert = 0;
api.Alert buildAlert() {
final o = api.Alert();
buildCounterAlert++;
if (buildCounterAlert < 3) {
o.message = 'foo';
o.name = 'foo';
o.severity = 'foo';
o.type = 'foo';
}
buildCounterAlert--;
return o;
}
void checkAlert(api.Alert o) {
buildCounterAlert++;
if (buildCounterAlert < 3) {
unittest.expect(
o.message!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.severity!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterAlert--;
}
core.int buildCounterCell = 0;
api.Cell buildCell() {
final o = api.Cell();
buildCounterCell++;
if (buildCounterCell < 3) {
o.value = 'foo';
}
buildCounterCell--;
return o;
}
void checkCell(api.Cell o) {
buildCounterCell++;
if (buildCounterCell < 3) {
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterCell--;
}
core.int buildCounterContentAdsSettings = 0;
api.ContentAdsSettings buildContentAdsSettings() {
final o = api.ContentAdsSettings();
buildCounterContentAdsSettings++;
if (buildCounterContentAdsSettings < 3) {
o.size = 'foo';
o.type = 'foo';
}
buildCounterContentAdsSettings--;
return o;
}
void checkContentAdsSettings(api.ContentAdsSettings o) {
buildCounterContentAdsSettings++;
if (buildCounterContentAdsSettings < 3) {
unittest.expect(
o.size!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterContentAdsSettings--;
}
core.int buildCounterCustomChannel = 0;
api.CustomChannel buildCustomChannel() {
final o = api.CustomChannel();
buildCounterCustomChannel++;
if (buildCounterCustomChannel < 3) {
o.active = true;
o.displayName = 'foo';
o.name = 'foo';
o.reportingDimensionId = 'foo';
}
buildCounterCustomChannel--;
return o;
}
void checkCustomChannel(api.CustomChannel o) {
buildCounterCustomChannel++;
if (buildCounterCustomChannel < 3) {
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.reportingDimensionId!,
unittest.equals('foo'),
);
}
buildCounterCustomChannel--;
}
core.int buildCounterDate = 0;
api.Date buildDate() {
final o = api.Date();
buildCounterDate++;
if (buildCounterDate < 3) {
o.day = 42;
o.month = 42;
o.year = 42;
}
buildCounterDate--;
return o;
}
void checkDate(api.Date o) {
buildCounterDate++;
if (buildCounterDate < 3) {
unittest.expect(
o.day!,
unittest.equals(42),
);
unittest.expect(
o.month!,
unittest.equals(42),
);
unittest.expect(
o.year!,
unittest.equals(42),
);
}
buildCounterDate--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.int buildCounterHeader = 0;
api.Header buildHeader() {
final o = api.Header();
buildCounterHeader++;
if (buildCounterHeader < 3) {
o.currencyCode = 'foo';
o.name = 'foo';
o.type = 'foo';
}
buildCounterHeader--;
return o;
}
void checkHeader(api.Header o) {
buildCounterHeader++;
if (buildCounterHeader < 3) {
unittest.expect(
o.currencyCode!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterHeader--;
}
core.Map<core.String, core.Object?> buildUnnamed1() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed1(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.List<core.Map<core.String, core.Object?>> buildUnnamed2() => [
buildUnnamed1(),
buildUnnamed1(),
];
void checkUnnamed2(core.List<core.Map<core.String, core.Object?>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed1(o[0]);
checkUnnamed1(o[1]);
}
core.int buildCounterHttpBody = 0;
api.HttpBody buildHttpBody() {
final o = api.HttpBody();
buildCounterHttpBody++;
if (buildCounterHttpBody < 3) {
o.contentType = 'foo';
o.data = 'foo';
o.extensions = buildUnnamed2();
}
buildCounterHttpBody--;
return o;
}
void checkHttpBody(api.HttpBody o) {
buildCounterHttpBody++;
if (buildCounterHttpBody < 3) {
unittest.expect(
o.contentType!,
unittest.equals('foo'),
);
unittest.expect(
o.data!,
unittest.equals('foo'),
);
checkUnnamed2(o.extensions!);
}
buildCounterHttpBody--;
}
core.List<api.Account> buildUnnamed3() => [
buildAccount(),
buildAccount(),
];
void checkUnnamed3(core.List<api.Account> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccount(o[0]);
checkAccount(o[1]);
}
core.int buildCounterListAccountsResponse = 0;
api.ListAccountsResponse buildListAccountsResponse() {
final o = api.ListAccountsResponse();
buildCounterListAccountsResponse++;
if (buildCounterListAccountsResponse < 3) {
o.accounts = buildUnnamed3();
o.nextPageToken = 'foo';
}
buildCounterListAccountsResponse--;
return o;
}
void checkListAccountsResponse(api.ListAccountsResponse o) {
buildCounterListAccountsResponse++;
if (buildCounterListAccountsResponse < 3) {
checkUnnamed3(o.accounts!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListAccountsResponse--;
}
core.List<api.AdClient> buildUnnamed4() => [
buildAdClient(),
buildAdClient(),
];
void checkUnnamed4(core.List<api.AdClient> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdClient(o[0]);
checkAdClient(o[1]);
}
core.int buildCounterListAdClientsResponse = 0;
api.ListAdClientsResponse buildListAdClientsResponse() {
final o = api.ListAdClientsResponse();
buildCounterListAdClientsResponse++;
if (buildCounterListAdClientsResponse < 3) {
o.adClients = buildUnnamed4();
o.nextPageToken = 'foo';
}
buildCounterListAdClientsResponse--;
return o;
}
void checkListAdClientsResponse(api.ListAdClientsResponse o) {
buildCounterListAdClientsResponse++;
if (buildCounterListAdClientsResponse < 3) {
checkUnnamed4(o.adClients!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListAdClientsResponse--;
}
core.List<api.AdUnit> buildUnnamed5() => [
buildAdUnit(),
buildAdUnit(),
];
void checkUnnamed5(core.List<api.AdUnit> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdUnit(o[0]);
checkAdUnit(o[1]);
}
core.int buildCounterListAdUnitsResponse = 0;
api.ListAdUnitsResponse buildListAdUnitsResponse() {
final o = api.ListAdUnitsResponse();
buildCounterListAdUnitsResponse++;
if (buildCounterListAdUnitsResponse < 3) {
o.adUnits = buildUnnamed5();
o.nextPageToken = 'foo';
}
buildCounterListAdUnitsResponse--;
return o;
}
void checkListAdUnitsResponse(api.ListAdUnitsResponse o) {
buildCounterListAdUnitsResponse++;
if (buildCounterListAdUnitsResponse < 3) {
checkUnnamed5(o.adUnits!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListAdUnitsResponse--;
}
core.List<api.Alert> buildUnnamed6() => [
buildAlert(),
buildAlert(),
];
void checkUnnamed6(core.List<api.Alert> o) {
unittest.expect(o, unittest.hasLength(2));
checkAlert(o[0]);
checkAlert(o[1]);
}
core.int buildCounterListAlertsResponse = 0;
api.ListAlertsResponse buildListAlertsResponse() {
final o = api.ListAlertsResponse();
buildCounterListAlertsResponse++;
if (buildCounterListAlertsResponse < 3) {
o.alerts = buildUnnamed6();
}
buildCounterListAlertsResponse--;
return o;
}
void checkListAlertsResponse(api.ListAlertsResponse o) {
buildCounterListAlertsResponse++;
if (buildCounterListAlertsResponse < 3) {
checkUnnamed6(o.alerts!);
}
buildCounterListAlertsResponse--;
}
core.List<api.Account> buildUnnamed7() => [
buildAccount(),
buildAccount(),
];
void checkUnnamed7(core.List<api.Account> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccount(o[0]);
checkAccount(o[1]);
}
core.int buildCounterListChildAccountsResponse = 0;
api.ListChildAccountsResponse buildListChildAccountsResponse() {
final o = api.ListChildAccountsResponse();
buildCounterListChildAccountsResponse++;
if (buildCounterListChildAccountsResponse < 3) {
o.accounts = buildUnnamed7();
o.nextPageToken = 'foo';
}
buildCounterListChildAccountsResponse--;
return o;
}
void checkListChildAccountsResponse(api.ListChildAccountsResponse o) {
buildCounterListChildAccountsResponse++;
if (buildCounterListChildAccountsResponse < 3) {
checkUnnamed7(o.accounts!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListChildAccountsResponse--;
}
core.List<api.CustomChannel> buildUnnamed8() => [
buildCustomChannel(),
buildCustomChannel(),
];
void checkUnnamed8(core.List<api.CustomChannel> o) {
unittest.expect(o, unittest.hasLength(2));
checkCustomChannel(o[0]);
checkCustomChannel(o[1]);
}
core.int buildCounterListCustomChannelsResponse = 0;
api.ListCustomChannelsResponse buildListCustomChannelsResponse() {
final o = api.ListCustomChannelsResponse();
buildCounterListCustomChannelsResponse++;
if (buildCounterListCustomChannelsResponse < 3) {
o.customChannels = buildUnnamed8();
o.nextPageToken = 'foo';
}
buildCounterListCustomChannelsResponse--;
return o;
}
void checkListCustomChannelsResponse(api.ListCustomChannelsResponse o) {
buildCounterListCustomChannelsResponse++;
if (buildCounterListCustomChannelsResponse < 3) {
checkUnnamed8(o.customChannels!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListCustomChannelsResponse--;
}
core.List<api.AdUnit> buildUnnamed9() => [
buildAdUnit(),
buildAdUnit(),
];
void checkUnnamed9(core.List<api.AdUnit> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdUnit(o[0]);
checkAdUnit(o[1]);
}
core.int buildCounterListLinkedAdUnitsResponse = 0;
api.ListLinkedAdUnitsResponse buildListLinkedAdUnitsResponse() {
final o = api.ListLinkedAdUnitsResponse();
buildCounterListLinkedAdUnitsResponse++;
if (buildCounterListLinkedAdUnitsResponse < 3) {
o.adUnits = buildUnnamed9();
o.nextPageToken = 'foo';
}
buildCounterListLinkedAdUnitsResponse--;
return o;
}
void checkListLinkedAdUnitsResponse(api.ListLinkedAdUnitsResponse o) {
buildCounterListLinkedAdUnitsResponse++;
if (buildCounterListLinkedAdUnitsResponse < 3) {
checkUnnamed9(o.adUnits!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLinkedAdUnitsResponse--;
}
core.List<api.CustomChannel> buildUnnamed10() => [
buildCustomChannel(),
buildCustomChannel(),
];
void checkUnnamed10(core.List<api.CustomChannel> o) {
unittest.expect(o, unittest.hasLength(2));
checkCustomChannel(o[0]);
checkCustomChannel(o[1]);
}
core.int buildCounterListLinkedCustomChannelsResponse = 0;
api.ListLinkedCustomChannelsResponse buildListLinkedCustomChannelsResponse() {
final o = api.ListLinkedCustomChannelsResponse();
buildCounterListLinkedCustomChannelsResponse++;
if (buildCounterListLinkedCustomChannelsResponse < 3) {
o.customChannels = buildUnnamed10();
o.nextPageToken = 'foo';
}
buildCounterListLinkedCustomChannelsResponse--;
return o;
}
void checkListLinkedCustomChannelsResponse(
api.ListLinkedCustomChannelsResponse o) {
buildCounterListLinkedCustomChannelsResponse++;
if (buildCounterListLinkedCustomChannelsResponse < 3) {
checkUnnamed10(o.customChannels!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLinkedCustomChannelsResponse--;
}
core.List<api.Payment> buildUnnamed11() => [
buildPayment(),
buildPayment(),
];
void checkUnnamed11(core.List<api.Payment> o) {
unittest.expect(o, unittest.hasLength(2));
checkPayment(o[0]);
checkPayment(o[1]);
}
core.int buildCounterListPaymentsResponse = 0;
api.ListPaymentsResponse buildListPaymentsResponse() {
final o = api.ListPaymentsResponse();
buildCounterListPaymentsResponse++;
if (buildCounterListPaymentsResponse < 3) {
o.payments = buildUnnamed11();
}
buildCounterListPaymentsResponse--;
return o;
}
void checkListPaymentsResponse(api.ListPaymentsResponse o) {
buildCounterListPaymentsResponse++;
if (buildCounterListPaymentsResponse < 3) {
checkUnnamed11(o.payments!);
}
buildCounterListPaymentsResponse--;
}
core.List<api.SavedReport> buildUnnamed12() => [
buildSavedReport(),
buildSavedReport(),
];
void checkUnnamed12(core.List<api.SavedReport> o) {
unittest.expect(o, unittest.hasLength(2));
checkSavedReport(o[0]);
checkSavedReport(o[1]);
}
core.int buildCounterListSavedReportsResponse = 0;
api.ListSavedReportsResponse buildListSavedReportsResponse() {
final o = api.ListSavedReportsResponse();
buildCounterListSavedReportsResponse++;
if (buildCounterListSavedReportsResponse < 3) {
o.nextPageToken = 'foo';
o.savedReports = buildUnnamed12();
}
buildCounterListSavedReportsResponse--;
return o;
}
void checkListSavedReportsResponse(api.ListSavedReportsResponse o) {
buildCounterListSavedReportsResponse++;
if (buildCounterListSavedReportsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed12(o.savedReports!);
}
buildCounterListSavedReportsResponse--;
}
core.List<api.Site> buildUnnamed13() => [
buildSite(),
buildSite(),
];
void checkUnnamed13(core.List<api.Site> o) {
unittest.expect(o, unittest.hasLength(2));
checkSite(o[0]);
checkSite(o[1]);
}
core.int buildCounterListSitesResponse = 0;
api.ListSitesResponse buildListSitesResponse() {
final o = api.ListSitesResponse();
buildCounterListSitesResponse++;
if (buildCounterListSitesResponse < 3) {
o.nextPageToken = 'foo';
o.sites = buildUnnamed13();
}
buildCounterListSitesResponse--;
return o;
}
void checkListSitesResponse(api.ListSitesResponse o) {
buildCounterListSitesResponse++;
if (buildCounterListSitesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed13(o.sites!);
}
buildCounterListSitesResponse--;
}
core.List<api.UrlChannel> buildUnnamed14() => [
buildUrlChannel(),
buildUrlChannel(),
];
void checkUnnamed14(core.List<api.UrlChannel> o) {
unittest.expect(o, unittest.hasLength(2));
checkUrlChannel(o[0]);
checkUrlChannel(o[1]);
}
core.int buildCounterListUrlChannelsResponse = 0;
api.ListUrlChannelsResponse buildListUrlChannelsResponse() {
final o = api.ListUrlChannelsResponse();
buildCounterListUrlChannelsResponse++;
if (buildCounterListUrlChannelsResponse < 3) {
o.nextPageToken = 'foo';
o.urlChannels = buildUnnamed14();
}
buildCounterListUrlChannelsResponse--;
return o;
}
void checkListUrlChannelsResponse(api.ListUrlChannelsResponse o) {
buildCounterListUrlChannelsResponse++;
if (buildCounterListUrlChannelsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed14(o.urlChannels!);
}
buildCounterListUrlChannelsResponse--;
}
core.int buildCounterPayment = 0;
api.Payment buildPayment() {
final o = api.Payment();
buildCounterPayment++;
if (buildCounterPayment < 3) {
o.amount = 'foo';
o.date = buildDate();
o.name = 'foo';
}
buildCounterPayment--;
return o;
}
void checkPayment(api.Payment o) {
buildCounterPayment++;
if (buildCounterPayment < 3) {
unittest.expect(
o.amount!,
unittest.equals('foo'),
);
checkDate(o.date!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterPayment--;
}
core.List<api.Header> buildUnnamed15() => [
buildHeader(),
buildHeader(),
];
void checkUnnamed15(core.List<api.Header> o) {
unittest.expect(o, unittest.hasLength(2));
checkHeader(o[0]);
checkHeader(o[1]);
}
core.List<api.Row> buildUnnamed16() => [
buildRow(),
buildRow(),
];
void checkUnnamed16(core.List<api.Row> o) {
unittest.expect(o, unittest.hasLength(2));
checkRow(o[0]);
checkRow(o[1]);
}
core.List<core.String> buildUnnamed17() => [
'foo',
'foo',
];
void checkUnnamed17(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportResult = 0;
api.ReportResult buildReportResult() {
final o = api.ReportResult();
buildCounterReportResult++;
if (buildCounterReportResult < 3) {
o.averages = buildRow();
o.endDate = buildDate();
o.headers = buildUnnamed15();
o.rows = buildUnnamed16();
o.startDate = buildDate();
o.totalMatchedRows = 'foo';
o.totals = buildRow();
o.warnings = buildUnnamed17();
}
buildCounterReportResult--;
return o;
}
void checkReportResult(api.ReportResult o) {
buildCounterReportResult++;
if (buildCounterReportResult < 3) {
checkRow(o.averages!);
checkDate(o.endDate!);
checkUnnamed15(o.headers!);
checkUnnamed16(o.rows!);
checkDate(o.startDate!);
unittest.expect(
o.totalMatchedRows!,
unittest.equals('foo'),
);
checkRow(o.totals!);
checkUnnamed17(o.warnings!);
}
buildCounterReportResult--;
}
core.List<api.Cell> buildUnnamed18() => [
buildCell(),
buildCell(),
];
void checkUnnamed18(core.List<api.Cell> o) {
unittest.expect(o, unittest.hasLength(2));
checkCell(o[0]);
checkCell(o[1]);
}
core.int buildCounterRow = 0;
api.Row buildRow() {
final o = api.Row();
buildCounterRow++;
if (buildCounterRow < 3) {
o.cells = buildUnnamed18();
}
buildCounterRow--;
return o;
}
void checkRow(api.Row o) {
buildCounterRow++;
if (buildCounterRow < 3) {
checkUnnamed18(o.cells!);
}
buildCounterRow--;
}
core.int buildCounterSavedReport = 0;
api.SavedReport buildSavedReport() {
final o = api.SavedReport();
buildCounterSavedReport++;
if (buildCounterSavedReport < 3) {
o.name = 'foo';
o.title = 'foo';
}
buildCounterSavedReport--;
return o;
}
void checkSavedReport(api.SavedReport o) {
buildCounterSavedReport++;
if (buildCounterSavedReport < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterSavedReport--;
}
core.int buildCounterSite = 0;
api.Site buildSite() {
final o = api.Site();
buildCounterSite++;
if (buildCounterSite < 3) {
o.autoAdsEnabled = true;
o.domain = 'foo';
o.name = 'foo';
o.reportingDimensionId = 'foo';
o.state = 'foo';
}
buildCounterSite--;
return o;
}
void checkSite(api.Site o) {
buildCounterSite++;
if (buildCounterSite < 3) {
unittest.expect(o.autoAdsEnabled!, unittest.isTrue);
unittest.expect(
o.domain!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.reportingDimensionId!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterSite--;
}
core.int buildCounterTimeZone = 0;
api.TimeZone buildTimeZone() {
final o = api.TimeZone();
buildCounterTimeZone++;
if (buildCounterTimeZone < 3) {
o.id = 'foo';
o.version = 'foo';
}
buildCounterTimeZone--;
return o;
}
void checkTimeZone(api.TimeZone o) {
buildCounterTimeZone++;
if (buildCounterTimeZone < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterTimeZone--;
}
core.int buildCounterUrlChannel = 0;
api.UrlChannel buildUrlChannel() {
final o = api.UrlChannel();
buildCounterUrlChannel++;
if (buildCounterUrlChannel < 3) {
o.name = 'foo';
o.reportingDimensionId = 'foo';
o.uriPattern = 'foo';
}
buildCounterUrlChannel--;
return o;
}
void checkUrlChannel(api.UrlChannel o) {
buildCounterUrlChannel++;
if (buildCounterUrlChannel < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.reportingDimensionId!,
unittest.equals('foo'),
);
unittest.expect(
o.uriPattern!,
unittest.equals('foo'),
);
}
buildCounterUrlChannel--;
}
core.List<core.String> buildUnnamed19() => [
'foo',
'foo',
];
void checkUnnamed19(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed20() => [
'foo',
'foo',
];
void checkUnnamed20(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed21() => [
'foo',
'foo',
];
void checkUnnamed21(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed22() => [
'foo',
'foo',
];
void checkUnnamed22(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed23() => [
'foo',
'foo',
];
void checkUnnamed23(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed24() => [
'foo',
'foo',
];
void checkUnnamed24(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed25() => [
'foo',
'foo',
];
void checkUnnamed25(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed26() => [
'foo',
'foo',
];
void checkUnnamed26(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
void main() {
unittest.group('obj-schema-Account', () {
unittest.test('to-json--from-json', () async {
final o = buildAccount();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Account.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAccount(od);
});
});
unittest.group('obj-schema-AdBlockingRecoveryTag', () {
unittest.test('to-json--from-json', () async {
final o = buildAdBlockingRecoveryTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdBlockingRecoveryTag.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdBlockingRecoveryTag(od);
});
});
unittest.group('obj-schema-AdClient', () {
unittest.test('to-json--from-json', () async {
final o = buildAdClient();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.AdClient.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAdClient(od);
});
});
unittest.group('obj-schema-AdClientAdCode', () {
unittest.test('to-json--from-json', () async {
final o = buildAdClientAdCode();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdClientAdCode.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdClientAdCode(od);
});
});
unittest.group('obj-schema-AdUnit', () {
unittest.test('to-json--from-json', () async {
final o = buildAdUnit();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.AdUnit.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAdUnit(od);
});
});
unittest.group('obj-schema-AdUnitAdCode', () {
unittest.test('to-json--from-json', () async {
final o = buildAdUnitAdCode();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdUnitAdCode.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdUnitAdCode(od);
});
});
unittest.group('obj-schema-Alert', () {
unittest.test('to-json--from-json', () async {
final o = buildAlert();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Alert.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAlert(od);
});
});
unittest.group('obj-schema-Cell', () {
unittest.test('to-json--from-json', () async {
final o = buildCell();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Cell.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCell(od);
});
});
unittest.group('obj-schema-ContentAdsSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildContentAdsSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ContentAdsSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkContentAdsSettings(od);
});
});
unittest.group('obj-schema-CustomChannel', () {
unittest.test('to-json--from-json', () async {
final o = buildCustomChannel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CustomChannel.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCustomChannel(od);
});
});
unittest.group('obj-schema-Date', () {
unittest.test('to-json--from-json', () async {
final o = buildDate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Date.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDate(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-Header', () {
unittest.test('to-json--from-json', () async {
final o = buildHeader();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Header.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkHeader(od);
});
});
unittest.group('obj-schema-HttpBody', () {
unittest.test('to-json--from-json', () async {
final o = buildHttpBody();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.HttpBody.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkHttpBody(od);
});
});
unittest.group('obj-schema-ListAccountsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListAccountsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListAccountsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListAccountsResponse(od);
});
});
unittest.group('obj-schema-ListAdClientsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListAdClientsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListAdClientsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListAdClientsResponse(od);
});
});
unittest.group('obj-schema-ListAdUnitsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListAdUnitsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListAdUnitsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListAdUnitsResponse(od);
});
});
unittest.group('obj-schema-ListAlertsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListAlertsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListAlertsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListAlertsResponse(od);
});
});
unittest.group('obj-schema-ListChildAccountsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListChildAccountsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListChildAccountsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListChildAccountsResponse(od);
});
});
unittest.group('obj-schema-ListCustomChannelsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListCustomChannelsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListCustomChannelsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListCustomChannelsResponse(od);
});
});
unittest.group('obj-schema-ListLinkedAdUnitsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLinkedAdUnitsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLinkedAdUnitsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLinkedAdUnitsResponse(od);
});
});
unittest.group('obj-schema-ListLinkedCustomChannelsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLinkedCustomChannelsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLinkedCustomChannelsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLinkedCustomChannelsResponse(od);
});
});
unittest.group('obj-schema-ListPaymentsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListPaymentsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPaymentsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPaymentsResponse(od);
});
});
unittest.group('obj-schema-ListSavedReportsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListSavedReportsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListSavedReportsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListSavedReportsResponse(od);
});
});
unittest.group('obj-schema-ListSitesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListSitesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListSitesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListSitesResponse(od);
});
});
unittest.group('obj-schema-ListUrlChannelsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListUrlChannelsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListUrlChannelsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListUrlChannelsResponse(od);
});
});
unittest.group('obj-schema-Payment', () {
unittest.test('to-json--from-json', () async {
final o = buildPayment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Payment.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPayment(od);
});
});
unittest.group('obj-schema-ReportResult', () {
unittest.test('to-json--from-json', () async {
final o = buildReportResult();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportResult.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportResult(od);
});
});
unittest.group('obj-schema-Row', () {
unittest.test('to-json--from-json', () async {
final o = buildRow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Row.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRow(od);
});
});
unittest.group('obj-schema-SavedReport', () {
unittest.test('to-json--from-json', () async {
final o = buildSavedReport();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SavedReport.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSavedReport(od);
});
});
unittest.group('obj-schema-Site', () {
unittest.test('to-json--from-json', () async {
final o = buildSite();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Site.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSite(od);
});
});
unittest.group('obj-schema-TimeZone', () {
unittest.test('to-json--from-json', () async {
final o = buildTimeZone();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TimeZone.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTimeZone(od);
});
});
unittest.group('obj-schema-UrlChannel', () {
unittest.test('to-json--from-json', () async {
final o = buildUrlChannel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.UrlChannel.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkUrlChannel(od);
});
});
unittest.group('resource-AccountsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkAccount(response as api.Account);
});
unittest.test('method--getAdBlockingRecoveryTag', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdBlockingRecoveryTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getAdBlockingRecoveryTag(arg_name, $fields: arg_$fields);
checkAdBlockingRecoveryTag(response as api.AdBlockingRecoveryTag);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('v2/accounts'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListAccountsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListAccountsResponse(response as api.ListAccountsResponse);
});
unittest.test('method--listChildAccounts', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListChildAccountsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.listChildAccounts(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListChildAccountsResponse(response as api.ListChildAccountsResponse);
});
});
unittest.group('resource-AccountsAdclientsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdClient());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkAdClient(response as api.AdClient);
});
unittest.test('method--getAdcode', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdClientAdCode());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getAdcode(arg_name, $fields: arg_$fields);
checkAdClientAdCode(response as api.AdClientAdCode);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListAdClientsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListAdClientsResponse(response as api.ListAdClientsResponse);
});
});
unittest.group('resource-AccountsAdclientsAdunitsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_request = buildAdUnit();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.AdUnit.fromJson(json as core.Map<core.String, core.dynamic>);
checkAdUnit(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdUnit());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkAdUnit(response as api.AdUnit);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdUnit());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkAdUnit(response as api.AdUnit);
});
unittest.test('method--getAdcode', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdUnitAdCode());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getAdcode(arg_name, $fields: arg_$fields);
checkAdUnitAdCode(response as api.AdUnitAdCode);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListAdUnitsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListAdUnitsResponse(response as api.ListAdUnitsResponse);
});
unittest.test('method--listLinkedCustomChannels', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildListLinkedCustomChannelsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.listLinkedCustomChannels(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinkedCustomChannelsResponse(
response as api.ListLinkedCustomChannelsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.adunits;
final arg_request = buildAdUnit();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.AdUnit.fromJson(json as core.Map<core.String, core.dynamic>);
checkAdUnit(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdUnit());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkAdUnit(response as api.AdUnit);
});
});
unittest.group('resource-AccountsAdclientsCustomchannelsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_request = buildCustomChannel();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CustomChannel.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCustomChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCustomChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkCustomChannel(response as api.CustomChannel);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCustomChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkCustomChannel(response as api.CustomChannel);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListCustomChannelsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListCustomChannelsResponse(
response as api.ListCustomChannelsResponse);
});
unittest.test('method--listLinkedAdUnits', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinkedAdUnitsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.listLinkedAdUnits(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinkedAdUnitsResponse(response as api.ListLinkedAdUnitsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.customchannels;
final arg_request = buildCustomChannel();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CustomChannel.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCustomChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCustomChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkCustomChannel(response as api.CustomChannel);
});
});
unittest.group('resource-AccountsAdclientsUrlchannelsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.urlchannels;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUrlChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkUrlChannel(response as api.UrlChannel);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.adclients.urlchannels;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListUrlChannelsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListUrlChannelsResponse(response as api.ListUrlChannelsResponse);
});
});
unittest.group('resource-AccountsAlertsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.alerts;
final arg_parent = 'foo';
final arg_languageCode = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['languageCode']!.first,
unittest.equals(arg_languageCode),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListAlertsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
languageCode: arg_languageCode, $fields: arg_$fields);
checkListAlertsResponse(response as api.ListAlertsResponse);
});
});
unittest.group('resource-AccountsPaymentsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.payments;
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListPaymentsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent, $fields: arg_$fields);
checkListPaymentsResponse(response as api.ListPaymentsResponse);
});
});
unittest.group('resource-AccountsReportsResource', () {
unittest.test('method--generate', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports;
final arg_account = 'foo';
final arg_currencyCode = 'foo';
final arg_dateRange = 'foo';
final arg_dimensions = buildUnnamed19();
final arg_endDate_day = 42;
final arg_endDate_month = 42;
final arg_endDate_year = 42;
final arg_filters = buildUnnamed20();
final arg_languageCode = 'foo';
final arg_limit = 42;
final arg_metrics = buildUnnamed21();
final arg_orderBy = buildUnnamed22();
final arg_reportingTimeZone = 'foo';
final arg_startDate_day = 42;
final arg_startDate_month = 42;
final arg_startDate_year = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['currencyCode']!.first,
unittest.equals(arg_currencyCode),
);
unittest.expect(
queryMap['dateRange']!.first,
unittest.equals(arg_dateRange),
);
unittest.expect(
queryMap['dimensions']!,
unittest.equals(arg_dimensions),
);
unittest.expect(
core.int.parse(queryMap['endDate.day']!.first),
unittest.equals(arg_endDate_day),
);
unittest.expect(
core.int.parse(queryMap['endDate.month']!.first),
unittest.equals(arg_endDate_month),
);
unittest.expect(
core.int.parse(queryMap['endDate.year']!.first),
unittest.equals(arg_endDate_year),
);
unittest.expect(
queryMap['filters']!,
unittest.equals(arg_filters),
);
unittest.expect(
queryMap['languageCode']!.first,
unittest.equals(arg_languageCode),
);
unittest.expect(
core.int.parse(queryMap['limit']!.first),
unittest.equals(arg_limit),
);
unittest.expect(
queryMap['metrics']!,
unittest.equals(arg_metrics),
);
unittest.expect(
queryMap['orderBy']!,
unittest.equals(arg_orderBy),
);
unittest.expect(
queryMap['reportingTimeZone']!.first,
unittest.equals(arg_reportingTimeZone),
);
unittest.expect(
core.int.parse(queryMap['startDate.day']!.first),
unittest.equals(arg_startDate_day),
);
unittest.expect(
core.int.parse(queryMap['startDate.month']!.first),
unittest.equals(arg_startDate_month),
);
unittest.expect(
core.int.parse(queryMap['startDate.year']!.first),
unittest.equals(arg_startDate_year),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReportResult());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generate(arg_account,
currencyCode: arg_currencyCode,
dateRange: arg_dateRange,
dimensions: arg_dimensions,
endDate_day: arg_endDate_day,
endDate_month: arg_endDate_month,
endDate_year: arg_endDate_year,
filters: arg_filters,
languageCode: arg_languageCode,
limit: arg_limit,
metrics: arg_metrics,
orderBy: arg_orderBy,
reportingTimeZone: arg_reportingTimeZone,
startDate_day: arg_startDate_day,
startDate_month: arg_startDate_month,
startDate_year: arg_startDate_year,
$fields: arg_$fields);
checkReportResult(response as api.ReportResult);
});
unittest.test('method--generateCsv', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports;
final arg_account = 'foo';
final arg_currencyCode = 'foo';
final arg_dateRange = 'foo';
final arg_dimensions = buildUnnamed23();
final arg_endDate_day = 42;
final arg_endDate_month = 42;
final arg_endDate_year = 42;
final arg_filters = buildUnnamed24();
final arg_languageCode = 'foo';
final arg_limit = 42;
final arg_metrics = buildUnnamed25();
final arg_orderBy = buildUnnamed26();
final arg_reportingTimeZone = 'foo';
final arg_startDate_day = 42;
final arg_startDate_month = 42;
final arg_startDate_year = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['currencyCode']!.first,
unittest.equals(arg_currencyCode),
);
unittest.expect(
queryMap['dateRange']!.first,
unittest.equals(arg_dateRange),
);
unittest.expect(
queryMap['dimensions']!,
unittest.equals(arg_dimensions),
);
unittest.expect(
core.int.parse(queryMap['endDate.day']!.first),
unittest.equals(arg_endDate_day),
);
unittest.expect(
core.int.parse(queryMap['endDate.month']!.first),
unittest.equals(arg_endDate_month),
);
unittest.expect(
core.int.parse(queryMap['endDate.year']!.first),
unittest.equals(arg_endDate_year),
);
unittest.expect(
queryMap['filters']!,
unittest.equals(arg_filters),
);
unittest.expect(
queryMap['languageCode']!.first,
unittest.equals(arg_languageCode),
);
unittest.expect(
core.int.parse(queryMap['limit']!.first),
unittest.equals(arg_limit),
);
unittest.expect(
queryMap['metrics']!,
unittest.equals(arg_metrics),
);
unittest.expect(
queryMap['orderBy']!,
unittest.equals(arg_orderBy),
);
unittest.expect(
queryMap['reportingTimeZone']!.first,
unittest.equals(arg_reportingTimeZone),
);
unittest.expect(
core.int.parse(queryMap['startDate.day']!.first),
unittest.equals(arg_startDate_day),
);
unittest.expect(
core.int.parse(queryMap['startDate.month']!.first),
unittest.equals(arg_startDate_month),
);
unittest.expect(
core.int.parse(queryMap['startDate.year']!.first),
unittest.equals(arg_startDate_year),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildHttpBody());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateCsv(arg_account,
currencyCode: arg_currencyCode,
dateRange: arg_dateRange,
dimensions: arg_dimensions,
endDate_day: arg_endDate_day,
endDate_month: arg_endDate_month,
endDate_year: arg_endDate_year,
filters: arg_filters,
languageCode: arg_languageCode,
limit: arg_limit,
metrics: arg_metrics,
orderBy: arg_orderBy,
reportingTimeZone: arg_reportingTimeZone,
startDate_day: arg_startDate_day,
startDate_month: arg_startDate_month,
startDate_year: arg_startDate_year,
$fields: arg_$fields);
checkHttpBody(response as api.HttpBody);
});
unittest.test('method--getSaved', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSavedReport());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSaved(arg_name, $fields: arg_$fields);
checkSavedReport(response as api.SavedReport);
});
});
unittest.group('resource-AccountsReportsSavedResource', () {
unittest.test('method--generate', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports.saved;
final arg_name = 'foo';
final arg_currencyCode = 'foo';
final arg_dateRange = 'foo';
final arg_endDate_day = 42;
final arg_endDate_month = 42;
final arg_endDate_year = 42;
final arg_languageCode = 'foo';
final arg_reportingTimeZone = 'foo';
final arg_startDate_day = 42;
final arg_startDate_month = 42;
final arg_startDate_year = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['currencyCode']!.first,
unittest.equals(arg_currencyCode),
);
unittest.expect(
queryMap['dateRange']!.first,
unittest.equals(arg_dateRange),
);
unittest.expect(
core.int.parse(queryMap['endDate.day']!.first),
unittest.equals(arg_endDate_day),
);
unittest.expect(
core.int.parse(queryMap['endDate.month']!.first),
unittest.equals(arg_endDate_month),
);
unittest.expect(
core.int.parse(queryMap['endDate.year']!.first),
unittest.equals(arg_endDate_year),
);
unittest.expect(
queryMap['languageCode']!.first,
unittest.equals(arg_languageCode),
);
unittest.expect(
queryMap['reportingTimeZone']!.first,
unittest.equals(arg_reportingTimeZone),
);
unittest.expect(
core.int.parse(queryMap['startDate.day']!.first),
unittest.equals(arg_startDate_day),
);
unittest.expect(
core.int.parse(queryMap['startDate.month']!.first),
unittest.equals(arg_startDate_month),
);
unittest.expect(
core.int.parse(queryMap['startDate.year']!.first),
unittest.equals(arg_startDate_year),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReportResult());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generate(arg_name,
currencyCode: arg_currencyCode,
dateRange: arg_dateRange,
endDate_day: arg_endDate_day,
endDate_month: arg_endDate_month,
endDate_year: arg_endDate_year,
languageCode: arg_languageCode,
reportingTimeZone: arg_reportingTimeZone,
startDate_day: arg_startDate_day,
startDate_month: arg_startDate_month,
startDate_year: arg_startDate_year,
$fields: arg_$fields);
checkReportResult(response as api.ReportResult);
});
unittest.test('method--generateCsv', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports.saved;
final arg_name = 'foo';
final arg_currencyCode = 'foo';
final arg_dateRange = 'foo';
final arg_endDate_day = 42;
final arg_endDate_month = 42;
final arg_endDate_year = 42;
final arg_languageCode = 'foo';
final arg_reportingTimeZone = 'foo';
final arg_startDate_day = 42;
final arg_startDate_month = 42;
final arg_startDate_year = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['currencyCode']!.first,
unittest.equals(arg_currencyCode),
);
unittest.expect(
queryMap['dateRange']!.first,
unittest.equals(arg_dateRange),
);
unittest.expect(
core.int.parse(queryMap['endDate.day']!.first),
unittest.equals(arg_endDate_day),
);
unittest.expect(
core.int.parse(queryMap['endDate.month']!.first),
unittest.equals(arg_endDate_month),
);
unittest.expect(
core.int.parse(queryMap['endDate.year']!.first),
unittest.equals(arg_endDate_year),
);
unittest.expect(
queryMap['languageCode']!.first,
unittest.equals(arg_languageCode),
);
unittest.expect(
queryMap['reportingTimeZone']!.first,
unittest.equals(arg_reportingTimeZone),
);
unittest.expect(
core.int.parse(queryMap['startDate.day']!.first),
unittest.equals(arg_startDate_day),
);
unittest.expect(
core.int.parse(queryMap['startDate.month']!.first),
unittest.equals(arg_startDate_month),
);
unittest.expect(
core.int.parse(queryMap['startDate.year']!.first),
unittest.equals(arg_startDate_year),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildHttpBody());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateCsv(arg_name,
currencyCode: arg_currencyCode,
dateRange: arg_dateRange,
endDate_day: arg_endDate_day,
endDate_month: arg_endDate_month,
endDate_year: arg_endDate_year,
languageCode: arg_languageCode,
reportingTimeZone: arg_reportingTimeZone,
startDate_day: arg_startDate_day,
startDate_month: arg_startDate_month,
startDate_year: arg_startDate_year,
$fields: arg_$fields);
checkHttpBody(response as api.HttpBody);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.reports.saved;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSavedReportsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSavedReportsResponse(response as api.ListSavedReportsResponse);
});
});
unittest.group('resource-AccountsSitesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.sites;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkSite(response as api.Site);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.AdsenseApi(mock).accounts.sites;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSitesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSitesResponse(response as api.ListSitesResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/adsense/v2_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/adsense/v2_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 52201}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/artifactregistry/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterBatchDeleteVersionsRequest = 0;
api.BatchDeleteVersionsRequest buildBatchDeleteVersionsRequest() {
final o = api.BatchDeleteVersionsRequest();
buildCounterBatchDeleteVersionsRequest++;
if (buildCounterBatchDeleteVersionsRequest < 3) {
o.names = buildUnnamed0();
o.validateOnly = true;
}
buildCounterBatchDeleteVersionsRequest--;
return o;
}
void checkBatchDeleteVersionsRequest(api.BatchDeleteVersionsRequest o) {
buildCounterBatchDeleteVersionsRequest++;
if (buildCounterBatchDeleteVersionsRequest < 3) {
checkUnnamed0(o.names!);
unittest.expect(o.validateOnly!, unittest.isTrue);
}
buildCounterBatchDeleteVersionsRequest--;
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterBinding = 0;
api.Binding buildBinding() {
final o = api.Binding();
buildCounterBinding++;
if (buildCounterBinding < 3) {
o.condition = buildExpr();
o.members = buildUnnamed1();
o.role = 'foo';
}
buildCounterBinding--;
return o;
}
void checkBinding(api.Binding o) {
buildCounterBinding++;
if (buildCounterBinding < 3) {
checkExpr(o.condition!);
checkUnnamed1(o.members!);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
}
buildCounterBinding--;
}
core.int buildCounterCleanupPolicy = 0;
api.CleanupPolicy buildCleanupPolicy() {
final o = api.CleanupPolicy();
buildCounterCleanupPolicy++;
if (buildCounterCleanupPolicy < 3) {
o.action = 'foo';
o.condition = buildCleanupPolicyCondition();
o.id = 'foo';
o.mostRecentVersions = buildCleanupPolicyMostRecentVersions();
}
buildCounterCleanupPolicy--;
return o;
}
void checkCleanupPolicy(api.CleanupPolicy o) {
buildCounterCleanupPolicy++;
if (buildCounterCleanupPolicy < 3) {
unittest.expect(
o.action!,
unittest.equals('foo'),
);
checkCleanupPolicyCondition(o.condition!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkCleanupPolicyMostRecentVersions(o.mostRecentVersions!);
}
buildCounterCleanupPolicy--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCleanupPolicyCondition = 0;
api.CleanupPolicyCondition buildCleanupPolicyCondition() {
final o = api.CleanupPolicyCondition();
buildCounterCleanupPolicyCondition++;
if (buildCounterCleanupPolicyCondition < 3) {
o.newerThan = 'foo';
o.olderThan = 'foo';
o.packageNamePrefixes = buildUnnamed2();
o.tagPrefixes = buildUnnamed3();
o.tagState = 'foo';
o.versionAge = 'foo';
o.versionNamePrefixes = buildUnnamed4();
}
buildCounterCleanupPolicyCondition--;
return o;
}
void checkCleanupPolicyCondition(api.CleanupPolicyCondition o) {
buildCounterCleanupPolicyCondition++;
if (buildCounterCleanupPolicyCondition < 3) {
unittest.expect(
o.newerThan!,
unittest.equals('foo'),
);
unittest.expect(
o.olderThan!,
unittest.equals('foo'),
);
checkUnnamed2(o.packageNamePrefixes!);
checkUnnamed3(o.tagPrefixes!);
unittest.expect(
o.tagState!,
unittest.equals('foo'),
);
unittest.expect(
o.versionAge!,
unittest.equals('foo'),
);
checkUnnamed4(o.versionNamePrefixes!);
}
buildCounterCleanupPolicyCondition--;
}
core.List<core.String> buildUnnamed5() => [
'foo',
'foo',
];
void checkUnnamed5(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCleanupPolicyMostRecentVersions = 0;
api.CleanupPolicyMostRecentVersions buildCleanupPolicyMostRecentVersions() {
final o = api.CleanupPolicyMostRecentVersions();
buildCounterCleanupPolicyMostRecentVersions++;
if (buildCounterCleanupPolicyMostRecentVersions < 3) {
o.keepCount = 42;
o.packageNamePrefixes = buildUnnamed5();
}
buildCounterCleanupPolicyMostRecentVersions--;
return o;
}
void checkCleanupPolicyMostRecentVersions(
api.CleanupPolicyMostRecentVersions o) {
buildCounterCleanupPolicyMostRecentVersions++;
if (buildCounterCleanupPolicyMostRecentVersions < 3) {
unittest.expect(
o.keepCount!,
unittest.equals(42),
);
checkUnnamed5(o.packageNamePrefixes!);
}
buildCounterCleanupPolicyMostRecentVersions--;
}
core.List<core.String> buildUnnamed6() => [
'foo',
'foo',
];
void checkUnnamed6(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterDockerImage = 0;
api.DockerImage buildDockerImage() {
final o = api.DockerImage();
buildCounterDockerImage++;
if (buildCounterDockerImage < 3) {
o.buildTime = 'foo';
o.imageSizeBytes = 'foo';
o.mediaType = 'foo';
o.name = 'foo';
o.tags = buildUnnamed6();
o.updateTime = 'foo';
o.uploadTime = 'foo';
o.uri = 'foo';
}
buildCounterDockerImage--;
return o;
}
void checkDockerImage(api.DockerImage o) {
buildCounterDockerImage++;
if (buildCounterDockerImage < 3) {
unittest.expect(
o.buildTime!,
unittest.equals('foo'),
);
unittest.expect(
o.imageSizeBytes!,
unittest.equals('foo'),
);
unittest.expect(
o.mediaType!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed6(o.tags!);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.uploadTime!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterDockerImage--;
}
core.int buildCounterDockerRepository = 0;
api.DockerRepository buildDockerRepository() {
final o = api.DockerRepository();
buildCounterDockerRepository++;
if (buildCounterDockerRepository < 3) {
o.publicRepository = 'foo';
}
buildCounterDockerRepository--;
return o;
}
void checkDockerRepository(api.DockerRepository o) {
buildCounterDockerRepository++;
if (buildCounterDockerRepository < 3) {
unittest.expect(
o.publicRepository!,
unittest.equals('foo'),
);
}
buildCounterDockerRepository--;
}
core.int buildCounterDockerRepositoryConfig = 0;
api.DockerRepositoryConfig buildDockerRepositoryConfig() {
final o = api.DockerRepositoryConfig();
buildCounterDockerRepositoryConfig++;
if (buildCounterDockerRepositoryConfig < 3) {
o.immutableTags = true;
}
buildCounterDockerRepositoryConfig--;
return o;
}
void checkDockerRepositoryConfig(api.DockerRepositoryConfig o) {
buildCounterDockerRepositoryConfig++;
if (buildCounterDockerRepositoryConfig < 3) {
unittest.expect(o.immutableTags!, unittest.isTrue);
}
buildCounterDockerRepositoryConfig--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.int buildCounterExpr = 0;
api.Expr buildExpr() {
final o = api.Expr();
buildCounterExpr++;
if (buildCounterExpr < 3) {
o.description = 'foo';
o.expression = 'foo';
o.location = 'foo';
o.title = 'foo';
}
buildCounterExpr--;
return o;
}
void checkExpr(api.Expr o) {
buildCounterExpr++;
if (buildCounterExpr < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.expression!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterExpr--;
}
core.List<api.Hash> buildUnnamed7() => [
buildHash(),
buildHash(),
];
void checkUnnamed7(core.List<api.Hash> o) {
unittest.expect(o, unittest.hasLength(2));
checkHash(o[0]);
checkHash(o[1]);
}
core.int buildCounterGoogleDevtoolsArtifactregistryV1File = 0;
api.GoogleDevtoolsArtifactregistryV1File
buildGoogleDevtoolsArtifactregistryV1File() {
final o = api.GoogleDevtoolsArtifactregistryV1File();
buildCounterGoogleDevtoolsArtifactregistryV1File++;
if (buildCounterGoogleDevtoolsArtifactregistryV1File < 3) {
o.createTime = 'foo';
o.fetchTime = 'foo';
o.hashes = buildUnnamed7();
o.name = 'foo';
o.owner = 'foo';
o.sizeBytes = 'foo';
o.updateTime = 'foo';
}
buildCounterGoogleDevtoolsArtifactregistryV1File--;
return o;
}
void checkGoogleDevtoolsArtifactregistryV1File(
api.GoogleDevtoolsArtifactregistryV1File o) {
buildCounterGoogleDevtoolsArtifactregistryV1File++;
if (buildCounterGoogleDevtoolsArtifactregistryV1File < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.fetchTime!,
unittest.equals('foo'),
);
checkUnnamed7(o.hashes!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.owner!,
unittest.equals('foo'),
);
unittest.expect(
o.sizeBytes!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterGoogleDevtoolsArtifactregistryV1File--;
}
core.int buildCounterHash = 0;
api.Hash buildHash() {
final o = api.Hash();
buildCounterHash++;
if (buildCounterHash < 3) {
o.type = 'foo';
o.value = 'foo';
}
buildCounterHash--;
return o;
}
void checkHash(api.Hash o) {
buildCounterHash++;
if (buildCounterHash < 3) {
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterHash--;
}
core.List<core.String> buildUnnamed8() => [
'foo',
'foo',
];
void checkUnnamed8(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterImportAptArtifactsGcsSource = 0;
api.ImportAptArtifactsGcsSource buildImportAptArtifactsGcsSource() {
final o = api.ImportAptArtifactsGcsSource();
buildCounterImportAptArtifactsGcsSource++;
if (buildCounterImportAptArtifactsGcsSource < 3) {
o.uris = buildUnnamed8();
o.useWildcards = true;
}
buildCounterImportAptArtifactsGcsSource--;
return o;
}
void checkImportAptArtifactsGcsSource(api.ImportAptArtifactsGcsSource o) {
buildCounterImportAptArtifactsGcsSource++;
if (buildCounterImportAptArtifactsGcsSource < 3) {
checkUnnamed8(o.uris!);
unittest.expect(o.useWildcards!, unittest.isTrue);
}
buildCounterImportAptArtifactsGcsSource--;
}
core.int buildCounterImportAptArtifactsRequest = 0;
api.ImportAptArtifactsRequest buildImportAptArtifactsRequest() {
final o = api.ImportAptArtifactsRequest();
buildCounterImportAptArtifactsRequest++;
if (buildCounterImportAptArtifactsRequest < 3) {
o.gcsSource = buildImportAptArtifactsGcsSource();
}
buildCounterImportAptArtifactsRequest--;
return o;
}
void checkImportAptArtifactsRequest(api.ImportAptArtifactsRequest o) {
buildCounterImportAptArtifactsRequest++;
if (buildCounterImportAptArtifactsRequest < 3) {
checkImportAptArtifactsGcsSource(o.gcsSource!);
}
buildCounterImportAptArtifactsRequest--;
}
core.List<core.String> buildUnnamed9() => [
'foo',
'foo',
];
void checkUnnamed9(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterImportGoogetArtifactsGcsSource = 0;
api.ImportGoogetArtifactsGcsSource buildImportGoogetArtifactsGcsSource() {
final o = api.ImportGoogetArtifactsGcsSource();
buildCounterImportGoogetArtifactsGcsSource++;
if (buildCounterImportGoogetArtifactsGcsSource < 3) {
o.uris = buildUnnamed9();
o.useWildcards = true;
}
buildCounterImportGoogetArtifactsGcsSource--;
return o;
}
void checkImportGoogetArtifactsGcsSource(api.ImportGoogetArtifactsGcsSource o) {
buildCounterImportGoogetArtifactsGcsSource++;
if (buildCounterImportGoogetArtifactsGcsSource < 3) {
checkUnnamed9(o.uris!);
unittest.expect(o.useWildcards!, unittest.isTrue);
}
buildCounterImportGoogetArtifactsGcsSource--;
}
core.int buildCounterImportGoogetArtifactsRequest = 0;
api.ImportGoogetArtifactsRequest buildImportGoogetArtifactsRequest() {
final o = api.ImportGoogetArtifactsRequest();
buildCounterImportGoogetArtifactsRequest++;
if (buildCounterImportGoogetArtifactsRequest < 3) {
o.gcsSource = buildImportGoogetArtifactsGcsSource();
}
buildCounterImportGoogetArtifactsRequest--;
return o;
}
void checkImportGoogetArtifactsRequest(api.ImportGoogetArtifactsRequest o) {
buildCounterImportGoogetArtifactsRequest++;
if (buildCounterImportGoogetArtifactsRequest < 3) {
checkImportGoogetArtifactsGcsSource(o.gcsSource!);
}
buildCounterImportGoogetArtifactsRequest--;
}
core.List<core.String> buildUnnamed10() => [
'foo',
'foo',
];
void checkUnnamed10(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterImportYumArtifactsGcsSource = 0;
api.ImportYumArtifactsGcsSource buildImportYumArtifactsGcsSource() {
final o = api.ImportYumArtifactsGcsSource();
buildCounterImportYumArtifactsGcsSource++;
if (buildCounterImportYumArtifactsGcsSource < 3) {
o.uris = buildUnnamed10();
o.useWildcards = true;
}
buildCounterImportYumArtifactsGcsSource--;
return o;
}
void checkImportYumArtifactsGcsSource(api.ImportYumArtifactsGcsSource o) {
buildCounterImportYumArtifactsGcsSource++;
if (buildCounterImportYumArtifactsGcsSource < 3) {
checkUnnamed10(o.uris!);
unittest.expect(o.useWildcards!, unittest.isTrue);
}
buildCounterImportYumArtifactsGcsSource--;
}
core.int buildCounterImportYumArtifactsRequest = 0;
api.ImportYumArtifactsRequest buildImportYumArtifactsRequest() {
final o = api.ImportYumArtifactsRequest();
buildCounterImportYumArtifactsRequest++;
if (buildCounterImportYumArtifactsRequest < 3) {
o.gcsSource = buildImportYumArtifactsGcsSource();
}
buildCounterImportYumArtifactsRequest--;
return o;
}
void checkImportYumArtifactsRequest(api.ImportYumArtifactsRequest o) {
buildCounterImportYumArtifactsRequest++;
if (buildCounterImportYumArtifactsRequest < 3) {
checkImportYumArtifactsGcsSource(o.gcsSource!);
}
buildCounterImportYumArtifactsRequest--;
}
core.List<api.DockerImage> buildUnnamed11() => [
buildDockerImage(),
buildDockerImage(),
];
void checkUnnamed11(core.List<api.DockerImage> o) {
unittest.expect(o, unittest.hasLength(2));
checkDockerImage(o[0]);
checkDockerImage(o[1]);
}
core.int buildCounterListDockerImagesResponse = 0;
api.ListDockerImagesResponse buildListDockerImagesResponse() {
final o = api.ListDockerImagesResponse();
buildCounterListDockerImagesResponse++;
if (buildCounterListDockerImagesResponse < 3) {
o.dockerImages = buildUnnamed11();
o.nextPageToken = 'foo';
}
buildCounterListDockerImagesResponse--;
return o;
}
void checkListDockerImagesResponse(api.ListDockerImagesResponse o) {
buildCounterListDockerImagesResponse++;
if (buildCounterListDockerImagesResponse < 3) {
checkUnnamed11(o.dockerImages!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListDockerImagesResponse--;
}
core.List<api.GoogleDevtoolsArtifactregistryV1File> buildUnnamed12() => [
buildGoogleDevtoolsArtifactregistryV1File(),
buildGoogleDevtoolsArtifactregistryV1File(),
];
void checkUnnamed12(core.List<api.GoogleDevtoolsArtifactregistryV1File> o) {
unittest.expect(o, unittest.hasLength(2));
checkGoogleDevtoolsArtifactregistryV1File(o[0]);
checkGoogleDevtoolsArtifactregistryV1File(o[1]);
}
core.int buildCounterListFilesResponse = 0;
api.ListFilesResponse buildListFilesResponse() {
final o = api.ListFilesResponse();
buildCounterListFilesResponse++;
if (buildCounterListFilesResponse < 3) {
o.files = buildUnnamed12();
o.nextPageToken = 'foo';
}
buildCounterListFilesResponse--;
return o;
}
void checkListFilesResponse(api.ListFilesResponse o) {
buildCounterListFilesResponse++;
if (buildCounterListFilesResponse < 3) {
checkUnnamed12(o.files!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListFilesResponse--;
}
core.List<api.Location> buildUnnamed13() => [
buildLocation(),
buildLocation(),
];
void checkUnnamed13(core.List<api.Location> o) {
unittest.expect(o, unittest.hasLength(2));
checkLocation(o[0]);
checkLocation(o[1]);
}
core.int buildCounterListLocationsResponse = 0;
api.ListLocationsResponse buildListLocationsResponse() {
final o = api.ListLocationsResponse();
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
o.locations = buildUnnamed13();
o.nextPageToken = 'foo';
}
buildCounterListLocationsResponse--;
return o;
}
void checkListLocationsResponse(api.ListLocationsResponse o) {
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
checkUnnamed13(o.locations!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLocationsResponse--;
}
core.List<api.MavenArtifact> buildUnnamed14() => [
buildMavenArtifact(),
buildMavenArtifact(),
];
void checkUnnamed14(core.List<api.MavenArtifact> o) {
unittest.expect(o, unittest.hasLength(2));
checkMavenArtifact(o[0]);
checkMavenArtifact(o[1]);
}
core.int buildCounterListMavenArtifactsResponse = 0;
api.ListMavenArtifactsResponse buildListMavenArtifactsResponse() {
final o = api.ListMavenArtifactsResponse();
buildCounterListMavenArtifactsResponse++;
if (buildCounterListMavenArtifactsResponse < 3) {
o.mavenArtifacts = buildUnnamed14();
o.nextPageToken = 'foo';
}
buildCounterListMavenArtifactsResponse--;
return o;
}
void checkListMavenArtifactsResponse(api.ListMavenArtifactsResponse o) {
buildCounterListMavenArtifactsResponse++;
if (buildCounterListMavenArtifactsResponse < 3) {
checkUnnamed14(o.mavenArtifacts!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListMavenArtifactsResponse--;
}
core.List<api.NpmPackage> buildUnnamed15() => [
buildNpmPackage(),
buildNpmPackage(),
];
void checkUnnamed15(core.List<api.NpmPackage> o) {
unittest.expect(o, unittest.hasLength(2));
checkNpmPackage(o[0]);
checkNpmPackage(o[1]);
}
core.int buildCounterListNpmPackagesResponse = 0;
api.ListNpmPackagesResponse buildListNpmPackagesResponse() {
final o = api.ListNpmPackagesResponse();
buildCounterListNpmPackagesResponse++;
if (buildCounterListNpmPackagesResponse < 3) {
o.nextPageToken = 'foo';
o.npmPackages = buildUnnamed15();
}
buildCounterListNpmPackagesResponse--;
return o;
}
void checkListNpmPackagesResponse(api.ListNpmPackagesResponse o) {
buildCounterListNpmPackagesResponse++;
if (buildCounterListNpmPackagesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed15(o.npmPackages!);
}
buildCounterListNpmPackagesResponse--;
}
core.List<api.Package> buildUnnamed16() => [
buildPackage(),
buildPackage(),
];
void checkUnnamed16(core.List<api.Package> o) {
unittest.expect(o, unittest.hasLength(2));
checkPackage(o[0]);
checkPackage(o[1]);
}
core.int buildCounterListPackagesResponse = 0;
api.ListPackagesResponse buildListPackagesResponse() {
final o = api.ListPackagesResponse();
buildCounterListPackagesResponse++;
if (buildCounterListPackagesResponse < 3) {
o.nextPageToken = 'foo';
o.packages = buildUnnamed16();
}
buildCounterListPackagesResponse--;
return o;
}
void checkListPackagesResponse(api.ListPackagesResponse o) {
buildCounterListPackagesResponse++;
if (buildCounterListPackagesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed16(o.packages!);
}
buildCounterListPackagesResponse--;
}
core.List<api.PythonPackage> buildUnnamed17() => [
buildPythonPackage(),
buildPythonPackage(),
];
void checkUnnamed17(core.List<api.PythonPackage> o) {
unittest.expect(o, unittest.hasLength(2));
checkPythonPackage(o[0]);
checkPythonPackage(o[1]);
}
core.int buildCounterListPythonPackagesResponse = 0;
api.ListPythonPackagesResponse buildListPythonPackagesResponse() {
final o = api.ListPythonPackagesResponse();
buildCounterListPythonPackagesResponse++;
if (buildCounterListPythonPackagesResponse < 3) {
o.nextPageToken = 'foo';
o.pythonPackages = buildUnnamed17();
}
buildCounterListPythonPackagesResponse--;
return o;
}
void checkListPythonPackagesResponse(api.ListPythonPackagesResponse o) {
buildCounterListPythonPackagesResponse++;
if (buildCounterListPythonPackagesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed17(o.pythonPackages!);
}
buildCounterListPythonPackagesResponse--;
}
core.List<api.Repository> buildUnnamed18() => [
buildRepository(),
buildRepository(),
];
void checkUnnamed18(core.List<api.Repository> o) {
unittest.expect(o, unittest.hasLength(2));
checkRepository(o[0]);
checkRepository(o[1]);
}
core.int buildCounterListRepositoriesResponse = 0;
api.ListRepositoriesResponse buildListRepositoriesResponse() {
final o = api.ListRepositoriesResponse();
buildCounterListRepositoriesResponse++;
if (buildCounterListRepositoriesResponse < 3) {
o.nextPageToken = 'foo';
o.repositories = buildUnnamed18();
}
buildCounterListRepositoriesResponse--;
return o;
}
void checkListRepositoriesResponse(api.ListRepositoriesResponse o) {
buildCounterListRepositoriesResponse++;
if (buildCounterListRepositoriesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed18(o.repositories!);
}
buildCounterListRepositoriesResponse--;
}
core.List<api.Tag> buildUnnamed19() => [
buildTag(),
buildTag(),
];
void checkUnnamed19(core.List<api.Tag> o) {
unittest.expect(o, unittest.hasLength(2));
checkTag(o[0]);
checkTag(o[1]);
}
core.int buildCounterListTagsResponse = 0;
api.ListTagsResponse buildListTagsResponse() {
final o = api.ListTagsResponse();
buildCounterListTagsResponse++;
if (buildCounterListTagsResponse < 3) {
o.nextPageToken = 'foo';
o.tags = buildUnnamed19();
}
buildCounterListTagsResponse--;
return o;
}
void checkListTagsResponse(api.ListTagsResponse o) {
buildCounterListTagsResponse++;
if (buildCounterListTagsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed19(o.tags!);
}
buildCounterListTagsResponse--;
}
core.List<api.Version> buildUnnamed20() => [
buildVersion(),
buildVersion(),
];
void checkUnnamed20(core.List<api.Version> o) {
unittest.expect(o, unittest.hasLength(2));
checkVersion(o[0]);
checkVersion(o[1]);
}
core.int buildCounterListVersionsResponse = 0;
api.ListVersionsResponse buildListVersionsResponse() {
final o = api.ListVersionsResponse();
buildCounterListVersionsResponse++;
if (buildCounterListVersionsResponse < 3) {
o.nextPageToken = 'foo';
o.versions = buildUnnamed20();
}
buildCounterListVersionsResponse--;
return o;
}
void checkListVersionsResponse(api.ListVersionsResponse o) {
buildCounterListVersionsResponse++;
if (buildCounterListVersionsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed20(o.versions!);
}
buildCounterListVersionsResponse--;
}
core.Map<core.String, core.String> buildUnnamed21() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed21(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed22() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed22(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.int buildCounterLocation = 0;
api.Location buildLocation() {
final o = api.Location();
buildCounterLocation++;
if (buildCounterLocation < 3) {
o.displayName = 'foo';
o.labels = buildUnnamed21();
o.locationId = 'foo';
o.metadata = buildUnnamed22();
o.name = 'foo';
}
buildCounterLocation--;
return o;
}
void checkLocation(api.Location o) {
buildCounterLocation++;
if (buildCounterLocation < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed21(o.labels!);
unittest.expect(
o.locationId!,
unittest.equals('foo'),
);
checkUnnamed22(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLocation--;
}
core.int buildCounterMavenArtifact = 0;
api.MavenArtifact buildMavenArtifact() {
final o = api.MavenArtifact();
buildCounterMavenArtifact++;
if (buildCounterMavenArtifact < 3) {
o.artifactId = 'foo';
o.createTime = 'foo';
o.groupId = 'foo';
o.name = 'foo';
o.pomUri = 'foo';
o.updateTime = 'foo';
o.version = 'foo';
}
buildCounterMavenArtifact--;
return o;
}
void checkMavenArtifact(api.MavenArtifact o) {
buildCounterMavenArtifact++;
if (buildCounterMavenArtifact < 3) {
unittest.expect(
o.artifactId!,
unittest.equals('foo'),
);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.groupId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.pomUri!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterMavenArtifact--;
}
core.int buildCounterMavenRepository = 0;
api.MavenRepository buildMavenRepository() {
final o = api.MavenRepository();
buildCounterMavenRepository++;
if (buildCounterMavenRepository < 3) {
o.publicRepository = 'foo';
}
buildCounterMavenRepository--;
return o;
}
void checkMavenRepository(api.MavenRepository o) {
buildCounterMavenRepository++;
if (buildCounterMavenRepository < 3) {
unittest.expect(
o.publicRepository!,
unittest.equals('foo'),
);
}
buildCounterMavenRepository--;
}
core.int buildCounterMavenRepositoryConfig = 0;
api.MavenRepositoryConfig buildMavenRepositoryConfig() {
final o = api.MavenRepositoryConfig();
buildCounterMavenRepositoryConfig++;
if (buildCounterMavenRepositoryConfig < 3) {
o.allowSnapshotOverwrites = true;
o.versionPolicy = 'foo';
}
buildCounterMavenRepositoryConfig--;
return o;
}
void checkMavenRepositoryConfig(api.MavenRepositoryConfig o) {
buildCounterMavenRepositoryConfig++;
if (buildCounterMavenRepositoryConfig < 3) {
unittest.expect(o.allowSnapshotOverwrites!, unittest.isTrue);
unittest.expect(
o.versionPolicy!,
unittest.equals('foo'),
);
}
buildCounterMavenRepositoryConfig--;
}
core.List<core.String> buildUnnamed23() => [
'foo',
'foo',
];
void checkUnnamed23(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterNpmPackage = 0;
api.NpmPackage buildNpmPackage() {
final o = api.NpmPackage();
buildCounterNpmPackage++;
if (buildCounterNpmPackage < 3) {
o.createTime = 'foo';
o.name = 'foo';
o.packageName = 'foo';
o.tags = buildUnnamed23();
o.updateTime = 'foo';
o.version = 'foo';
}
buildCounterNpmPackage--;
return o;
}
void checkNpmPackage(api.NpmPackage o) {
buildCounterNpmPackage++;
if (buildCounterNpmPackage < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.packageName!,
unittest.equals('foo'),
);
checkUnnamed23(o.tags!);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterNpmPackage--;
}
core.int buildCounterNpmRepository = 0;
api.NpmRepository buildNpmRepository() {
final o = api.NpmRepository();
buildCounterNpmRepository++;
if (buildCounterNpmRepository < 3) {
o.publicRepository = 'foo';
}
buildCounterNpmRepository--;
return o;
}
void checkNpmRepository(api.NpmRepository o) {
buildCounterNpmRepository++;
if (buildCounterNpmRepository < 3) {
unittest.expect(
o.publicRepository!,
unittest.equals('foo'),
);
}
buildCounterNpmRepository--;
}
core.Map<core.String, core.Object?> buildUnnamed24() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed24(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted3 = (o['x']!) as core.Map;
unittest.expect(casted3, unittest.hasLength(3));
unittest.expect(
casted3['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted3['bool'],
unittest.equals(true),
);
unittest.expect(
casted3['string'],
unittest.equals('foo'),
);
var casted4 = (o['y']!) as core.Map;
unittest.expect(casted4, unittest.hasLength(3));
unittest.expect(
casted4['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted4['bool'],
unittest.equals(true),
);
unittest.expect(
casted4['string'],
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed25() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed25(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted5 = (o['x']!) as core.Map;
unittest.expect(casted5, unittest.hasLength(3));
unittest.expect(
casted5['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted5['bool'],
unittest.equals(true),
);
unittest.expect(
casted5['string'],
unittest.equals('foo'),
);
var casted6 = (o['y']!) as core.Map;
unittest.expect(casted6, unittest.hasLength(3));
unittest.expect(
casted6['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted6['bool'],
unittest.equals(true),
);
unittest.expect(
casted6['string'],
unittest.equals('foo'),
);
}
core.int buildCounterOperation = 0;
api.Operation buildOperation() {
final o = api.Operation();
buildCounterOperation++;
if (buildCounterOperation < 3) {
o.done = true;
o.error = buildStatus();
o.metadata = buildUnnamed24();
o.name = 'foo';
o.response = buildUnnamed25();
}
buildCounterOperation--;
return o;
}
void checkOperation(api.Operation o) {
buildCounterOperation++;
if (buildCounterOperation < 3) {
unittest.expect(o.done!, unittest.isTrue);
checkStatus(o.error!);
checkUnnamed24(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed25(o.response!);
}
buildCounterOperation--;
}
core.int buildCounterPackage = 0;
api.Package buildPackage() {
final o = api.Package();
buildCounterPackage++;
if (buildCounterPackage < 3) {
o.createTime = 'foo';
o.displayName = 'foo';
o.name = 'foo';
o.updateTime = 'foo';
}
buildCounterPackage--;
return o;
}
void checkPackage(api.Package o) {
buildCounterPackage++;
if (buildCounterPackage < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterPackage--;
}
core.List<api.Binding> buildUnnamed26() => [
buildBinding(),
buildBinding(),
];
void checkUnnamed26(core.List<api.Binding> o) {
unittest.expect(o, unittest.hasLength(2));
checkBinding(o[0]);
checkBinding(o[1]);
}
core.int buildCounterPolicy = 0;
api.Policy buildPolicy() {
final o = api.Policy();
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
o.bindings = buildUnnamed26();
o.etag = 'foo';
o.version = 42;
}
buildCounterPolicy--;
return o;
}
void checkPolicy(api.Policy o) {
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
checkUnnamed26(o.bindings!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals(42),
);
}
buildCounterPolicy--;
}
core.int buildCounterProjectSettings = 0;
api.ProjectSettings buildProjectSettings() {
final o = api.ProjectSettings();
buildCounterProjectSettings++;
if (buildCounterProjectSettings < 3) {
o.legacyRedirectionState = 'foo';
o.name = 'foo';
}
buildCounterProjectSettings--;
return o;
}
void checkProjectSettings(api.ProjectSettings o) {
buildCounterProjectSettings++;
if (buildCounterProjectSettings < 3) {
unittest.expect(
o.legacyRedirectionState!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterProjectSettings--;
}
core.int buildCounterPythonPackage = 0;
api.PythonPackage buildPythonPackage() {
final o = api.PythonPackage();
buildCounterPythonPackage++;
if (buildCounterPythonPackage < 3) {
o.createTime = 'foo';
o.name = 'foo';
o.packageName = 'foo';
o.updateTime = 'foo';
o.uri = 'foo';
o.version = 'foo';
}
buildCounterPythonPackage--;
return o;
}
void checkPythonPackage(api.PythonPackage o) {
buildCounterPythonPackage++;
if (buildCounterPythonPackage < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.packageName!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterPythonPackage--;
}
core.int buildCounterPythonRepository = 0;
api.PythonRepository buildPythonRepository() {
final o = api.PythonRepository();
buildCounterPythonRepository++;
if (buildCounterPythonRepository < 3) {
o.publicRepository = 'foo';
}
buildCounterPythonRepository--;
return o;
}
void checkPythonRepository(api.PythonRepository o) {
buildCounterPythonRepository++;
if (buildCounterPythonRepository < 3) {
unittest.expect(
o.publicRepository!,
unittest.equals('foo'),
);
}
buildCounterPythonRepository--;
}
core.int buildCounterRemoteRepositoryConfig = 0;
api.RemoteRepositoryConfig buildRemoteRepositoryConfig() {
final o = api.RemoteRepositoryConfig();
buildCounterRemoteRepositoryConfig++;
if (buildCounterRemoteRepositoryConfig < 3) {
o.description = 'foo';
o.dockerRepository = buildDockerRepository();
o.mavenRepository = buildMavenRepository();
o.npmRepository = buildNpmRepository();
o.pythonRepository = buildPythonRepository();
}
buildCounterRemoteRepositoryConfig--;
return o;
}
void checkRemoteRepositoryConfig(api.RemoteRepositoryConfig o) {
buildCounterRemoteRepositoryConfig++;
if (buildCounterRemoteRepositoryConfig < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkDockerRepository(o.dockerRepository!);
checkMavenRepository(o.mavenRepository!);
checkNpmRepository(o.npmRepository!);
checkPythonRepository(o.pythonRepository!);
}
buildCounterRemoteRepositoryConfig--;
}
core.Map<core.String, api.CleanupPolicy> buildUnnamed27() => {
'x': buildCleanupPolicy(),
'y': buildCleanupPolicy(),
};
void checkUnnamed27(core.Map<core.String, api.CleanupPolicy> o) {
unittest.expect(o, unittest.hasLength(2));
checkCleanupPolicy(o['x']!);
checkCleanupPolicy(o['y']!);
}
core.Map<core.String, core.String> buildUnnamed28() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed28(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterRepository = 0;
api.Repository buildRepository() {
final o = api.Repository();
buildCounterRepository++;
if (buildCounterRepository < 3) {
o.cleanupPolicies = buildUnnamed27();
o.cleanupPolicyDryRun = true;
o.createTime = 'foo';
o.description = 'foo';
o.dockerConfig = buildDockerRepositoryConfig();
o.format = 'foo';
o.kmsKeyName = 'foo';
o.labels = buildUnnamed28();
o.mavenConfig = buildMavenRepositoryConfig();
o.mode = 'foo';
o.name = 'foo';
o.remoteRepositoryConfig = buildRemoteRepositoryConfig();
o.satisfiesPzs = true;
o.sbomConfig = buildSbomConfig();
o.sizeBytes = 'foo';
o.updateTime = 'foo';
o.virtualRepositoryConfig = buildVirtualRepositoryConfig();
}
buildCounterRepository--;
return o;
}
void checkRepository(api.Repository o) {
buildCounterRepository++;
if (buildCounterRepository < 3) {
checkUnnamed27(o.cleanupPolicies!);
unittest.expect(o.cleanupPolicyDryRun!, unittest.isTrue);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkDockerRepositoryConfig(o.dockerConfig!);
unittest.expect(
o.format!,
unittest.equals('foo'),
);
unittest.expect(
o.kmsKeyName!,
unittest.equals('foo'),
);
checkUnnamed28(o.labels!);
checkMavenRepositoryConfig(o.mavenConfig!);
unittest.expect(
o.mode!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkRemoteRepositoryConfig(o.remoteRepositoryConfig!);
unittest.expect(o.satisfiesPzs!, unittest.isTrue);
checkSbomConfig(o.sbomConfig!);
unittest.expect(
o.sizeBytes!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
checkVirtualRepositoryConfig(o.virtualRepositoryConfig!);
}
buildCounterRepository--;
}
core.int buildCounterSbomConfig = 0;
api.SbomConfig buildSbomConfig() {
final o = api.SbomConfig();
buildCounterSbomConfig++;
if (buildCounterSbomConfig < 3) {
o.enablementConfig = 'foo';
o.lastEnableTime = 'foo';
}
buildCounterSbomConfig--;
return o;
}
void checkSbomConfig(api.SbomConfig o) {
buildCounterSbomConfig++;
if (buildCounterSbomConfig < 3) {
unittest.expect(
o.enablementConfig!,
unittest.equals('foo'),
);
unittest.expect(
o.lastEnableTime!,
unittest.equals('foo'),
);
}
buildCounterSbomConfig--;
}
core.int buildCounterSetIamPolicyRequest = 0;
api.SetIamPolicyRequest buildSetIamPolicyRequest() {
final o = api.SetIamPolicyRequest();
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
o.policy = buildPolicy();
}
buildCounterSetIamPolicyRequest--;
return o;
}
void checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
checkPolicy(o.policy!);
}
buildCounterSetIamPolicyRequest--;
}
core.Map<core.String, core.Object?> buildUnnamed29() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed29(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted7 = (o['x']!) as core.Map;
unittest.expect(casted7, unittest.hasLength(3));
unittest.expect(
casted7['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted7['bool'],
unittest.equals(true),
);
unittest.expect(
casted7['string'],
unittest.equals('foo'),
);
var casted8 = (o['y']!) as core.Map;
unittest.expect(casted8, unittest.hasLength(3));
unittest.expect(
casted8['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted8['bool'],
unittest.equals(true),
);
unittest.expect(
casted8['string'],
unittest.equals('foo'),
);
}
core.List<core.Map<core.String, core.Object?>> buildUnnamed30() => [
buildUnnamed29(),
buildUnnamed29(),
];
void checkUnnamed30(core.List<core.Map<core.String, core.Object?>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed29(o[0]);
checkUnnamed29(o[1]);
}
core.int buildCounterStatus = 0;
api.Status buildStatus() {
final o = api.Status();
buildCounterStatus++;
if (buildCounterStatus < 3) {
o.code = 42;
o.details = buildUnnamed30();
o.message = 'foo';
}
buildCounterStatus--;
return o;
}
void checkStatus(api.Status o) {
buildCounterStatus++;
if (buildCounterStatus < 3) {
unittest.expect(
o.code!,
unittest.equals(42),
);
checkUnnamed30(o.details!);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterStatus--;
}
core.int buildCounterTag = 0;
api.Tag buildTag() {
final o = api.Tag();
buildCounterTag++;
if (buildCounterTag < 3) {
o.name = 'foo';
o.version = 'foo';
}
buildCounterTag--;
return o;
}
void checkTag(api.Tag o) {
buildCounterTag++;
if (buildCounterTag < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterTag--;
}
core.List<core.String> buildUnnamed31() => [
'foo',
'foo',
];
void checkUnnamed31(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsRequest = 0;
api.TestIamPermissionsRequest buildTestIamPermissionsRequest() {
final o = api.TestIamPermissionsRequest();
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
o.permissions = buildUnnamed31();
}
buildCounterTestIamPermissionsRequest--;
return o;
}
void checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
checkUnnamed31(o.permissions!);
}
buildCounterTestIamPermissionsRequest--;
}
core.List<core.String> buildUnnamed32() => [
'foo',
'foo',
];
void checkUnnamed32(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsResponse = 0;
api.TestIamPermissionsResponse buildTestIamPermissionsResponse() {
final o = api.TestIamPermissionsResponse();
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
o.permissions = buildUnnamed32();
}
buildCounterTestIamPermissionsResponse--;
return o;
}
void checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
checkUnnamed32(o.permissions!);
}
buildCounterTestIamPermissionsResponse--;
}
core.int buildCounterUploadAptArtifactMediaResponse = 0;
api.UploadAptArtifactMediaResponse buildUploadAptArtifactMediaResponse() {
final o = api.UploadAptArtifactMediaResponse();
buildCounterUploadAptArtifactMediaResponse++;
if (buildCounterUploadAptArtifactMediaResponse < 3) {
o.operation = buildOperation();
}
buildCounterUploadAptArtifactMediaResponse--;
return o;
}
void checkUploadAptArtifactMediaResponse(api.UploadAptArtifactMediaResponse o) {
buildCounterUploadAptArtifactMediaResponse++;
if (buildCounterUploadAptArtifactMediaResponse < 3) {
checkOperation(o.operation!);
}
buildCounterUploadAptArtifactMediaResponse--;
}
core.int buildCounterUploadAptArtifactRequest = 0;
api.UploadAptArtifactRequest buildUploadAptArtifactRequest() {
final o = api.UploadAptArtifactRequest();
buildCounterUploadAptArtifactRequest++;
if (buildCounterUploadAptArtifactRequest < 3) {}
buildCounterUploadAptArtifactRequest--;
return o;
}
void checkUploadAptArtifactRequest(api.UploadAptArtifactRequest o) {
buildCounterUploadAptArtifactRequest++;
if (buildCounterUploadAptArtifactRequest < 3) {}
buildCounterUploadAptArtifactRequest--;
}
core.int buildCounterUploadGoModuleMediaResponse = 0;
api.UploadGoModuleMediaResponse buildUploadGoModuleMediaResponse() {
final o = api.UploadGoModuleMediaResponse();
buildCounterUploadGoModuleMediaResponse++;
if (buildCounterUploadGoModuleMediaResponse < 3) {
o.operation = buildOperation();
}
buildCounterUploadGoModuleMediaResponse--;
return o;
}
void checkUploadGoModuleMediaResponse(api.UploadGoModuleMediaResponse o) {
buildCounterUploadGoModuleMediaResponse++;
if (buildCounterUploadGoModuleMediaResponse < 3) {
checkOperation(o.operation!);
}
buildCounterUploadGoModuleMediaResponse--;
}
core.int buildCounterUploadGoModuleRequest = 0;
api.UploadGoModuleRequest buildUploadGoModuleRequest() {
final o = api.UploadGoModuleRequest();
buildCounterUploadGoModuleRequest++;
if (buildCounterUploadGoModuleRequest < 3) {}
buildCounterUploadGoModuleRequest--;
return o;
}
void checkUploadGoModuleRequest(api.UploadGoModuleRequest o) {
buildCounterUploadGoModuleRequest++;
if (buildCounterUploadGoModuleRequest < 3) {}
buildCounterUploadGoModuleRequest--;
}
core.int buildCounterUploadGoogetArtifactMediaResponse = 0;
api.UploadGoogetArtifactMediaResponse buildUploadGoogetArtifactMediaResponse() {
final o = api.UploadGoogetArtifactMediaResponse();
buildCounterUploadGoogetArtifactMediaResponse++;
if (buildCounterUploadGoogetArtifactMediaResponse < 3) {
o.operation = buildOperation();
}
buildCounterUploadGoogetArtifactMediaResponse--;
return o;
}
void checkUploadGoogetArtifactMediaResponse(
api.UploadGoogetArtifactMediaResponse o) {
buildCounterUploadGoogetArtifactMediaResponse++;
if (buildCounterUploadGoogetArtifactMediaResponse < 3) {
checkOperation(o.operation!);
}
buildCounterUploadGoogetArtifactMediaResponse--;
}
core.int buildCounterUploadGoogetArtifactRequest = 0;
api.UploadGoogetArtifactRequest buildUploadGoogetArtifactRequest() {
final o = api.UploadGoogetArtifactRequest();
buildCounterUploadGoogetArtifactRequest++;
if (buildCounterUploadGoogetArtifactRequest < 3) {}
buildCounterUploadGoogetArtifactRequest--;
return o;
}
void checkUploadGoogetArtifactRequest(api.UploadGoogetArtifactRequest o) {
buildCounterUploadGoogetArtifactRequest++;
if (buildCounterUploadGoogetArtifactRequest < 3) {}
buildCounterUploadGoogetArtifactRequest--;
}
core.int buildCounterUploadKfpArtifactMediaResponse = 0;
api.UploadKfpArtifactMediaResponse buildUploadKfpArtifactMediaResponse() {
final o = api.UploadKfpArtifactMediaResponse();
buildCounterUploadKfpArtifactMediaResponse++;
if (buildCounterUploadKfpArtifactMediaResponse < 3) {
o.operation = buildOperation();
}
buildCounterUploadKfpArtifactMediaResponse--;
return o;
}
void checkUploadKfpArtifactMediaResponse(api.UploadKfpArtifactMediaResponse o) {
buildCounterUploadKfpArtifactMediaResponse++;
if (buildCounterUploadKfpArtifactMediaResponse < 3) {
checkOperation(o.operation!);
}
buildCounterUploadKfpArtifactMediaResponse--;
}
core.List<core.String> buildUnnamed33() => [
'foo',
'foo',
];
void checkUnnamed33(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterUploadKfpArtifactRequest = 0;
api.UploadKfpArtifactRequest buildUploadKfpArtifactRequest() {
final o = api.UploadKfpArtifactRequest();
buildCounterUploadKfpArtifactRequest++;
if (buildCounterUploadKfpArtifactRequest < 3) {
o.description = 'foo';
o.tags = buildUnnamed33();
}
buildCounterUploadKfpArtifactRequest--;
return o;
}
void checkUploadKfpArtifactRequest(api.UploadKfpArtifactRequest o) {
buildCounterUploadKfpArtifactRequest++;
if (buildCounterUploadKfpArtifactRequest < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkUnnamed33(o.tags!);
}
buildCounterUploadKfpArtifactRequest--;
}
core.int buildCounterUploadYumArtifactMediaResponse = 0;
api.UploadYumArtifactMediaResponse buildUploadYumArtifactMediaResponse() {
final o = api.UploadYumArtifactMediaResponse();
buildCounterUploadYumArtifactMediaResponse++;
if (buildCounterUploadYumArtifactMediaResponse < 3) {
o.operation = buildOperation();
}
buildCounterUploadYumArtifactMediaResponse--;
return o;
}
void checkUploadYumArtifactMediaResponse(api.UploadYumArtifactMediaResponse o) {
buildCounterUploadYumArtifactMediaResponse++;
if (buildCounterUploadYumArtifactMediaResponse < 3) {
checkOperation(o.operation!);
}
buildCounterUploadYumArtifactMediaResponse--;
}
core.int buildCounterUploadYumArtifactRequest = 0;
api.UploadYumArtifactRequest buildUploadYumArtifactRequest() {
final o = api.UploadYumArtifactRequest();
buildCounterUploadYumArtifactRequest++;
if (buildCounterUploadYumArtifactRequest < 3) {}
buildCounterUploadYumArtifactRequest--;
return o;
}
void checkUploadYumArtifactRequest(api.UploadYumArtifactRequest o) {
buildCounterUploadYumArtifactRequest++;
if (buildCounterUploadYumArtifactRequest < 3) {}
buildCounterUploadYumArtifactRequest--;
}
core.int buildCounterUpstreamPolicy = 0;
api.UpstreamPolicy buildUpstreamPolicy() {
final o = api.UpstreamPolicy();
buildCounterUpstreamPolicy++;
if (buildCounterUpstreamPolicy < 3) {
o.id = 'foo';
o.priority = 42;
o.repository = 'foo';
}
buildCounterUpstreamPolicy--;
return o;
}
void checkUpstreamPolicy(api.UpstreamPolicy o) {
buildCounterUpstreamPolicy++;
if (buildCounterUpstreamPolicy < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.priority!,
unittest.equals(42),
);
unittest.expect(
o.repository!,
unittest.equals('foo'),
);
}
buildCounterUpstreamPolicy--;
}
core.int buildCounterVPCSCConfig = 0;
api.VPCSCConfig buildVPCSCConfig() {
final o = api.VPCSCConfig();
buildCounterVPCSCConfig++;
if (buildCounterVPCSCConfig < 3) {
o.name = 'foo';
o.vpcscPolicy = 'foo';
}
buildCounterVPCSCConfig--;
return o;
}
void checkVPCSCConfig(api.VPCSCConfig o) {
buildCounterVPCSCConfig++;
if (buildCounterVPCSCConfig < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.vpcscPolicy!,
unittest.equals('foo'),
);
}
buildCounterVPCSCConfig--;
}
core.Map<core.String, core.Object?> buildUnnamed34() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed34(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted9 = (o['x']!) as core.Map;
unittest.expect(casted9, unittest.hasLength(3));
unittest.expect(
casted9['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted9['bool'],
unittest.equals(true),
);
unittest.expect(
casted9['string'],
unittest.equals('foo'),
);
var casted10 = (o['y']!) as core.Map;
unittest.expect(casted10, unittest.hasLength(3));
unittest.expect(
casted10['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted10['bool'],
unittest.equals(true),
);
unittest.expect(
casted10['string'],
unittest.equals('foo'),
);
}
core.List<api.Tag> buildUnnamed35() => [
buildTag(),
buildTag(),
];
void checkUnnamed35(core.List<api.Tag> o) {
unittest.expect(o, unittest.hasLength(2));
checkTag(o[0]);
checkTag(o[1]);
}
core.int buildCounterVersion = 0;
api.Version buildVersion() {
final o = api.Version();
buildCounterVersion++;
if (buildCounterVersion < 3) {
o.createTime = 'foo';
o.description = 'foo';
o.metadata = buildUnnamed34();
o.name = 'foo';
o.relatedTags = buildUnnamed35();
o.updateTime = 'foo';
}
buildCounterVersion--;
return o;
}
void checkVersion(api.Version o) {
buildCounterVersion++;
if (buildCounterVersion < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkUnnamed34(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed35(o.relatedTags!);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterVersion--;
}
core.List<api.UpstreamPolicy> buildUnnamed36() => [
buildUpstreamPolicy(),
buildUpstreamPolicy(),
];
void checkUnnamed36(core.List<api.UpstreamPolicy> o) {
unittest.expect(o, unittest.hasLength(2));
checkUpstreamPolicy(o[0]);
checkUpstreamPolicy(o[1]);
}
core.int buildCounterVirtualRepositoryConfig = 0;
api.VirtualRepositoryConfig buildVirtualRepositoryConfig() {
final o = api.VirtualRepositoryConfig();
buildCounterVirtualRepositoryConfig++;
if (buildCounterVirtualRepositoryConfig < 3) {
o.upstreamPolicies = buildUnnamed36();
}
buildCounterVirtualRepositoryConfig--;
return o;
}
void checkVirtualRepositoryConfig(api.VirtualRepositoryConfig o) {
buildCounterVirtualRepositoryConfig++;
if (buildCounterVirtualRepositoryConfig < 3) {
checkUnnamed36(o.upstreamPolicies!);
}
buildCounterVirtualRepositoryConfig--;
}
void main() {
unittest.group('obj-schema-BatchDeleteVersionsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildBatchDeleteVersionsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BatchDeleteVersionsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBatchDeleteVersionsRequest(od);
});
});
unittest.group('obj-schema-Binding', () {
unittest.test('to-json--from-json', () async {
final o = buildBinding();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Binding.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkBinding(od);
});
});
unittest.group('obj-schema-CleanupPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildCleanupPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CleanupPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCleanupPolicy(od);
});
});
unittest.group('obj-schema-CleanupPolicyCondition', () {
unittest.test('to-json--from-json', () async {
final o = buildCleanupPolicyCondition();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CleanupPolicyCondition.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCleanupPolicyCondition(od);
});
});
unittest.group('obj-schema-CleanupPolicyMostRecentVersions', () {
unittest.test('to-json--from-json', () async {
final o = buildCleanupPolicyMostRecentVersions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CleanupPolicyMostRecentVersions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCleanupPolicyMostRecentVersions(od);
});
});
unittest.group('obj-schema-DockerImage', () {
unittest.test('to-json--from-json', () async {
final o = buildDockerImage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DockerImage.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDockerImage(od);
});
});
unittest.group('obj-schema-DockerRepository', () {
unittest.test('to-json--from-json', () async {
final o = buildDockerRepository();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DockerRepository.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDockerRepository(od);
});
});
unittest.group('obj-schema-DockerRepositoryConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildDockerRepositoryConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DockerRepositoryConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDockerRepositoryConfig(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-Expr', () {
unittest.test('to-json--from-json', () async {
final o = buildExpr();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Expr.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkExpr(od);
});
});
unittest.group('obj-schema-GoogleDevtoolsArtifactregistryV1File', () {
unittest.test('to-json--from-json', () async {
final o = buildGoogleDevtoolsArtifactregistryV1File();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GoogleDevtoolsArtifactregistryV1File.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGoogleDevtoolsArtifactregistryV1File(od);
});
});
unittest.group('obj-schema-Hash', () {
unittest.test('to-json--from-json', () async {
final o = buildHash();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Hash.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkHash(od);
});
});
unittest.group('obj-schema-ImportAptArtifactsGcsSource', () {
unittest.test('to-json--from-json', () async {
final o = buildImportAptArtifactsGcsSource();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportAptArtifactsGcsSource.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportAptArtifactsGcsSource(od);
});
});
unittest.group('obj-schema-ImportAptArtifactsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildImportAptArtifactsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportAptArtifactsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportAptArtifactsRequest(od);
});
});
unittest.group('obj-schema-ImportGoogetArtifactsGcsSource', () {
unittest.test('to-json--from-json', () async {
final o = buildImportGoogetArtifactsGcsSource();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportGoogetArtifactsGcsSource.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportGoogetArtifactsGcsSource(od);
});
});
unittest.group('obj-schema-ImportGoogetArtifactsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildImportGoogetArtifactsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportGoogetArtifactsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportGoogetArtifactsRequest(od);
});
});
unittest.group('obj-schema-ImportYumArtifactsGcsSource', () {
unittest.test('to-json--from-json', () async {
final o = buildImportYumArtifactsGcsSource();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportYumArtifactsGcsSource.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportYumArtifactsGcsSource(od);
});
});
unittest.group('obj-schema-ImportYumArtifactsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildImportYumArtifactsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportYumArtifactsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportYumArtifactsRequest(od);
});
});
unittest.group('obj-schema-ListDockerImagesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListDockerImagesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListDockerImagesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListDockerImagesResponse(od);
});
});
unittest.group('obj-schema-ListFilesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListFilesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListFilesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListFilesResponse(od);
});
});
unittest.group('obj-schema-ListLocationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLocationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLocationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLocationsResponse(od);
});
});
unittest.group('obj-schema-ListMavenArtifactsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListMavenArtifactsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListMavenArtifactsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListMavenArtifactsResponse(od);
});
});
unittest.group('obj-schema-ListNpmPackagesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListNpmPackagesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListNpmPackagesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListNpmPackagesResponse(od);
});
});
unittest.group('obj-schema-ListPackagesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListPackagesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPackagesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPackagesResponse(od);
});
});
unittest.group('obj-schema-ListPythonPackagesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListPythonPackagesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPythonPackagesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPythonPackagesResponse(od);
});
});
unittest.group('obj-schema-ListRepositoriesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListRepositoriesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListRepositoriesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListRepositoriesResponse(od);
});
});
unittest.group('obj-schema-ListTagsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListTagsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListTagsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListTagsResponse(od);
});
});
unittest.group('obj-schema-ListVersionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListVersionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListVersionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListVersionsResponse(od);
});
});
unittest.group('obj-schema-Location', () {
unittest.test('to-json--from-json', () async {
final o = buildLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Location.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLocation(od);
});
});
unittest.group('obj-schema-MavenArtifact', () {
unittest.test('to-json--from-json', () async {
final o = buildMavenArtifact();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MavenArtifact.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMavenArtifact(od);
});
});
unittest.group('obj-schema-MavenRepository', () {
unittest.test('to-json--from-json', () async {
final o = buildMavenRepository();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MavenRepository.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMavenRepository(od);
});
});
unittest.group('obj-schema-MavenRepositoryConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildMavenRepositoryConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MavenRepositoryConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMavenRepositoryConfig(od);
});
});
unittest.group('obj-schema-NpmPackage', () {
unittest.test('to-json--from-json', () async {
final o = buildNpmPackage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NpmPackage.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNpmPackage(od);
});
});
unittest.group('obj-schema-NpmRepository', () {
unittest.test('to-json--from-json', () async {
final o = buildNpmRepository();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NpmRepository.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNpmRepository(od);
});
});
unittest.group('obj-schema-Operation', () {
unittest.test('to-json--from-json', () async {
final o = buildOperation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Operation.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOperation(od);
});
});
unittest.group('obj-schema-Package', () {
unittest.test('to-json--from-json', () async {
final o = buildPackage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Package.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPackage(od);
});
});
unittest.group('obj-schema-Policy', () {
unittest.test('to-json--from-json', () async {
final o = buildPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Policy.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPolicy(od);
});
});
unittest.group('obj-schema-ProjectSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildProjectSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ProjectSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkProjectSettings(od);
});
});
unittest.group('obj-schema-PythonPackage', () {
unittest.test('to-json--from-json', () async {
final o = buildPythonPackage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PythonPackage.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPythonPackage(od);
});
});
unittest.group('obj-schema-PythonRepository', () {
unittest.test('to-json--from-json', () async {
final o = buildPythonRepository();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PythonRepository.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPythonRepository(od);
});
});
unittest.group('obj-schema-RemoteRepositoryConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildRemoteRepositoryConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RemoteRepositoryConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRemoteRepositoryConfig(od);
});
});
unittest.group('obj-schema-Repository', () {
unittest.test('to-json--from-json', () async {
final o = buildRepository();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Repository.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRepository(od);
});
});
unittest.group('obj-schema-SbomConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildSbomConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.SbomConfig.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSbomConfig(od);
});
});
unittest.group('obj-schema-SetIamPolicyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetIamPolicyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetIamPolicyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(od);
});
});
unittest.group('obj-schema-Status', () {
unittest.test('to-json--from-json', () async {
final o = buildStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Status.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkStatus(od);
});
});
unittest.group('obj-schema-Tag', () {
unittest.test('to-json--from-json', () async {
final o = buildTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Tag.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTag(od);
});
});
unittest.group('obj-schema-TestIamPermissionsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(od);
});
});
unittest.group('obj-schema-TestIamPermissionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsResponse(od);
});
});
unittest.group('obj-schema-UploadAptArtifactMediaResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadAptArtifactMediaResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadAptArtifactMediaResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadAptArtifactMediaResponse(od);
});
});
unittest.group('obj-schema-UploadAptArtifactRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadAptArtifactRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadAptArtifactRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadAptArtifactRequest(od);
});
});
unittest.group('obj-schema-UploadGoModuleMediaResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadGoModuleMediaResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadGoModuleMediaResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadGoModuleMediaResponse(od);
});
});
unittest.group('obj-schema-UploadGoModuleRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadGoModuleRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadGoModuleRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadGoModuleRequest(od);
});
});
unittest.group('obj-schema-UploadGoogetArtifactMediaResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadGoogetArtifactMediaResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadGoogetArtifactMediaResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadGoogetArtifactMediaResponse(od);
});
});
unittest.group('obj-schema-UploadGoogetArtifactRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadGoogetArtifactRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadGoogetArtifactRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadGoogetArtifactRequest(od);
});
});
unittest.group('obj-schema-UploadKfpArtifactMediaResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadKfpArtifactMediaResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadKfpArtifactMediaResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadKfpArtifactMediaResponse(od);
});
});
unittest.group('obj-schema-UploadKfpArtifactRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadKfpArtifactRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadKfpArtifactRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadKfpArtifactRequest(od);
});
});
unittest.group('obj-schema-UploadYumArtifactMediaResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadYumArtifactMediaResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadYumArtifactMediaResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadYumArtifactMediaResponse(od);
});
});
unittest.group('obj-schema-UploadYumArtifactRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUploadYumArtifactRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UploadYumArtifactRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUploadYumArtifactRequest(od);
});
});
unittest.group('obj-schema-UpstreamPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildUpstreamPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpstreamPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpstreamPolicy(od);
});
});
unittest.group('obj-schema-VPCSCConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildVPCSCConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VPCSCConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVPCSCConfig(od);
});
});
unittest.group('obj-schema-Version', () {
unittest.test('to-json--from-json', () async {
final o = buildVersion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Version.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkVersion(od);
});
});
unittest.group('obj-schema-VirtualRepositoryConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildVirtualRepositoryConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VirtualRepositoryConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVirtualRepositoryConfig(od);
});
});
unittest.group('resource-ProjectsResource', () {
unittest.test('method--getProjectSettings', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildProjectSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getProjectSettings(arg_name, $fields: arg_$fields);
checkProjectSettings(response as api.ProjectSettings);
});
unittest.test('method--updateProjectSettings', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects;
final arg_request = buildProjectSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ProjectSettings.fromJson(
json as core.Map<core.String, core.dynamic>);
checkProjectSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildProjectSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateProjectSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkProjectSettings(response as api.ProjectSettings);
});
});
unittest.group('resource-ProjectsLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--getVpcscConfig', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVPCSCConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getVpcscConfig(arg_name, $fields: arg_$fields);
checkVPCSCConfig(response as api.VPCSCConfig);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
unittest.test('method--updateVpcscConfig', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations;
final arg_request = buildVPCSCConfig();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.VPCSCConfig.fromJson(
json as core.Map<core.String, core.dynamic>);
checkVPCSCConfig(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVPCSCConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateVpcscConfig(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkVPCSCConfig(response as api.VPCSCConfig);
});
});
unittest.group('resource-ProjectsLocationsOperationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_request = buildRepository();
final arg_parent = 'foo';
final arg_repositoryId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Repository.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRepository(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['repositoryId']!.first,
unittest.equals(arg_repositoryId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
repositoryId: arg_repositoryId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRepository());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkRepository(response as api.Repository);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListRepositoriesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListRepositoriesResponse(response as api.ListRepositoriesResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_request = buildRepository();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Repository.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRepository(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRepository());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkRepository(response as api.Repository);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock).projects.locations.repositories;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesAptArtifactsResource',
() {
unittest.test('method--import', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.aptArtifacts;
final arg_request = buildImportAptArtifactsRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ImportAptArtifactsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkImportAptArtifactsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.import(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--upload', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.aptArtifacts;
final arg_request = buildUploadAptArtifactRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UploadAptArtifactRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUploadAptArtifactRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUploadAptArtifactMediaResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.upload(arg_request, arg_parent, $fields: arg_$fields);
checkUploadAptArtifactMediaResponse(
response as api.UploadAptArtifactMediaResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesDockerImagesResource',
() {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.dockerImages;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDockerImage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkDockerImage(response as api.DockerImage);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.dockerImages;
final arg_parent = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListDockerImagesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListDockerImagesResponse(response as api.ListDockerImagesResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesFilesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res =
api.ArtifactRegistryApi(mock).projects.locations.repositories.files;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildGoogleDevtoolsArtifactregistryV1File());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkGoogleDevtoolsArtifactregistryV1File(
response as api.GoogleDevtoolsArtifactregistryV1File);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res =
api.ArtifactRegistryApi(mock).projects.locations.repositories.files;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListFilesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListFilesResponse(response as api.ListFilesResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesGoModulesResource', () {
unittest.test('method--upload', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.goModules;
final arg_request = buildUploadGoModuleRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UploadGoModuleRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUploadGoModuleRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUploadGoModuleMediaResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.upload(arg_request, arg_parent, $fields: arg_$fields);
checkUploadGoModuleMediaResponse(
response as api.UploadGoModuleMediaResponse);
});
});
unittest.group(
'resource-ProjectsLocationsRepositoriesGoogetArtifactsResource', () {
unittest.test('method--import', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.googetArtifacts;
final arg_request = buildImportGoogetArtifactsRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ImportGoogetArtifactsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkImportGoogetArtifactsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.import(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--upload', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.googetArtifacts;
final arg_request = buildUploadGoogetArtifactRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UploadGoogetArtifactRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUploadGoogetArtifactRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildUploadGoogetArtifactMediaResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.upload(arg_request, arg_parent, $fields: arg_$fields);
checkUploadGoogetArtifactMediaResponse(
response as api.UploadGoogetArtifactMediaResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesKfpArtifactsResource',
() {
unittest.test('method--upload', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.kfpArtifacts;
final arg_request = buildUploadKfpArtifactRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UploadKfpArtifactRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUploadKfpArtifactRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUploadKfpArtifactMediaResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.upload(arg_request, arg_parent, $fields: arg_$fields);
checkUploadKfpArtifactMediaResponse(
response as api.UploadKfpArtifactMediaResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesMavenArtifactsResource',
() {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.mavenArtifacts;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMavenArtifact());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkMavenArtifact(response as api.MavenArtifact);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.mavenArtifacts;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListMavenArtifactsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListMavenArtifactsResponse(
response as api.ListMavenArtifactsResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesNpmPackagesResource',
() {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.npmPackages;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildNpmPackage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkNpmPackage(response as api.NpmPackage);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.npmPackages;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListNpmPackagesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListNpmPackagesResponse(response as api.ListNpmPackagesResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesPackagesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPackage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkPackage(response as api.Package);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListPackagesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListPackagesResponse(response as api.ListPackagesResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesPackagesTagsResource',
() {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.tags;
final arg_request = buildTag();
final arg_parent = 'foo';
final arg_tagId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Tag.fromJson(json as core.Map<core.String, core.dynamic>);
checkTag(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['tagId']!.first,
unittest.equals(arg_tagId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
tagId: arg_tagId, $fields: arg_$fields);
checkTag(response as api.Tag);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.tags;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.tags;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkTag(response as api.Tag);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.tags;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListTagsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListTagsResponse(response as api.ListTagsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.tags;
final arg_request = buildTag();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Tag.fromJson(json as core.Map<core.String, core.dynamic>);
checkTag(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkTag(response as api.Tag);
});
});
unittest.group(
'resource-ProjectsLocationsRepositoriesPackagesVersionsResource', () {
unittest.test('method--batchDelete', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.versions;
final arg_request = buildBatchDeleteVersionsRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.BatchDeleteVersionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkBatchDeleteVersionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.batchDelete(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.versions;
final arg_name = 'foo';
final arg_force = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['force']!.first,
unittest.equals('$arg_force'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.delete(arg_name, force: arg_force, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.versions;
final arg_name = 'foo';
final arg_view = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['view']!.first,
unittest.equals(arg_view),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_name, view: arg_view, $fields: arg_$fields);
checkVersion(response as api.Version);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.packages
.versions;
final arg_parent = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_view = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['view']!.first,
unittest.equals(arg_view),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListVersionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
view: arg_view,
$fields: arg_$fields);
checkListVersionsResponse(response as api.ListVersionsResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesPythonPackagesResource',
() {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.pythonPackages;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPythonPackage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkPythonPackage(response as api.PythonPackage);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.pythonPackages;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListPythonPackagesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListPythonPackagesResponse(
response as api.ListPythonPackagesResponse);
});
});
unittest.group('resource-ProjectsLocationsRepositoriesYumArtifactsResource',
() {
unittest.test('method--import', () async {
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.yumArtifacts;
final arg_request = buildImportYumArtifactsRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ImportYumArtifactsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkImportYumArtifactsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.import(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--upload', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.ArtifactRegistryApi(mock)
.projects
.locations
.repositories
.yumArtifacts;
final arg_request = buildUploadYumArtifactRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UploadYumArtifactRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUploadYumArtifactRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUploadYumArtifactMediaResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.upload(arg_request, arg_parent, $fields: arg_$fields);
checkUploadYumArtifactMediaResponse(
response as api.UploadYumArtifactMediaResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/artifactregistry/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/artifactregistry/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 78959}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/calendar/v3.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<api.AclRule> buildUnnamed0() => [
buildAclRule(),
buildAclRule(),
];
void checkUnnamed0(core.List<api.AclRule> o) {
unittest.expect(o, unittest.hasLength(2));
checkAclRule(o[0]);
checkAclRule(o[1]);
}
core.int buildCounterAcl = 0;
api.Acl buildAcl() {
final o = api.Acl();
buildCounterAcl++;
if (buildCounterAcl < 3) {
o.etag = 'foo';
o.items = buildUnnamed0();
o.kind = 'foo';
o.nextPageToken = 'foo';
o.nextSyncToken = 'foo';
}
buildCounterAcl--;
return o;
}
void checkAcl(api.Acl o) {
buildCounterAcl++;
if (buildCounterAcl < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed0(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.nextSyncToken!,
unittest.equals('foo'),
);
}
buildCounterAcl--;
}
core.int buildCounterAclRuleScope = 0;
api.AclRuleScope buildAclRuleScope() {
final o = api.AclRuleScope();
buildCounterAclRuleScope++;
if (buildCounterAclRuleScope < 3) {
o.type = 'foo';
o.value = 'foo';
}
buildCounterAclRuleScope--;
return o;
}
void checkAclRuleScope(api.AclRuleScope o) {
buildCounterAclRuleScope++;
if (buildCounterAclRuleScope < 3) {
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterAclRuleScope--;
}
core.int buildCounterAclRule = 0;
api.AclRule buildAclRule() {
final o = api.AclRule();
buildCounterAclRule++;
if (buildCounterAclRule < 3) {
o.etag = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.role = 'foo';
o.scope = buildAclRuleScope();
}
buildCounterAclRule--;
return o;
}
void checkAclRule(api.AclRule o) {
buildCounterAclRule++;
if (buildCounterAclRule < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
checkAclRuleScope(o.scope!);
}
buildCounterAclRule--;
}
core.int buildCounterCalendar = 0;
api.Calendar buildCalendar() {
final o = api.Calendar();
buildCounterCalendar++;
if (buildCounterCalendar < 3) {
o.conferenceProperties = buildConferenceProperties();
o.description = 'foo';
o.etag = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.location = 'foo';
o.summary = 'foo';
o.timeZone = 'foo';
}
buildCounterCalendar--;
return o;
}
void checkCalendar(api.Calendar o) {
buildCounterCalendar++;
if (buildCounterCalendar < 3) {
checkConferenceProperties(o.conferenceProperties!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.summary!,
unittest.equals('foo'),
);
unittest.expect(
o.timeZone!,
unittest.equals('foo'),
);
}
buildCounterCalendar--;
}
core.List<api.CalendarListEntry> buildUnnamed1() => [
buildCalendarListEntry(),
buildCalendarListEntry(),
];
void checkUnnamed1(core.List<api.CalendarListEntry> o) {
unittest.expect(o, unittest.hasLength(2));
checkCalendarListEntry(o[0]);
checkCalendarListEntry(o[1]);
}
core.int buildCounterCalendarList = 0;
api.CalendarList buildCalendarList() {
final o = api.CalendarList();
buildCounterCalendarList++;
if (buildCounterCalendarList < 3) {
o.etag = 'foo';
o.items = buildUnnamed1();
o.kind = 'foo';
o.nextPageToken = 'foo';
o.nextSyncToken = 'foo';
}
buildCounterCalendarList--;
return o;
}
void checkCalendarList(api.CalendarList o) {
buildCounterCalendarList++;
if (buildCounterCalendarList < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed1(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.nextSyncToken!,
unittest.equals('foo'),
);
}
buildCounterCalendarList--;
}
core.List<api.EventReminder> buildUnnamed2() => [
buildEventReminder(),
buildEventReminder(),
];
void checkUnnamed2(core.List<api.EventReminder> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventReminder(o[0]);
checkEventReminder(o[1]);
}
core.List<api.CalendarNotification> buildUnnamed3() => [
buildCalendarNotification(),
buildCalendarNotification(),
];
void checkUnnamed3(core.List<api.CalendarNotification> o) {
unittest.expect(o, unittest.hasLength(2));
checkCalendarNotification(o[0]);
checkCalendarNotification(o[1]);
}
core.int buildCounterCalendarListEntryNotificationSettings = 0;
api.CalendarListEntryNotificationSettings
buildCalendarListEntryNotificationSettings() {
final o = api.CalendarListEntryNotificationSettings();
buildCounterCalendarListEntryNotificationSettings++;
if (buildCounterCalendarListEntryNotificationSettings < 3) {
o.notifications = buildUnnamed3();
}
buildCounterCalendarListEntryNotificationSettings--;
return o;
}
void checkCalendarListEntryNotificationSettings(
api.CalendarListEntryNotificationSettings o) {
buildCounterCalendarListEntryNotificationSettings++;
if (buildCounterCalendarListEntryNotificationSettings < 3) {
checkUnnamed3(o.notifications!);
}
buildCounterCalendarListEntryNotificationSettings--;
}
core.int buildCounterCalendarListEntry = 0;
api.CalendarListEntry buildCalendarListEntry() {
final o = api.CalendarListEntry();
buildCounterCalendarListEntry++;
if (buildCounterCalendarListEntry < 3) {
o.accessRole = 'foo';
o.backgroundColor = 'foo';
o.colorId = 'foo';
o.conferenceProperties = buildConferenceProperties();
o.defaultReminders = buildUnnamed2();
o.deleted = true;
o.description = 'foo';
o.etag = 'foo';
o.foregroundColor = 'foo';
o.hidden = true;
o.id = 'foo';
o.kind = 'foo';
o.location = 'foo';
o.notificationSettings = buildCalendarListEntryNotificationSettings();
o.primary = true;
o.selected = true;
o.summary = 'foo';
o.summaryOverride = 'foo';
o.timeZone = 'foo';
}
buildCounterCalendarListEntry--;
return o;
}
void checkCalendarListEntry(api.CalendarListEntry o) {
buildCounterCalendarListEntry++;
if (buildCounterCalendarListEntry < 3) {
unittest.expect(
o.accessRole!,
unittest.equals('foo'),
);
unittest.expect(
o.backgroundColor!,
unittest.equals('foo'),
);
unittest.expect(
o.colorId!,
unittest.equals('foo'),
);
checkConferenceProperties(o.conferenceProperties!);
checkUnnamed2(o.defaultReminders!);
unittest.expect(o.deleted!, unittest.isTrue);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.foregroundColor!,
unittest.equals('foo'),
);
unittest.expect(o.hidden!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
checkCalendarListEntryNotificationSettings(o.notificationSettings!);
unittest.expect(o.primary!, unittest.isTrue);
unittest.expect(o.selected!, unittest.isTrue);
unittest.expect(
o.summary!,
unittest.equals('foo'),
);
unittest.expect(
o.summaryOverride!,
unittest.equals('foo'),
);
unittest.expect(
o.timeZone!,
unittest.equals('foo'),
);
}
buildCounterCalendarListEntry--;
}
core.int buildCounterCalendarNotification = 0;
api.CalendarNotification buildCalendarNotification() {
final o = api.CalendarNotification();
buildCounterCalendarNotification++;
if (buildCounterCalendarNotification < 3) {
o.method = 'foo';
o.type = 'foo';
}
buildCounterCalendarNotification--;
return o;
}
void checkCalendarNotification(api.CalendarNotification o) {
buildCounterCalendarNotification++;
if (buildCounterCalendarNotification < 3) {
unittest.expect(
o.method!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterCalendarNotification--;
}
core.Map<core.String, core.String> buildUnnamed4() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed4(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterChannel = 0;
api.Channel buildChannel() {
final o = api.Channel();
buildCounterChannel++;
if (buildCounterChannel < 3) {
o.address = 'foo';
o.expiration = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.params = buildUnnamed4();
o.payload = true;
o.resourceId = 'foo';
o.resourceUri = 'foo';
o.token = 'foo';
o.type = 'foo';
}
buildCounterChannel--;
return o;
}
void checkChannel(api.Channel o) {
buildCounterChannel++;
if (buildCounterChannel < 3) {
unittest.expect(
o.address!,
unittest.equals('foo'),
);
unittest.expect(
o.expiration!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed4(o.params!);
unittest.expect(o.payload!, unittest.isTrue);
unittest.expect(
o.resourceId!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
unittest.expect(
o.token!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterChannel--;
}
core.int buildCounterColorDefinition = 0;
api.ColorDefinition buildColorDefinition() {
final o = api.ColorDefinition();
buildCounterColorDefinition++;
if (buildCounterColorDefinition < 3) {
o.background = 'foo';
o.foreground = 'foo';
}
buildCounterColorDefinition--;
return o;
}
void checkColorDefinition(api.ColorDefinition o) {
buildCounterColorDefinition++;
if (buildCounterColorDefinition < 3) {
unittest.expect(
o.background!,
unittest.equals('foo'),
);
unittest.expect(
o.foreground!,
unittest.equals('foo'),
);
}
buildCounterColorDefinition--;
}
core.Map<core.String, api.ColorDefinition> buildUnnamed5() => {
'x': buildColorDefinition(),
'y': buildColorDefinition(),
};
void checkUnnamed5(core.Map<core.String, api.ColorDefinition> o) {
unittest.expect(o, unittest.hasLength(2));
checkColorDefinition(o['x']!);
checkColorDefinition(o['y']!);
}
core.Map<core.String, api.ColorDefinition> buildUnnamed6() => {
'x': buildColorDefinition(),
'y': buildColorDefinition(),
};
void checkUnnamed6(core.Map<core.String, api.ColorDefinition> o) {
unittest.expect(o, unittest.hasLength(2));
checkColorDefinition(o['x']!);
checkColorDefinition(o['y']!);
}
core.int buildCounterColors = 0;
api.Colors buildColors() {
final o = api.Colors();
buildCounterColors++;
if (buildCounterColors < 3) {
o.calendar = buildUnnamed5();
o.event = buildUnnamed6();
o.kind = 'foo';
o.updated = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterColors--;
return o;
}
void checkColors(api.Colors o) {
buildCounterColors++;
if (buildCounterColors < 3) {
checkUnnamed5(o.calendar!);
checkUnnamed6(o.event!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.updated!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
}
buildCounterColors--;
}
core.List<api.EntryPoint> buildUnnamed7() => [
buildEntryPoint(),
buildEntryPoint(),
];
void checkUnnamed7(core.List<api.EntryPoint> o) {
unittest.expect(o, unittest.hasLength(2));
checkEntryPoint(o[0]);
checkEntryPoint(o[1]);
}
core.int buildCounterConferenceData = 0;
api.ConferenceData buildConferenceData() {
final o = api.ConferenceData();
buildCounterConferenceData++;
if (buildCounterConferenceData < 3) {
o.conferenceId = 'foo';
o.conferenceSolution = buildConferenceSolution();
o.createRequest = buildCreateConferenceRequest();
o.entryPoints = buildUnnamed7();
o.notes = 'foo';
o.parameters = buildConferenceParameters();
o.signature = 'foo';
}
buildCounterConferenceData--;
return o;
}
void checkConferenceData(api.ConferenceData o) {
buildCounterConferenceData++;
if (buildCounterConferenceData < 3) {
unittest.expect(
o.conferenceId!,
unittest.equals('foo'),
);
checkConferenceSolution(o.conferenceSolution!);
checkCreateConferenceRequest(o.createRequest!);
checkUnnamed7(o.entryPoints!);
unittest.expect(
o.notes!,
unittest.equals('foo'),
);
checkConferenceParameters(o.parameters!);
unittest.expect(
o.signature!,
unittest.equals('foo'),
);
}
buildCounterConferenceData--;
}
core.int buildCounterConferenceParameters = 0;
api.ConferenceParameters buildConferenceParameters() {
final o = api.ConferenceParameters();
buildCounterConferenceParameters++;
if (buildCounterConferenceParameters < 3) {
o.addOnParameters = buildConferenceParametersAddOnParameters();
}
buildCounterConferenceParameters--;
return o;
}
void checkConferenceParameters(api.ConferenceParameters o) {
buildCounterConferenceParameters++;
if (buildCounterConferenceParameters < 3) {
checkConferenceParametersAddOnParameters(o.addOnParameters!);
}
buildCounterConferenceParameters--;
}
core.Map<core.String, core.String> buildUnnamed8() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed8(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterConferenceParametersAddOnParameters = 0;
api.ConferenceParametersAddOnParameters
buildConferenceParametersAddOnParameters() {
final o = api.ConferenceParametersAddOnParameters();
buildCounterConferenceParametersAddOnParameters++;
if (buildCounterConferenceParametersAddOnParameters < 3) {
o.parameters = buildUnnamed8();
}
buildCounterConferenceParametersAddOnParameters--;
return o;
}
void checkConferenceParametersAddOnParameters(
api.ConferenceParametersAddOnParameters o) {
buildCounterConferenceParametersAddOnParameters++;
if (buildCounterConferenceParametersAddOnParameters < 3) {
checkUnnamed8(o.parameters!);
}
buildCounterConferenceParametersAddOnParameters--;
}
core.List<core.String> buildUnnamed9() => [
'foo',
'foo',
];
void checkUnnamed9(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterConferenceProperties = 0;
api.ConferenceProperties buildConferenceProperties() {
final o = api.ConferenceProperties();
buildCounterConferenceProperties++;
if (buildCounterConferenceProperties < 3) {
o.allowedConferenceSolutionTypes = buildUnnamed9();
}
buildCounterConferenceProperties--;
return o;
}
void checkConferenceProperties(api.ConferenceProperties o) {
buildCounterConferenceProperties++;
if (buildCounterConferenceProperties < 3) {
checkUnnamed9(o.allowedConferenceSolutionTypes!);
}
buildCounterConferenceProperties--;
}
core.int buildCounterConferenceRequestStatus = 0;
api.ConferenceRequestStatus buildConferenceRequestStatus() {
final o = api.ConferenceRequestStatus();
buildCounterConferenceRequestStatus++;
if (buildCounterConferenceRequestStatus < 3) {
o.statusCode = 'foo';
}
buildCounterConferenceRequestStatus--;
return o;
}
void checkConferenceRequestStatus(api.ConferenceRequestStatus o) {
buildCounterConferenceRequestStatus++;
if (buildCounterConferenceRequestStatus < 3) {
unittest.expect(
o.statusCode!,
unittest.equals('foo'),
);
}
buildCounterConferenceRequestStatus--;
}
core.int buildCounterConferenceSolution = 0;
api.ConferenceSolution buildConferenceSolution() {
final o = api.ConferenceSolution();
buildCounterConferenceSolution++;
if (buildCounterConferenceSolution < 3) {
o.iconUri = 'foo';
o.key = buildConferenceSolutionKey();
o.name = 'foo';
}
buildCounterConferenceSolution--;
return o;
}
void checkConferenceSolution(api.ConferenceSolution o) {
buildCounterConferenceSolution++;
if (buildCounterConferenceSolution < 3) {
unittest.expect(
o.iconUri!,
unittest.equals('foo'),
);
checkConferenceSolutionKey(o.key!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterConferenceSolution--;
}
core.int buildCounterConferenceSolutionKey = 0;
api.ConferenceSolutionKey buildConferenceSolutionKey() {
final o = api.ConferenceSolutionKey();
buildCounterConferenceSolutionKey++;
if (buildCounterConferenceSolutionKey < 3) {
o.type = 'foo';
}
buildCounterConferenceSolutionKey--;
return o;
}
void checkConferenceSolutionKey(api.ConferenceSolutionKey o) {
buildCounterConferenceSolutionKey++;
if (buildCounterConferenceSolutionKey < 3) {
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterConferenceSolutionKey--;
}
core.int buildCounterCreateConferenceRequest = 0;
api.CreateConferenceRequest buildCreateConferenceRequest() {
final o = api.CreateConferenceRequest();
buildCounterCreateConferenceRequest++;
if (buildCounterCreateConferenceRequest < 3) {
o.conferenceSolutionKey = buildConferenceSolutionKey();
o.requestId = 'foo';
o.status = buildConferenceRequestStatus();
}
buildCounterCreateConferenceRequest--;
return o;
}
void checkCreateConferenceRequest(api.CreateConferenceRequest o) {
buildCounterCreateConferenceRequest++;
if (buildCounterCreateConferenceRequest < 3) {
checkConferenceSolutionKey(o.conferenceSolutionKey!);
unittest.expect(
o.requestId!,
unittest.equals('foo'),
);
checkConferenceRequestStatus(o.status!);
}
buildCounterCreateConferenceRequest--;
}
core.List<core.String> buildUnnamed10() => [
'foo',
'foo',
];
void checkUnnamed10(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterEntryPoint = 0;
api.EntryPoint buildEntryPoint() {
final o = api.EntryPoint();
buildCounterEntryPoint++;
if (buildCounterEntryPoint < 3) {
o.accessCode = 'foo';
o.entryPointFeatures = buildUnnamed10();
o.entryPointType = 'foo';
o.label = 'foo';
o.meetingCode = 'foo';
o.passcode = 'foo';
o.password = 'foo';
o.pin = 'foo';
o.regionCode = 'foo';
o.uri = 'foo';
}
buildCounterEntryPoint--;
return o;
}
void checkEntryPoint(api.EntryPoint o) {
buildCounterEntryPoint++;
if (buildCounterEntryPoint < 3) {
unittest.expect(
o.accessCode!,
unittest.equals('foo'),
);
checkUnnamed10(o.entryPointFeatures!);
unittest.expect(
o.entryPointType!,
unittest.equals('foo'),
);
unittest.expect(
o.label!,
unittest.equals('foo'),
);
unittest.expect(
o.meetingCode!,
unittest.equals('foo'),
);
unittest.expect(
o.passcode!,
unittest.equals('foo'),
);
unittest.expect(
o.password!,
unittest.equals('foo'),
);
unittest.expect(
o.pin!,
unittest.equals('foo'),
);
unittest.expect(
o.regionCode!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterEntryPoint--;
}
core.int buildCounterError = 0;
api.Error buildError() {
final o = api.Error();
buildCounterError++;
if (buildCounterError < 3) {
o.domain = 'foo';
o.reason = 'foo';
}
buildCounterError--;
return o;
}
void checkError(api.Error o) {
buildCounterError++;
if (buildCounterError < 3) {
unittest.expect(
o.domain!,
unittest.equals('foo'),
);
unittest.expect(
o.reason!,
unittest.equals('foo'),
);
}
buildCounterError--;
}
core.List<api.EventAttachment> buildUnnamed11() => [
buildEventAttachment(),
buildEventAttachment(),
];
void checkUnnamed11(core.List<api.EventAttachment> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventAttachment(o[0]);
checkEventAttachment(o[1]);
}
core.List<api.EventAttendee> buildUnnamed12() => [
buildEventAttendee(),
buildEventAttendee(),
];
void checkUnnamed12(core.List<api.EventAttendee> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventAttendee(o[0]);
checkEventAttendee(o[1]);
}
core.int buildCounterEventCreator = 0;
api.EventCreator buildEventCreator() {
final o = api.EventCreator();
buildCounterEventCreator++;
if (buildCounterEventCreator < 3) {
o.displayName = 'foo';
o.email = 'foo';
o.id = 'foo';
o.self = true;
}
buildCounterEventCreator--;
return o;
}
void checkEventCreator(api.EventCreator o) {
buildCounterEventCreator++;
if (buildCounterEventCreator < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.self!, unittest.isTrue);
}
buildCounterEventCreator--;
}
core.Map<core.String, core.String> buildUnnamed13() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed13(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.String> buildUnnamed14() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed14(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterEventExtendedProperties = 0;
api.EventExtendedProperties buildEventExtendedProperties() {
final o = api.EventExtendedProperties();
buildCounterEventExtendedProperties++;
if (buildCounterEventExtendedProperties < 3) {
o.private = buildUnnamed13();
o.shared = buildUnnamed14();
}
buildCounterEventExtendedProperties--;
return o;
}
void checkEventExtendedProperties(api.EventExtendedProperties o) {
buildCounterEventExtendedProperties++;
if (buildCounterEventExtendedProperties < 3) {
checkUnnamed13(o.private!);
checkUnnamed14(o.shared!);
}
buildCounterEventExtendedProperties--;
}
core.Map<core.String, core.String> buildUnnamed15() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed15(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterEventGadget = 0;
api.EventGadget buildEventGadget() {
final o = api.EventGadget();
buildCounterEventGadget++;
if (buildCounterEventGadget < 3) {
o.display = 'foo';
o.height = 42;
o.iconLink = 'foo';
o.link = 'foo';
o.preferences = buildUnnamed15();
o.title = 'foo';
o.type = 'foo';
o.width = 42;
}
buildCounterEventGadget--;
return o;
}
void checkEventGadget(api.EventGadget o) {
buildCounterEventGadget++;
if (buildCounterEventGadget < 3) {
unittest.expect(
o.display!,
unittest.equals('foo'),
);
unittest.expect(
o.height!,
unittest.equals(42),
);
unittest.expect(
o.iconLink!,
unittest.equals('foo'),
);
unittest.expect(
o.link!,
unittest.equals('foo'),
);
checkUnnamed15(o.preferences!);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42),
);
}
buildCounterEventGadget--;
}
core.int buildCounterEventOrganizer = 0;
api.EventOrganizer buildEventOrganizer() {
final o = api.EventOrganizer();
buildCounterEventOrganizer++;
if (buildCounterEventOrganizer < 3) {
o.displayName = 'foo';
o.email = 'foo';
o.id = 'foo';
o.self = true;
}
buildCounterEventOrganizer--;
return o;
}
void checkEventOrganizer(api.EventOrganizer o) {
buildCounterEventOrganizer++;
if (buildCounterEventOrganizer < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.self!, unittest.isTrue);
}
buildCounterEventOrganizer--;
}
core.List<core.String> buildUnnamed16() => [
'foo',
'foo',
];
void checkUnnamed16(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.EventReminder> buildUnnamed17() => [
buildEventReminder(),
buildEventReminder(),
];
void checkUnnamed17(core.List<api.EventReminder> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventReminder(o[0]);
checkEventReminder(o[1]);
}
core.int buildCounterEventReminders = 0;
api.EventReminders buildEventReminders() {
final o = api.EventReminders();
buildCounterEventReminders++;
if (buildCounterEventReminders < 3) {
o.overrides = buildUnnamed17();
o.useDefault = true;
}
buildCounterEventReminders--;
return o;
}
void checkEventReminders(api.EventReminders o) {
buildCounterEventReminders++;
if (buildCounterEventReminders < 3) {
checkUnnamed17(o.overrides!);
unittest.expect(o.useDefault!, unittest.isTrue);
}
buildCounterEventReminders--;
}
core.int buildCounterEventSource = 0;
api.EventSource buildEventSource() {
final o = api.EventSource();
buildCounterEventSource++;
if (buildCounterEventSource < 3) {
o.title = 'foo';
o.url = 'foo';
}
buildCounterEventSource--;
return o;
}
void checkEventSource(api.EventSource o) {
buildCounterEventSource++;
if (buildCounterEventSource < 3) {
unittest.expect(
o.title!,
unittest.equals('foo'),
);
unittest.expect(
o.url!,
unittest.equals('foo'),
);
}
buildCounterEventSource--;
}
core.int buildCounterEvent = 0;
api.Event buildEvent() {
final o = api.Event();
buildCounterEvent++;
if (buildCounterEvent < 3) {
o.anyoneCanAddSelf = true;
o.attachments = buildUnnamed11();
o.attendees = buildUnnamed12();
o.attendeesOmitted = true;
o.colorId = 'foo';
o.conferenceData = buildConferenceData();
o.created = core.DateTime.parse('2002-02-27T14:01:02Z');
o.creator = buildEventCreator();
o.description = 'foo';
o.end = buildEventDateTime();
o.endTimeUnspecified = true;
o.etag = 'foo';
o.eventType = 'foo';
o.extendedProperties = buildEventExtendedProperties();
o.gadget = buildEventGadget();
o.guestsCanInviteOthers = true;
o.guestsCanModify = true;
o.guestsCanSeeOtherGuests = true;
o.hangoutLink = 'foo';
o.htmlLink = 'foo';
o.iCalUID = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.location = 'foo';
o.locked = true;
o.organizer = buildEventOrganizer();
o.originalStartTime = buildEventDateTime();
o.privateCopy = true;
o.recurrence = buildUnnamed16();
o.recurringEventId = 'foo';
o.reminders = buildEventReminders();
o.sequence = 42;
o.source = buildEventSource();
o.start = buildEventDateTime();
o.status = 'foo';
o.summary = 'foo';
o.transparency = 'foo';
o.updated = core.DateTime.parse('2002-02-27T14:01:02Z');
o.visibility = 'foo';
o.workingLocationProperties = buildEventWorkingLocationProperties();
}
buildCounterEvent--;
return o;
}
void checkEvent(api.Event o) {
buildCounterEvent++;
if (buildCounterEvent < 3) {
unittest.expect(o.anyoneCanAddSelf!, unittest.isTrue);
checkUnnamed11(o.attachments!);
checkUnnamed12(o.attendees!);
unittest.expect(o.attendeesOmitted!, unittest.isTrue);
unittest.expect(
o.colorId!,
unittest.equals('foo'),
);
checkConferenceData(o.conferenceData!);
unittest.expect(
o.created!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkEventCreator(o.creator!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkEventDateTime(o.end!);
unittest.expect(o.endTimeUnspecified!, unittest.isTrue);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.eventType!,
unittest.equals('foo'),
);
checkEventExtendedProperties(o.extendedProperties!);
checkEventGadget(o.gadget!);
unittest.expect(o.guestsCanInviteOthers!, unittest.isTrue);
unittest.expect(o.guestsCanModify!, unittest.isTrue);
unittest.expect(o.guestsCanSeeOtherGuests!, unittest.isTrue);
unittest.expect(
o.hangoutLink!,
unittest.equals('foo'),
);
unittest.expect(
o.htmlLink!,
unittest.equals('foo'),
);
unittest.expect(
o.iCalUID!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(o.locked!, unittest.isTrue);
checkEventOrganizer(o.organizer!);
checkEventDateTime(o.originalStartTime!);
unittest.expect(o.privateCopy!, unittest.isTrue);
checkUnnamed16(o.recurrence!);
unittest.expect(
o.recurringEventId!,
unittest.equals('foo'),
);
checkEventReminders(o.reminders!);
unittest.expect(
o.sequence!,
unittest.equals(42),
);
checkEventSource(o.source!);
checkEventDateTime(o.start!);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.summary!,
unittest.equals('foo'),
);
unittest.expect(
o.transparency!,
unittest.equals('foo'),
);
unittest.expect(
o.updated!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.visibility!,
unittest.equals('foo'),
);
checkEventWorkingLocationProperties(o.workingLocationProperties!);
}
buildCounterEvent--;
}
core.int buildCounterEventAttachment = 0;
api.EventAttachment buildEventAttachment() {
final o = api.EventAttachment();
buildCounterEventAttachment++;
if (buildCounterEventAttachment < 3) {
o.fileId = 'foo';
o.fileUrl = 'foo';
o.iconLink = 'foo';
o.mimeType = 'foo';
o.title = 'foo';
}
buildCounterEventAttachment--;
return o;
}
void checkEventAttachment(api.EventAttachment o) {
buildCounterEventAttachment++;
if (buildCounterEventAttachment < 3) {
unittest.expect(
o.fileId!,
unittest.equals('foo'),
);
unittest.expect(
o.fileUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.iconLink!,
unittest.equals('foo'),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterEventAttachment--;
}
core.int buildCounterEventAttendee = 0;
api.EventAttendee buildEventAttendee() {
final o = api.EventAttendee();
buildCounterEventAttendee++;
if (buildCounterEventAttendee < 3) {
o.additionalGuests = 42;
o.comment = 'foo';
o.displayName = 'foo';
o.email = 'foo';
o.id = 'foo';
o.optional = true;
o.organizer = true;
o.resource = true;
o.responseStatus = 'foo';
o.self = true;
}
buildCounterEventAttendee--;
return o;
}
void checkEventAttendee(api.EventAttendee o) {
buildCounterEventAttendee++;
if (buildCounterEventAttendee < 3) {
unittest.expect(
o.additionalGuests!,
unittest.equals(42),
);
unittest.expect(
o.comment!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.optional!, unittest.isTrue);
unittest.expect(o.organizer!, unittest.isTrue);
unittest.expect(o.resource!, unittest.isTrue);
unittest.expect(
o.responseStatus!,
unittest.equals('foo'),
);
unittest.expect(o.self!, unittest.isTrue);
}
buildCounterEventAttendee--;
}
core.int buildCounterEventDateTime = 0;
api.EventDateTime buildEventDateTime() {
final o = api.EventDateTime();
buildCounterEventDateTime++;
if (buildCounterEventDateTime < 3) {
o.date = core.DateTime.parse('2002-02-27T14:01:02Z');
o.dateTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.timeZone = 'foo';
}
buildCounterEventDateTime--;
return o;
}
void checkEventDateTime(api.EventDateTime o) {
buildCounterEventDateTime++;
if (buildCounterEventDateTime < 3) {
unittest.expect(
o.date!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.dateTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.timeZone!,
unittest.equals('foo'),
);
}
buildCounterEventDateTime--;
}
core.int buildCounterEventReminder = 0;
api.EventReminder buildEventReminder() {
final o = api.EventReminder();
buildCounterEventReminder++;
if (buildCounterEventReminder < 3) {
o.method = 'foo';
o.minutes = 42;
}
buildCounterEventReminder--;
return o;
}
void checkEventReminder(api.EventReminder o) {
buildCounterEventReminder++;
if (buildCounterEventReminder < 3) {
unittest.expect(
o.method!,
unittest.equals('foo'),
);
unittest.expect(
o.minutes!,
unittest.equals(42),
);
}
buildCounterEventReminder--;
}
core.int buildCounterEventWorkingLocationPropertiesCustomLocation = 0;
api.EventWorkingLocationPropertiesCustomLocation
buildEventWorkingLocationPropertiesCustomLocation() {
final o = api.EventWorkingLocationPropertiesCustomLocation();
buildCounterEventWorkingLocationPropertiesCustomLocation++;
if (buildCounterEventWorkingLocationPropertiesCustomLocation < 3) {
o.label = 'foo';
}
buildCounterEventWorkingLocationPropertiesCustomLocation--;
return o;
}
void checkEventWorkingLocationPropertiesCustomLocation(
api.EventWorkingLocationPropertiesCustomLocation o) {
buildCounterEventWorkingLocationPropertiesCustomLocation++;
if (buildCounterEventWorkingLocationPropertiesCustomLocation < 3) {
unittest.expect(
o.label!,
unittest.equals('foo'),
);
}
buildCounterEventWorkingLocationPropertiesCustomLocation--;
}
core.int buildCounterEventWorkingLocationPropertiesOfficeLocation = 0;
api.EventWorkingLocationPropertiesOfficeLocation
buildEventWorkingLocationPropertiesOfficeLocation() {
final o = api.EventWorkingLocationPropertiesOfficeLocation();
buildCounterEventWorkingLocationPropertiesOfficeLocation++;
if (buildCounterEventWorkingLocationPropertiesOfficeLocation < 3) {
o.buildingId = 'foo';
o.deskId = 'foo';
o.floorId = 'foo';
o.floorSectionId = 'foo';
o.label = 'foo';
}
buildCounterEventWorkingLocationPropertiesOfficeLocation--;
return o;
}
void checkEventWorkingLocationPropertiesOfficeLocation(
api.EventWorkingLocationPropertiesOfficeLocation o) {
buildCounterEventWorkingLocationPropertiesOfficeLocation++;
if (buildCounterEventWorkingLocationPropertiesOfficeLocation < 3) {
unittest.expect(
o.buildingId!,
unittest.equals('foo'),
);
unittest.expect(
o.deskId!,
unittest.equals('foo'),
);
unittest.expect(
o.floorId!,
unittest.equals('foo'),
);
unittest.expect(
o.floorSectionId!,
unittest.equals('foo'),
);
unittest.expect(
o.label!,
unittest.equals('foo'),
);
}
buildCounterEventWorkingLocationPropertiesOfficeLocation--;
}
core.int buildCounterEventWorkingLocationProperties = 0;
api.EventWorkingLocationProperties buildEventWorkingLocationProperties() {
final o = api.EventWorkingLocationProperties();
buildCounterEventWorkingLocationProperties++;
if (buildCounterEventWorkingLocationProperties < 3) {
o.customLocation = buildEventWorkingLocationPropertiesCustomLocation();
o.homeOffice = {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
};
o.officeLocation = buildEventWorkingLocationPropertiesOfficeLocation();
o.type = 'foo';
}
buildCounterEventWorkingLocationProperties--;
return o;
}
void checkEventWorkingLocationProperties(api.EventWorkingLocationProperties o) {
buildCounterEventWorkingLocationProperties++;
if (buildCounterEventWorkingLocationProperties < 3) {
checkEventWorkingLocationPropertiesCustomLocation(o.customLocation!);
var casted1 = (o.homeOffice!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
checkEventWorkingLocationPropertiesOfficeLocation(o.officeLocation!);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterEventWorkingLocationProperties--;
}
core.List<api.EventReminder> buildUnnamed18() => [
buildEventReminder(),
buildEventReminder(),
];
void checkUnnamed18(core.List<api.EventReminder> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventReminder(o[0]);
checkEventReminder(o[1]);
}
core.List<api.Event> buildUnnamed19() => [
buildEvent(),
buildEvent(),
];
void checkUnnamed19(core.List<api.Event> o) {
unittest.expect(o, unittest.hasLength(2));
checkEvent(o[0]);
checkEvent(o[1]);
}
core.int buildCounterEvents = 0;
api.Events buildEvents() {
final o = api.Events();
buildCounterEvents++;
if (buildCounterEvents < 3) {
o.accessRole = 'foo';
o.defaultReminders = buildUnnamed18();
o.description = 'foo';
o.etag = 'foo';
o.items = buildUnnamed19();
o.kind = 'foo';
o.nextPageToken = 'foo';
o.nextSyncToken = 'foo';
o.summary = 'foo';
o.timeZone = 'foo';
o.updated = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterEvents--;
return o;
}
void checkEvents(api.Events o) {
buildCounterEvents++;
if (buildCounterEvents < 3) {
unittest.expect(
o.accessRole!,
unittest.equals('foo'),
);
checkUnnamed18(o.defaultReminders!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed19(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.nextSyncToken!,
unittest.equals('foo'),
);
unittest.expect(
o.summary!,
unittest.equals('foo'),
);
unittest.expect(
o.timeZone!,
unittest.equals('foo'),
);
unittest.expect(
o.updated!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
}
buildCounterEvents--;
}
core.List<api.TimePeriod> buildUnnamed20() => [
buildTimePeriod(),
buildTimePeriod(),
];
void checkUnnamed20(core.List<api.TimePeriod> o) {
unittest.expect(o, unittest.hasLength(2));
checkTimePeriod(o[0]);
checkTimePeriod(o[1]);
}
core.List<api.Error> buildUnnamed21() => [
buildError(),
buildError(),
];
void checkUnnamed21(core.List<api.Error> o) {
unittest.expect(o, unittest.hasLength(2));
checkError(o[0]);
checkError(o[1]);
}
core.int buildCounterFreeBusyCalendar = 0;
api.FreeBusyCalendar buildFreeBusyCalendar() {
final o = api.FreeBusyCalendar();
buildCounterFreeBusyCalendar++;
if (buildCounterFreeBusyCalendar < 3) {
o.busy = buildUnnamed20();
o.errors = buildUnnamed21();
}
buildCounterFreeBusyCalendar--;
return o;
}
void checkFreeBusyCalendar(api.FreeBusyCalendar o) {
buildCounterFreeBusyCalendar++;
if (buildCounterFreeBusyCalendar < 3) {
checkUnnamed20(o.busy!);
checkUnnamed21(o.errors!);
}
buildCounterFreeBusyCalendar--;
}
core.List<core.String> buildUnnamed22() => [
'foo',
'foo',
];
void checkUnnamed22(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.Error> buildUnnamed23() => [
buildError(),
buildError(),
];
void checkUnnamed23(core.List<api.Error> o) {
unittest.expect(o, unittest.hasLength(2));
checkError(o[0]);
checkError(o[1]);
}
core.int buildCounterFreeBusyGroup = 0;
api.FreeBusyGroup buildFreeBusyGroup() {
final o = api.FreeBusyGroup();
buildCounterFreeBusyGroup++;
if (buildCounterFreeBusyGroup < 3) {
o.calendars = buildUnnamed22();
o.errors = buildUnnamed23();
}
buildCounterFreeBusyGroup--;
return o;
}
void checkFreeBusyGroup(api.FreeBusyGroup o) {
buildCounterFreeBusyGroup++;
if (buildCounterFreeBusyGroup < 3) {
checkUnnamed22(o.calendars!);
checkUnnamed23(o.errors!);
}
buildCounterFreeBusyGroup--;
}
core.List<api.FreeBusyRequestItem> buildUnnamed24() => [
buildFreeBusyRequestItem(),
buildFreeBusyRequestItem(),
];
void checkUnnamed24(core.List<api.FreeBusyRequestItem> o) {
unittest.expect(o, unittest.hasLength(2));
checkFreeBusyRequestItem(o[0]);
checkFreeBusyRequestItem(o[1]);
}
core.int buildCounterFreeBusyRequest = 0;
api.FreeBusyRequest buildFreeBusyRequest() {
final o = api.FreeBusyRequest();
buildCounterFreeBusyRequest++;
if (buildCounterFreeBusyRequest < 3) {
o.calendarExpansionMax = 42;
o.groupExpansionMax = 42;
o.items = buildUnnamed24();
o.timeMax = core.DateTime.parse('2002-02-27T14:01:02Z');
o.timeMin = core.DateTime.parse('2002-02-27T14:01:02Z');
o.timeZone = 'foo';
}
buildCounterFreeBusyRequest--;
return o;
}
void checkFreeBusyRequest(api.FreeBusyRequest o) {
buildCounterFreeBusyRequest++;
if (buildCounterFreeBusyRequest < 3) {
unittest.expect(
o.calendarExpansionMax!,
unittest.equals(42),
);
unittest.expect(
o.groupExpansionMax!,
unittest.equals(42),
);
checkUnnamed24(o.items!);
unittest.expect(
o.timeMax!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.timeMin!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.timeZone!,
unittest.equals('foo'),
);
}
buildCounterFreeBusyRequest--;
}
core.int buildCounterFreeBusyRequestItem = 0;
api.FreeBusyRequestItem buildFreeBusyRequestItem() {
final o = api.FreeBusyRequestItem();
buildCounterFreeBusyRequestItem++;
if (buildCounterFreeBusyRequestItem < 3) {
o.id = 'foo';
}
buildCounterFreeBusyRequestItem--;
return o;
}
void checkFreeBusyRequestItem(api.FreeBusyRequestItem o) {
buildCounterFreeBusyRequestItem++;
if (buildCounterFreeBusyRequestItem < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
}
buildCounterFreeBusyRequestItem--;
}
core.Map<core.String, api.FreeBusyCalendar> buildUnnamed25() => {
'x': buildFreeBusyCalendar(),
'y': buildFreeBusyCalendar(),
};
void checkUnnamed25(core.Map<core.String, api.FreeBusyCalendar> o) {
unittest.expect(o, unittest.hasLength(2));
checkFreeBusyCalendar(o['x']!);
checkFreeBusyCalendar(o['y']!);
}
core.Map<core.String, api.FreeBusyGroup> buildUnnamed26() => {
'x': buildFreeBusyGroup(),
'y': buildFreeBusyGroup(),
};
void checkUnnamed26(core.Map<core.String, api.FreeBusyGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkFreeBusyGroup(o['x']!);
checkFreeBusyGroup(o['y']!);
}
core.int buildCounterFreeBusyResponse = 0;
api.FreeBusyResponse buildFreeBusyResponse() {
final o = api.FreeBusyResponse();
buildCounterFreeBusyResponse++;
if (buildCounterFreeBusyResponse < 3) {
o.calendars = buildUnnamed25();
o.groups = buildUnnamed26();
o.kind = 'foo';
o.timeMax = core.DateTime.parse('2002-02-27T14:01:02Z');
o.timeMin = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterFreeBusyResponse--;
return o;
}
void checkFreeBusyResponse(api.FreeBusyResponse o) {
buildCounterFreeBusyResponse++;
if (buildCounterFreeBusyResponse < 3) {
checkUnnamed25(o.calendars!);
checkUnnamed26(o.groups!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.timeMax!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.timeMin!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
}
buildCounterFreeBusyResponse--;
}
core.int buildCounterSetting = 0;
api.Setting buildSetting() {
final o = api.Setting();
buildCounterSetting++;
if (buildCounterSetting < 3) {
o.etag = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.value = 'foo';
}
buildCounterSetting--;
return o;
}
void checkSetting(api.Setting o) {
buildCounterSetting++;
if (buildCounterSetting < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterSetting--;
}
core.List<api.Setting> buildUnnamed27() => [
buildSetting(),
buildSetting(),
];
void checkUnnamed27(core.List<api.Setting> o) {
unittest.expect(o, unittest.hasLength(2));
checkSetting(o[0]);
checkSetting(o[1]);
}
core.int buildCounterSettings = 0;
api.Settings buildSettings() {
final o = api.Settings();
buildCounterSettings++;
if (buildCounterSettings < 3) {
o.etag = 'foo';
o.items = buildUnnamed27();
o.kind = 'foo';
o.nextPageToken = 'foo';
o.nextSyncToken = 'foo';
}
buildCounterSettings--;
return o;
}
void checkSettings(api.Settings o) {
buildCounterSettings++;
if (buildCounterSettings < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed27(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.nextSyncToken!,
unittest.equals('foo'),
);
}
buildCounterSettings--;
}
core.int buildCounterTimePeriod = 0;
api.TimePeriod buildTimePeriod() {
final o = api.TimePeriod();
buildCounterTimePeriod++;
if (buildCounterTimePeriod < 3) {
o.end = core.DateTime.parse('2002-02-27T14:01:02Z');
o.start = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterTimePeriod--;
return o;
}
void checkTimePeriod(api.TimePeriod o) {
buildCounterTimePeriod++;
if (buildCounterTimePeriod < 3) {
unittest.expect(
o.end!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.start!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
}
buildCounterTimePeriod--;
}
core.List<core.String> buildUnnamed28() => [
'foo',
'foo',
];
void checkUnnamed28(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed29() => [
'foo',
'foo',
];
void checkUnnamed29(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed30() => [
'foo',
'foo',
];
void checkUnnamed30(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed31() => [
'foo',
'foo',
];
void checkUnnamed31(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed32() => [
'foo',
'foo',
];
void checkUnnamed32(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed33() => [
'foo',
'foo',
];
void checkUnnamed33(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
void main() {
unittest.group('obj-schema-Acl', () {
unittest.test('to-json--from-json', () async {
final o = buildAcl();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Acl.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAcl(od);
});
});
unittest.group('obj-schema-AclRuleScope', () {
unittest.test('to-json--from-json', () async {
final o = buildAclRuleScope();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AclRuleScope.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAclRuleScope(od);
});
});
unittest.group('obj-schema-AclRule', () {
unittest.test('to-json--from-json', () async {
final o = buildAclRule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.AclRule.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAclRule(od);
});
});
unittest.group('obj-schema-Calendar', () {
unittest.test('to-json--from-json', () async {
final o = buildCalendar();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Calendar.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCalendar(od);
});
});
unittest.group('obj-schema-CalendarList', () {
unittest.test('to-json--from-json', () async {
final o = buildCalendarList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CalendarList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCalendarList(od);
});
});
unittest.group('obj-schema-CalendarListEntryNotificationSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildCalendarListEntryNotificationSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CalendarListEntryNotificationSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCalendarListEntryNotificationSettings(od);
});
});
unittest.group('obj-schema-CalendarListEntry', () {
unittest.test('to-json--from-json', () async {
final o = buildCalendarListEntry();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CalendarListEntry.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCalendarListEntry(od);
});
});
unittest.group('obj-schema-CalendarNotification', () {
unittest.test('to-json--from-json', () async {
final o = buildCalendarNotification();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CalendarNotification.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCalendarNotification(od);
});
});
unittest.group('obj-schema-Channel', () {
unittest.test('to-json--from-json', () async {
final o = buildChannel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Channel.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkChannel(od);
});
});
unittest.group('obj-schema-ColorDefinition', () {
unittest.test('to-json--from-json', () async {
final o = buildColorDefinition();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ColorDefinition.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkColorDefinition(od);
});
});
unittest.group('obj-schema-Colors', () {
unittest.test('to-json--from-json', () async {
final o = buildColors();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Colors.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkColors(od);
});
});
unittest.group('obj-schema-ConferenceData', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceData();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceData.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceData(od);
});
});
unittest.group('obj-schema-ConferenceParameters', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceParameters();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceParameters.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceParameters(od);
});
});
unittest.group('obj-schema-ConferenceParametersAddOnParameters', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceParametersAddOnParameters();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceParametersAddOnParameters.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceParametersAddOnParameters(od);
});
});
unittest.group('obj-schema-ConferenceProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceProperties(od);
});
});
unittest.group('obj-schema-ConferenceRequestStatus', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceRequestStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceRequestStatus.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceRequestStatus(od);
});
});
unittest.group('obj-schema-ConferenceSolution', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceSolution();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceSolution.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceSolution(od);
});
});
unittest.group('obj-schema-ConferenceSolutionKey', () {
unittest.test('to-json--from-json', () async {
final o = buildConferenceSolutionKey();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConferenceSolutionKey.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConferenceSolutionKey(od);
});
});
unittest.group('obj-schema-CreateConferenceRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateConferenceRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateConferenceRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateConferenceRequest(od);
});
});
unittest.group('obj-schema-EntryPoint', () {
unittest.test('to-json--from-json', () async {
final o = buildEntryPoint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.EntryPoint.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEntryPoint(od);
});
});
unittest.group('obj-schema-Error', () {
unittest.test('to-json--from-json', () async {
final o = buildError();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Error.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkError(od);
});
});
unittest.group('obj-schema-EventCreator', () {
unittest.test('to-json--from-json', () async {
final o = buildEventCreator();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventCreator.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventCreator(od);
});
});
unittest.group('obj-schema-EventExtendedProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildEventExtendedProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventExtendedProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventExtendedProperties(od);
});
});
unittest.group('obj-schema-EventGadget', () {
unittest.test('to-json--from-json', () async {
final o = buildEventGadget();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventGadget.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventGadget(od);
});
});
unittest.group('obj-schema-EventOrganizer', () {
unittest.test('to-json--from-json', () async {
final o = buildEventOrganizer();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventOrganizer.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventOrganizer(od);
});
});
unittest.group('obj-schema-EventReminders', () {
unittest.test('to-json--from-json', () async {
final o = buildEventReminders();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventReminders.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventReminders(od);
});
});
unittest.group('obj-schema-EventSource', () {
unittest.test('to-json--from-json', () async {
final o = buildEventSource();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventSource.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventSource(od);
});
});
unittest.group('obj-schema-Event', () {
unittest.test('to-json--from-json', () async {
final o = buildEvent();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Event.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEvent(od);
});
});
unittest.group('obj-schema-EventAttachment', () {
unittest.test('to-json--from-json', () async {
final o = buildEventAttachment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventAttachment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventAttachment(od);
});
});
unittest.group('obj-schema-EventAttendee', () {
unittest.test('to-json--from-json', () async {
final o = buildEventAttendee();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventAttendee.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventAttendee(od);
});
});
unittest.group('obj-schema-EventDateTime', () {
unittest.test('to-json--from-json', () async {
final o = buildEventDateTime();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventDateTime.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventDateTime(od);
});
});
unittest.group('obj-schema-EventReminder', () {
unittest.test('to-json--from-json', () async {
final o = buildEventReminder();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventReminder.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventReminder(od);
});
});
unittest.group('obj-schema-EventWorkingLocationPropertiesCustomLocation', () {
unittest.test('to-json--from-json', () async {
final o = buildEventWorkingLocationPropertiesCustomLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventWorkingLocationPropertiesCustomLocation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventWorkingLocationPropertiesCustomLocation(od);
});
});
unittest.group('obj-schema-EventWorkingLocationPropertiesOfficeLocation', () {
unittest.test('to-json--from-json', () async {
final o = buildEventWorkingLocationPropertiesOfficeLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventWorkingLocationPropertiesOfficeLocation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventWorkingLocationPropertiesOfficeLocation(od);
});
});
unittest.group('obj-schema-EventWorkingLocationProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildEventWorkingLocationProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventWorkingLocationProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventWorkingLocationProperties(od);
});
});
unittest.group('obj-schema-Events', () {
unittest.test('to-json--from-json', () async {
final o = buildEvents();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Events.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEvents(od);
});
});
unittest.group('obj-schema-FreeBusyCalendar', () {
unittest.test('to-json--from-json', () async {
final o = buildFreeBusyCalendar();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FreeBusyCalendar.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFreeBusyCalendar(od);
});
});
unittest.group('obj-schema-FreeBusyGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildFreeBusyGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FreeBusyGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFreeBusyGroup(od);
});
});
unittest.group('obj-schema-FreeBusyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildFreeBusyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FreeBusyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFreeBusyRequest(od);
});
});
unittest.group('obj-schema-FreeBusyRequestItem', () {
unittest.test('to-json--from-json', () async {
final o = buildFreeBusyRequestItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FreeBusyRequestItem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFreeBusyRequestItem(od);
});
});
unittest.group('obj-schema-FreeBusyResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFreeBusyResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FreeBusyResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFreeBusyResponse(od);
});
});
unittest.group('obj-schema-Setting', () {
unittest.test('to-json--from-json', () async {
final o = buildSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Setting.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSetting(od);
});
});
unittest.group('obj-schema-Settings', () {
unittest.test('to-json--from-json', () async {
final o = buildSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Settings.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSettings(od);
});
});
unittest.group('obj-schema-TimePeriod', () {
unittest.test('to-json--from-json', () async {
final o = buildTimePeriod();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TimePeriod.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTimePeriod(od);
});
});
unittest.group('resource-AclResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_calendarId = 'foo';
final arg_ruleId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/acl/'),
);
pathOffset += 5;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_ruleId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_calendarId, arg_ruleId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_calendarId = 'foo';
final arg_ruleId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/acl/'),
);
pathOffset += 5;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_ruleId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAclRule());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_calendarId, arg_ruleId, $fields: arg_$fields);
checkAclRule(response as api.AclRule);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_request = buildAclRule();
final arg_calendarId = 'foo';
final arg_sendNotifications = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.AclRule.fromJson(json as core.Map<core.String, core.dynamic>);
checkAclRule(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 4),
unittest.equals('/acl'),
);
pathOffset += 4;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAclRule());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(arg_request, arg_calendarId,
sendNotifications: arg_sendNotifications, $fields: arg_$fields);
checkAclRule(response as api.AclRule);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_calendarId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_showDeleted = true;
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 4),
unittest.equals('/acl'),
);
pathOffset += 4;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAcl());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_calendarId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
showDeleted: arg_showDeleted,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkAcl(response as api.Acl);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_request = buildAclRule();
final arg_calendarId = 'foo';
final arg_ruleId = 'foo';
final arg_sendNotifications = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.AclRule.fromJson(json as core.Map<core.String, core.dynamic>);
checkAclRule(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/acl/'),
);
pathOffset += 5;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_ruleId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAclRule());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_calendarId, arg_ruleId,
sendNotifications: arg_sendNotifications, $fields: arg_$fields);
checkAclRule(response as api.AclRule);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_request = buildAclRule();
final arg_calendarId = 'foo';
final arg_ruleId = 'foo';
final arg_sendNotifications = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.AclRule.fromJson(json as core.Map<core.String, core.dynamic>);
checkAclRule(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/acl/'),
);
pathOffset += 5;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_ruleId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAclRule());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_calendarId, arg_ruleId,
sendNotifications: arg_sendNotifications, $fields: arg_$fields);
checkAclRule(response as api.AclRule);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).acl;
final arg_request = buildChannel();
final arg_calendarId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_showDeleted = true;
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/acl/watch', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/acl/watch'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request, arg_calendarId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
showDeleted: arg_showDeleted,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
unittest.group('resource-CalendarListResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('users/me/calendarList/'),
);
pathOffset += 22;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_calendarId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('users/me/calendarList/'),
);
pathOffset += 22;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendarListEntry());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_calendarId, $fields: arg_$fields);
checkCalendarListEntry(response as api.CalendarListEntry);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_request = buildCalendarListEntry();
final arg_colorRgbFormat = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CalendarListEntry.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCalendarListEntry(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 21),
unittest.equals('users/me/calendarList'),
);
pathOffset += 21;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['colorRgbFormat']!.first,
unittest.equals('$arg_colorRgbFormat'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendarListEntry());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(arg_request,
colorRgbFormat: arg_colorRgbFormat, $fields: arg_$fields);
checkCalendarListEntry(response as api.CalendarListEntry);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_maxResults = 42;
final arg_minAccessRole = 'foo';
final arg_pageToken = 'foo';
final arg_showDeleted = true;
final arg_showHidden = true;
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 21),
unittest.equals('users/me/calendarList'),
);
pathOffset += 21;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['minAccessRole']!.first,
unittest.equals(arg_minAccessRole),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['showHidden']!.first,
unittest.equals('$arg_showHidden'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendarList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
maxResults: arg_maxResults,
minAccessRole: arg_minAccessRole,
pageToken: arg_pageToken,
showDeleted: arg_showDeleted,
showHidden: arg_showHidden,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkCalendarList(response as api.CalendarList);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_request = buildCalendarListEntry();
final arg_calendarId = 'foo';
final arg_colorRgbFormat = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CalendarListEntry.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCalendarListEntry(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('users/me/calendarList/'),
);
pathOffset += 22;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['colorRgbFormat']!.first,
unittest.equals('$arg_colorRgbFormat'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendarListEntry());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_calendarId,
colorRgbFormat: arg_colorRgbFormat, $fields: arg_$fields);
checkCalendarListEntry(response as api.CalendarListEntry);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_request = buildCalendarListEntry();
final arg_calendarId = 'foo';
final arg_colorRgbFormat = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CalendarListEntry.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCalendarListEntry(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('users/me/calendarList/'),
);
pathOffset += 22;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['colorRgbFormat']!.first,
unittest.equals('$arg_colorRgbFormat'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendarListEntry());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_calendarId,
colorRgbFormat: arg_colorRgbFormat, $fields: arg_$fields);
checkCalendarListEntry(response as api.CalendarListEntry);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendarList;
final arg_request = buildChannel();
final arg_maxResults = 42;
final arg_minAccessRole = 'foo';
final arg_pageToken = 'foo';
final arg_showDeleted = true;
final arg_showHidden = true;
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 27),
unittest.equals('users/me/calendarList/watch'),
);
pathOffset += 27;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['minAccessRole']!.first,
unittest.equals(arg_minAccessRole),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['showHidden']!.first,
unittest.equals('$arg_showHidden'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request,
maxResults: arg_maxResults,
minAccessRole: arg_minAccessRole,
pageToken: arg_pageToken,
showDeleted: arg_showDeleted,
showHidden: arg_showHidden,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
unittest.group('resource-CalendarsResource', () {
unittest.test('method--clear', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/clear', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('/clear'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.clear(arg_calendarId, $fields: arg_$fields);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_calendarId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendar());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_calendarId, $fields: arg_$fields);
checkCalendar(response as api.Calendar);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_request = buildCalendar();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Calendar.fromJson(json as core.Map<core.String, core.dynamic>);
checkCalendar(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('calendars'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendar());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(arg_request, $fields: arg_$fields);
checkCalendar(response as api.Calendar);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_request = buildCalendar();
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Calendar.fromJson(json as core.Map<core.String, core.dynamic>);
checkCalendar(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendar());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.patch(arg_request, arg_calendarId, $fields: arg_$fields);
checkCalendar(response as api.Calendar);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).calendars;
final arg_request = buildCalendar();
final arg_calendarId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Calendar.fromJson(json as core.Map<core.String, core.dynamic>);
checkCalendar(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCalendar());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_calendarId, $fields: arg_$fields);
checkCalendar(response as api.Calendar);
});
});
unittest.group('resource-ChannelsResource', () {
unittest.test('method--stop', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).channels;
final arg_request = buildChannel();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('channels/stop'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.stop(arg_request, $fields: arg_$fields);
});
});
unittest.group('resource-ColorsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).colors;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('colors'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildColors());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get($fields: arg_$fields);
checkColors(response as api.Colors);
});
});
unittest.group('resource-EventsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_calendarId, arg_eventId,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
$fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_maxAttendees = 42;
final arg_timeZone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
queryMap['timeZone']!.first,
unittest.equals(arg_timeZone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_calendarId, arg_eventId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
maxAttendees: arg_maxAttendees,
timeZone: arg_timeZone,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--import', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_request = buildEvent();
final arg_calendarId = 'foo';
final arg_conferenceDataVersion = 42;
final arg_supportsAttachments = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Event.fromJson(json as core.Map<core.String, core.dynamic>);
checkEvent(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/import', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 14),
unittest.equals('/events/import'),
);
pathOffset += 14;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['conferenceDataVersion']!.first),
unittest.equals(arg_conferenceDataVersion),
);
unittest.expect(
queryMap['supportsAttachments']!.first,
unittest.equals('$arg_supportsAttachments'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.import(arg_request, arg_calendarId,
conferenceDataVersion: arg_conferenceDataVersion,
supportsAttachments: arg_supportsAttachments,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_request = buildEvent();
final arg_calendarId = 'foo';
final arg_conferenceDataVersion = 42;
final arg_maxAttendees = 42;
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_supportsAttachments = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Event.fromJson(json as core.Map<core.String, core.dynamic>);
checkEvent(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/events'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['conferenceDataVersion']!.first),
unittest.equals(arg_conferenceDataVersion),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['supportsAttachments']!.first,
unittest.equals('$arg_supportsAttachments'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(arg_request, arg_calendarId,
conferenceDataVersion: arg_conferenceDataVersion,
maxAttendees: arg_maxAttendees,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
supportsAttachments: arg_supportsAttachments,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--instances', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_maxAttendees = 42;
final arg_maxResults = 42;
final arg_originalStart = 'foo';
final arg_pageToken = 'foo';
final arg_showDeleted = true;
final arg_timeMax = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeMin = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeZone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
index = path.indexOf('/instances', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/instances'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['originalStart']!.first,
unittest.equals(arg_originalStart),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMax']!.first),
unittest.equals(arg_timeMax),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMin']!.first),
unittest.equals(arg_timeMin),
);
unittest.expect(
queryMap['timeZone']!.first,
unittest.equals(arg_timeZone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvents());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.instances(arg_calendarId, arg_eventId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
maxAttendees: arg_maxAttendees,
maxResults: arg_maxResults,
originalStart: arg_originalStart,
pageToken: arg_pageToken,
showDeleted: arg_showDeleted,
timeMax: arg_timeMax,
timeMin: arg_timeMin,
timeZone: arg_timeZone,
$fields: arg_$fields);
checkEvents(response as api.Events);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_eventTypes = buildUnnamed28();
final arg_iCalUID = 'foo';
final arg_maxAttendees = 42;
final arg_maxResults = 42;
final arg_orderBy = 'foo';
final arg_pageToken = 'foo';
final arg_privateExtendedProperty = buildUnnamed29();
final arg_q = 'foo';
final arg_sharedExtendedProperty = buildUnnamed30();
final arg_showDeleted = true;
final arg_showHiddenInvitations = true;
final arg_singleEvents = true;
final arg_syncToken = 'foo';
final arg_timeMax = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeMin = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeZone = 'foo';
final arg_updatedMin = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/events'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
queryMap['eventTypes']!,
unittest.equals(arg_eventTypes),
);
unittest.expect(
queryMap['iCalUID']!.first,
unittest.equals(arg_iCalUID),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['privateExtendedProperty']!,
unittest.equals(arg_privateExtendedProperty),
);
unittest.expect(
queryMap['q']!.first,
unittest.equals(arg_q),
);
unittest.expect(
queryMap['sharedExtendedProperty']!,
unittest.equals(arg_sharedExtendedProperty),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['showHiddenInvitations']!.first,
unittest.equals('$arg_showHiddenInvitations'),
);
unittest.expect(
queryMap['singleEvents']!.first,
unittest.equals('$arg_singleEvents'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMax']!.first),
unittest.equals(arg_timeMax),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMin']!.first),
unittest.equals(arg_timeMin),
);
unittest.expect(
queryMap['timeZone']!.first,
unittest.equals(arg_timeZone),
);
unittest.expect(
core.DateTime.parse(queryMap['updatedMin']!.first),
unittest.equals(arg_updatedMin),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvents());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_calendarId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
eventTypes: arg_eventTypes,
iCalUID: arg_iCalUID,
maxAttendees: arg_maxAttendees,
maxResults: arg_maxResults,
orderBy: arg_orderBy,
pageToken: arg_pageToken,
privateExtendedProperty: arg_privateExtendedProperty,
q: arg_q,
sharedExtendedProperty: arg_sharedExtendedProperty,
showDeleted: arg_showDeleted,
showHiddenInvitations: arg_showHiddenInvitations,
singleEvents: arg_singleEvents,
syncToken: arg_syncToken,
timeMax: arg_timeMax,
timeMin: arg_timeMin,
timeZone: arg_timeZone,
updatedMin: arg_updatedMin,
$fields: arg_$fields);
checkEvents(response as api.Events);
});
unittest.test('method--move', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_destination = 'foo';
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
index = path.indexOf('/move', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/move'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['destination']!.first,
unittest.equals(arg_destination),
);
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.move(
arg_calendarId, arg_eventId, arg_destination,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_request = buildEvent();
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_conferenceDataVersion = 42;
final arg_maxAttendees = 42;
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_supportsAttachments = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Event.fromJson(json as core.Map<core.String, core.dynamic>);
checkEvent(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
core.int.parse(queryMap['conferenceDataVersion']!.first),
unittest.equals(arg_conferenceDataVersion),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['supportsAttachments']!.first,
unittest.equals('$arg_supportsAttachments'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_calendarId, arg_eventId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
conferenceDataVersion: arg_conferenceDataVersion,
maxAttendees: arg_maxAttendees,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
supportsAttachments: arg_supportsAttachments,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--quickAdd', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_calendarId = 'foo';
final arg_text = 'foo';
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/quickAdd', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('/events/quickAdd'),
);
pathOffset += 16;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['text']!.first,
unittest.equals(arg_text),
);
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.quickAdd(arg_calendarId, arg_text,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_request = buildEvent();
final arg_calendarId = 'foo';
final arg_eventId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_conferenceDataVersion = 42;
final arg_maxAttendees = 42;
final arg_sendNotifications = true;
final arg_sendUpdates = 'foo';
final arg_supportsAttachments = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Event.fromJson(json as core.Map<core.String, core.dynamic>);
checkEvent(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/events/'),
);
pathOffset += 8;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_eventId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
core.int.parse(queryMap['conferenceDataVersion']!.first),
unittest.equals(arg_conferenceDataVersion),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
queryMap['sendNotifications']!.first,
unittest.equals('$arg_sendNotifications'),
);
unittest.expect(
queryMap['sendUpdates']!.first,
unittest.equals(arg_sendUpdates),
);
unittest.expect(
queryMap['supportsAttachments']!.first,
unittest.equals('$arg_supportsAttachments'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEvent());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_calendarId, arg_eventId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
conferenceDataVersion: arg_conferenceDataVersion,
maxAttendees: arg_maxAttendees,
sendNotifications: arg_sendNotifications,
sendUpdates: arg_sendUpdates,
supportsAttachments: arg_supportsAttachments,
$fields: arg_$fields);
checkEvent(response as api.Event);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).events;
final arg_request = buildChannel();
final arg_calendarId = 'foo';
final arg_alwaysIncludeEmail = true;
final arg_eventTypes = buildUnnamed31();
final arg_iCalUID = 'foo';
final arg_maxAttendees = 42;
final arg_maxResults = 42;
final arg_orderBy = 'foo';
final arg_pageToken = 'foo';
final arg_privateExtendedProperty = buildUnnamed32();
final arg_q = 'foo';
final arg_sharedExtendedProperty = buildUnnamed33();
final arg_showDeleted = true;
final arg_showHiddenInvitations = true;
final arg_singleEvents = true;
final arg_syncToken = 'foo';
final arg_timeMax = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeMin = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_timeZone = 'foo';
final arg_updatedMin = core.DateTime.parse('2002-02-27T14:01:02Z');
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('calendars/'),
);
pathOffset += 10;
index = path.indexOf('/events/watch', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_calendarId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/events/watch'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['alwaysIncludeEmail']!.first,
unittest.equals('$arg_alwaysIncludeEmail'),
);
unittest.expect(
queryMap['eventTypes']!,
unittest.equals(arg_eventTypes),
);
unittest.expect(
queryMap['iCalUID']!.first,
unittest.equals(arg_iCalUID),
);
unittest.expect(
core.int.parse(queryMap['maxAttendees']!.first),
unittest.equals(arg_maxAttendees),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['privateExtendedProperty']!,
unittest.equals(arg_privateExtendedProperty),
);
unittest.expect(
queryMap['q']!.first,
unittest.equals(arg_q),
);
unittest.expect(
queryMap['sharedExtendedProperty']!,
unittest.equals(arg_sharedExtendedProperty),
);
unittest.expect(
queryMap['showDeleted']!.first,
unittest.equals('$arg_showDeleted'),
);
unittest.expect(
queryMap['showHiddenInvitations']!.first,
unittest.equals('$arg_showHiddenInvitations'),
);
unittest.expect(
queryMap['singleEvents']!.first,
unittest.equals('$arg_singleEvents'),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMax']!.first),
unittest.equals(arg_timeMax),
);
unittest.expect(
core.DateTime.parse(queryMap['timeMin']!.first),
unittest.equals(arg_timeMin),
);
unittest.expect(
queryMap['timeZone']!.first,
unittest.equals(arg_timeZone),
);
unittest.expect(
core.DateTime.parse(queryMap['updatedMin']!.first),
unittest.equals(arg_updatedMin),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request, arg_calendarId,
alwaysIncludeEmail: arg_alwaysIncludeEmail,
eventTypes: arg_eventTypes,
iCalUID: arg_iCalUID,
maxAttendees: arg_maxAttendees,
maxResults: arg_maxResults,
orderBy: arg_orderBy,
pageToken: arg_pageToken,
privateExtendedProperty: arg_privateExtendedProperty,
q: arg_q,
sharedExtendedProperty: arg_sharedExtendedProperty,
showDeleted: arg_showDeleted,
showHiddenInvitations: arg_showHiddenInvitations,
singleEvents: arg_singleEvents,
syncToken: arg_syncToken,
timeMax: arg_timeMax,
timeMin: arg_timeMin,
timeZone: arg_timeZone,
updatedMin: arg_updatedMin,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
unittest.group('resource-FreebusyResource', () {
unittest.test('method--query', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).freebusy;
final arg_request = buildFreeBusyRequest();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FreeBusyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFreeBusyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('freeBusy'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFreeBusyResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.query(arg_request, $fields: arg_$fields);
checkFreeBusyResponse(response as api.FreeBusyResponse);
});
});
unittest.group('resource-SettingsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).settings;
final arg_setting = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 18),
unittest.equals('users/me/settings/'),
);
pathOffset += 18;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_setting'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSetting());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_setting, $fields: arg_$fields);
checkSetting(response as api.Setting);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).settings;
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 17),
unittest.equals('users/me/settings'),
);
pathOffset += 17;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
maxResults: arg_maxResults,
pageToken: arg_pageToken,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkSettings(response as api.Settings);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.CalendarApi(mock).settings;
final arg_request = buildChannel();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_syncToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('calendar/v3/'),
);
pathOffset += 12;
unittest.expect(
path.substring(pathOffset, pathOffset + 23),
unittest.equals('users/me/settings/watch'),
);
pathOffset += 23;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['syncToken']!.first,
unittest.equals(arg_syncToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
syncToken: arg_syncToken,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
}
|
googleapis.dart/generated/googleapis/test/calendar/v3_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/calendar/v3_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 81786}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/cloudkms/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterAsymmetricDecryptRequest = 0;
api.AsymmetricDecryptRequest buildAsymmetricDecryptRequest() {
final o = api.AsymmetricDecryptRequest();
buildCounterAsymmetricDecryptRequest++;
if (buildCounterAsymmetricDecryptRequest < 3) {
o.ciphertext = 'foo';
o.ciphertextCrc32c = 'foo';
}
buildCounterAsymmetricDecryptRequest--;
return o;
}
void checkAsymmetricDecryptRequest(api.AsymmetricDecryptRequest o) {
buildCounterAsymmetricDecryptRequest++;
if (buildCounterAsymmetricDecryptRequest < 3) {
unittest.expect(
o.ciphertext!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertextCrc32c!,
unittest.equals('foo'),
);
}
buildCounterAsymmetricDecryptRequest--;
}
core.int buildCounterAsymmetricDecryptResponse = 0;
api.AsymmetricDecryptResponse buildAsymmetricDecryptResponse() {
final o = api.AsymmetricDecryptResponse();
buildCounterAsymmetricDecryptResponse++;
if (buildCounterAsymmetricDecryptResponse < 3) {
o.plaintext = 'foo';
o.plaintextCrc32c = 'foo';
o.protectionLevel = 'foo';
o.verifiedCiphertextCrc32c = true;
}
buildCounterAsymmetricDecryptResponse--;
return o;
}
void checkAsymmetricDecryptResponse(api.AsymmetricDecryptResponse o) {
buildCounterAsymmetricDecryptResponse++;
if (buildCounterAsymmetricDecryptResponse < 3) {
unittest.expect(
o.plaintext!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(o.verifiedCiphertextCrc32c!, unittest.isTrue);
}
buildCounterAsymmetricDecryptResponse--;
}
core.int buildCounterAsymmetricSignRequest = 0;
api.AsymmetricSignRequest buildAsymmetricSignRequest() {
final o = api.AsymmetricSignRequest();
buildCounterAsymmetricSignRequest++;
if (buildCounterAsymmetricSignRequest < 3) {
o.data = 'foo';
o.dataCrc32c = 'foo';
o.digest = buildDigest();
o.digestCrc32c = 'foo';
}
buildCounterAsymmetricSignRequest--;
return o;
}
void checkAsymmetricSignRequest(api.AsymmetricSignRequest o) {
buildCounterAsymmetricSignRequest++;
if (buildCounterAsymmetricSignRequest < 3) {
unittest.expect(
o.data!,
unittest.equals('foo'),
);
unittest.expect(
o.dataCrc32c!,
unittest.equals('foo'),
);
checkDigest(o.digest!);
unittest.expect(
o.digestCrc32c!,
unittest.equals('foo'),
);
}
buildCounterAsymmetricSignRequest--;
}
core.int buildCounterAsymmetricSignResponse = 0;
api.AsymmetricSignResponse buildAsymmetricSignResponse() {
final o = api.AsymmetricSignResponse();
buildCounterAsymmetricSignResponse++;
if (buildCounterAsymmetricSignResponse < 3) {
o.name = 'foo';
o.protectionLevel = 'foo';
o.signature = 'foo';
o.signatureCrc32c = 'foo';
o.verifiedDataCrc32c = true;
o.verifiedDigestCrc32c = true;
}
buildCounterAsymmetricSignResponse--;
return o;
}
void checkAsymmetricSignResponse(api.AsymmetricSignResponse o) {
buildCounterAsymmetricSignResponse++;
if (buildCounterAsymmetricSignResponse < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(
o.signature!,
unittest.equals('foo'),
);
unittest.expect(
o.signatureCrc32c!,
unittest.equals('foo'),
);
unittest.expect(o.verifiedDataCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedDigestCrc32c!, unittest.isTrue);
}
buildCounterAsymmetricSignResponse--;
}
core.List<api.AuditLogConfig> buildUnnamed0() => [
buildAuditLogConfig(),
buildAuditLogConfig(),
];
void checkUnnamed0(core.List<api.AuditLogConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAuditLogConfig(o[0]);
checkAuditLogConfig(o[1]);
}
core.int buildCounterAuditConfig = 0;
api.AuditConfig buildAuditConfig() {
final o = api.AuditConfig();
buildCounterAuditConfig++;
if (buildCounterAuditConfig < 3) {
o.auditLogConfigs = buildUnnamed0();
o.service = 'foo';
}
buildCounterAuditConfig--;
return o;
}
void checkAuditConfig(api.AuditConfig o) {
buildCounterAuditConfig++;
if (buildCounterAuditConfig < 3) {
checkUnnamed0(o.auditLogConfigs!);
unittest.expect(
o.service!,
unittest.equals('foo'),
);
}
buildCounterAuditConfig--;
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAuditLogConfig = 0;
api.AuditLogConfig buildAuditLogConfig() {
final o = api.AuditLogConfig();
buildCounterAuditLogConfig++;
if (buildCounterAuditLogConfig < 3) {
o.exemptedMembers = buildUnnamed1();
o.logType = 'foo';
}
buildCounterAuditLogConfig--;
return o;
}
void checkAuditLogConfig(api.AuditLogConfig o) {
buildCounterAuditLogConfig++;
if (buildCounterAuditLogConfig < 3) {
checkUnnamed1(o.exemptedMembers!);
unittest.expect(
o.logType!,
unittest.equals('foo'),
);
}
buildCounterAuditLogConfig--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterBinding = 0;
api.Binding buildBinding() {
final o = api.Binding();
buildCounterBinding++;
if (buildCounterBinding < 3) {
o.condition = buildExpr();
o.members = buildUnnamed2();
o.role = 'foo';
}
buildCounterBinding--;
return o;
}
void checkBinding(api.Binding o) {
buildCounterBinding++;
if (buildCounterBinding < 3) {
checkExpr(o.condition!);
checkUnnamed2(o.members!);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
}
buildCounterBinding--;
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCertificate = 0;
api.Certificate buildCertificate() {
final o = api.Certificate();
buildCounterCertificate++;
if (buildCounterCertificate < 3) {
o.issuer = 'foo';
o.notAfterTime = 'foo';
o.notBeforeTime = 'foo';
o.parsed = true;
o.rawDer = 'foo';
o.serialNumber = 'foo';
o.sha256Fingerprint = 'foo';
o.subject = 'foo';
o.subjectAlternativeDnsNames = buildUnnamed3();
}
buildCounterCertificate--;
return o;
}
void checkCertificate(api.Certificate o) {
buildCounterCertificate++;
if (buildCounterCertificate < 3) {
unittest.expect(
o.issuer!,
unittest.equals('foo'),
);
unittest.expect(
o.notAfterTime!,
unittest.equals('foo'),
);
unittest.expect(
o.notBeforeTime!,
unittest.equals('foo'),
);
unittest.expect(o.parsed!, unittest.isTrue);
unittest.expect(
o.rawDer!,
unittest.equals('foo'),
);
unittest.expect(
o.serialNumber!,
unittest.equals('foo'),
);
unittest.expect(
o.sha256Fingerprint!,
unittest.equals('foo'),
);
unittest.expect(
o.subject!,
unittest.equals('foo'),
);
checkUnnamed3(o.subjectAlternativeDnsNames!);
}
buildCounterCertificate--;
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed5() => [
'foo',
'foo',
];
void checkUnnamed5(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed6() => [
'foo',
'foo',
];
void checkUnnamed6(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCertificateChains = 0;
api.CertificateChains buildCertificateChains() {
final o = api.CertificateChains();
buildCounterCertificateChains++;
if (buildCounterCertificateChains < 3) {
o.caviumCerts = buildUnnamed4();
o.googleCardCerts = buildUnnamed5();
o.googlePartitionCerts = buildUnnamed6();
}
buildCounterCertificateChains--;
return o;
}
void checkCertificateChains(api.CertificateChains o) {
buildCounterCertificateChains++;
if (buildCounterCertificateChains < 3) {
checkUnnamed4(o.caviumCerts!);
checkUnnamed5(o.googleCardCerts!);
checkUnnamed6(o.googlePartitionCerts!);
}
buildCounterCertificateChains--;
}
core.Map<core.String, core.String> buildUnnamed7() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed7(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterCryptoKey = 0;
api.CryptoKey buildCryptoKey() {
final o = api.CryptoKey();
buildCounterCryptoKey++;
if (buildCounterCryptoKey < 3) {
o.createTime = 'foo';
o.cryptoKeyBackend = 'foo';
o.destroyScheduledDuration = 'foo';
o.importOnly = true;
o.labels = buildUnnamed7();
o.name = 'foo';
o.nextRotationTime = 'foo';
o.primary = buildCryptoKeyVersion();
o.purpose = 'foo';
o.rotationPeriod = 'foo';
o.versionTemplate = buildCryptoKeyVersionTemplate();
}
buildCounterCryptoKey--;
return o;
}
void checkCryptoKey(api.CryptoKey o) {
buildCounterCryptoKey++;
if (buildCounterCryptoKey < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.cryptoKeyBackend!,
unittest.equals('foo'),
);
unittest.expect(
o.destroyScheduledDuration!,
unittest.equals('foo'),
);
unittest.expect(o.importOnly!, unittest.isTrue);
checkUnnamed7(o.labels!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.nextRotationTime!,
unittest.equals('foo'),
);
checkCryptoKeyVersion(o.primary!);
unittest.expect(
o.purpose!,
unittest.equals('foo'),
);
unittest.expect(
o.rotationPeriod!,
unittest.equals('foo'),
);
checkCryptoKeyVersionTemplate(o.versionTemplate!);
}
buildCounterCryptoKey--;
}
core.int buildCounterCryptoKeyVersion = 0;
api.CryptoKeyVersion buildCryptoKeyVersion() {
final o = api.CryptoKeyVersion();
buildCounterCryptoKeyVersion++;
if (buildCounterCryptoKeyVersion < 3) {
o.algorithm = 'foo';
o.attestation = buildKeyOperationAttestation();
o.createTime = 'foo';
o.destroyEventTime = 'foo';
o.destroyTime = 'foo';
o.externalDestructionFailureReason = 'foo';
o.externalProtectionLevelOptions = buildExternalProtectionLevelOptions();
o.generateTime = 'foo';
o.generationFailureReason = 'foo';
o.importFailureReason = 'foo';
o.importJob = 'foo';
o.importTime = 'foo';
o.name = 'foo';
o.protectionLevel = 'foo';
o.reimportEligible = true;
o.state = 'foo';
}
buildCounterCryptoKeyVersion--;
return o;
}
void checkCryptoKeyVersion(api.CryptoKeyVersion o) {
buildCounterCryptoKeyVersion++;
if (buildCounterCryptoKeyVersion < 3) {
unittest.expect(
o.algorithm!,
unittest.equals('foo'),
);
checkKeyOperationAttestation(o.attestation!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.destroyEventTime!,
unittest.equals('foo'),
);
unittest.expect(
o.destroyTime!,
unittest.equals('foo'),
);
unittest.expect(
o.externalDestructionFailureReason!,
unittest.equals('foo'),
);
checkExternalProtectionLevelOptions(o.externalProtectionLevelOptions!);
unittest.expect(
o.generateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.generationFailureReason!,
unittest.equals('foo'),
);
unittest.expect(
o.importFailureReason!,
unittest.equals('foo'),
);
unittest.expect(
o.importJob!,
unittest.equals('foo'),
);
unittest.expect(
o.importTime!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(o.reimportEligible!, unittest.isTrue);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterCryptoKeyVersion--;
}
core.int buildCounterCryptoKeyVersionTemplate = 0;
api.CryptoKeyVersionTemplate buildCryptoKeyVersionTemplate() {
final o = api.CryptoKeyVersionTemplate();
buildCounterCryptoKeyVersionTemplate++;
if (buildCounterCryptoKeyVersionTemplate < 3) {
o.algorithm = 'foo';
o.protectionLevel = 'foo';
}
buildCounterCryptoKeyVersionTemplate--;
return o;
}
void checkCryptoKeyVersionTemplate(api.CryptoKeyVersionTemplate o) {
buildCounterCryptoKeyVersionTemplate++;
if (buildCounterCryptoKeyVersionTemplate < 3) {
unittest.expect(
o.algorithm!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
}
buildCounterCryptoKeyVersionTemplate--;
}
core.int buildCounterDecryptRequest = 0;
api.DecryptRequest buildDecryptRequest() {
final o = api.DecryptRequest();
buildCounterDecryptRequest++;
if (buildCounterDecryptRequest < 3) {
o.additionalAuthenticatedData = 'foo';
o.additionalAuthenticatedDataCrc32c = 'foo';
o.ciphertext = 'foo';
o.ciphertextCrc32c = 'foo';
}
buildCounterDecryptRequest--;
return o;
}
void checkDecryptRequest(api.DecryptRequest o) {
buildCounterDecryptRequest++;
if (buildCounterDecryptRequest < 3) {
unittest.expect(
o.additionalAuthenticatedData!,
unittest.equals('foo'),
);
unittest.expect(
o.additionalAuthenticatedDataCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertext!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertextCrc32c!,
unittest.equals('foo'),
);
}
buildCounterDecryptRequest--;
}
core.int buildCounterDecryptResponse = 0;
api.DecryptResponse buildDecryptResponse() {
final o = api.DecryptResponse();
buildCounterDecryptResponse++;
if (buildCounterDecryptResponse < 3) {
o.plaintext = 'foo';
o.plaintextCrc32c = 'foo';
o.protectionLevel = 'foo';
o.usedPrimary = true;
}
buildCounterDecryptResponse--;
return o;
}
void checkDecryptResponse(api.DecryptResponse o) {
buildCounterDecryptResponse++;
if (buildCounterDecryptResponse < 3) {
unittest.expect(
o.plaintext!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(o.usedPrimary!, unittest.isTrue);
}
buildCounterDecryptResponse--;
}
core.int buildCounterDestroyCryptoKeyVersionRequest = 0;
api.DestroyCryptoKeyVersionRequest buildDestroyCryptoKeyVersionRequest() {
final o = api.DestroyCryptoKeyVersionRequest();
buildCounterDestroyCryptoKeyVersionRequest++;
if (buildCounterDestroyCryptoKeyVersionRequest < 3) {}
buildCounterDestroyCryptoKeyVersionRequest--;
return o;
}
void checkDestroyCryptoKeyVersionRequest(api.DestroyCryptoKeyVersionRequest o) {
buildCounterDestroyCryptoKeyVersionRequest++;
if (buildCounterDestroyCryptoKeyVersionRequest < 3) {}
buildCounterDestroyCryptoKeyVersionRequest--;
}
core.int buildCounterDigest = 0;
api.Digest buildDigest() {
final o = api.Digest();
buildCounterDigest++;
if (buildCounterDigest < 3) {
o.sha256 = 'foo';
o.sha384 = 'foo';
o.sha512 = 'foo';
}
buildCounterDigest--;
return o;
}
void checkDigest(api.Digest o) {
buildCounterDigest++;
if (buildCounterDigest < 3) {
unittest.expect(
o.sha256!,
unittest.equals('foo'),
);
unittest.expect(
o.sha384!,
unittest.equals('foo'),
);
unittest.expect(
o.sha512!,
unittest.equals('foo'),
);
}
buildCounterDigest--;
}
core.int buildCounterEkmConfig = 0;
api.EkmConfig buildEkmConfig() {
final o = api.EkmConfig();
buildCounterEkmConfig++;
if (buildCounterEkmConfig < 3) {
o.defaultEkmConnection = 'foo';
o.name = 'foo';
}
buildCounterEkmConfig--;
return o;
}
void checkEkmConfig(api.EkmConfig o) {
buildCounterEkmConfig++;
if (buildCounterEkmConfig < 3) {
unittest.expect(
o.defaultEkmConnection!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterEkmConfig--;
}
core.List<api.ServiceResolver> buildUnnamed8() => [
buildServiceResolver(),
buildServiceResolver(),
];
void checkUnnamed8(core.List<api.ServiceResolver> o) {
unittest.expect(o, unittest.hasLength(2));
checkServiceResolver(o[0]);
checkServiceResolver(o[1]);
}
core.int buildCounterEkmConnection = 0;
api.EkmConnection buildEkmConnection() {
final o = api.EkmConnection();
buildCounterEkmConnection++;
if (buildCounterEkmConnection < 3) {
o.createTime = 'foo';
o.cryptoSpacePath = 'foo';
o.etag = 'foo';
o.keyManagementMode = 'foo';
o.name = 'foo';
o.serviceResolvers = buildUnnamed8();
}
buildCounterEkmConnection--;
return o;
}
void checkEkmConnection(api.EkmConnection o) {
buildCounterEkmConnection++;
if (buildCounterEkmConnection < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.cryptoSpacePath!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.keyManagementMode!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed8(o.serviceResolvers!);
}
buildCounterEkmConnection--;
}
core.int buildCounterEncryptRequest = 0;
api.EncryptRequest buildEncryptRequest() {
final o = api.EncryptRequest();
buildCounterEncryptRequest++;
if (buildCounterEncryptRequest < 3) {
o.additionalAuthenticatedData = 'foo';
o.additionalAuthenticatedDataCrc32c = 'foo';
o.plaintext = 'foo';
o.plaintextCrc32c = 'foo';
}
buildCounterEncryptRequest--;
return o;
}
void checkEncryptRequest(api.EncryptRequest o) {
buildCounterEncryptRequest++;
if (buildCounterEncryptRequest < 3) {
unittest.expect(
o.additionalAuthenticatedData!,
unittest.equals('foo'),
);
unittest.expect(
o.additionalAuthenticatedDataCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintext!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintextCrc32c!,
unittest.equals('foo'),
);
}
buildCounterEncryptRequest--;
}
core.int buildCounterEncryptResponse = 0;
api.EncryptResponse buildEncryptResponse() {
final o = api.EncryptResponse();
buildCounterEncryptResponse++;
if (buildCounterEncryptResponse < 3) {
o.ciphertext = 'foo';
o.ciphertextCrc32c = 'foo';
o.name = 'foo';
o.protectionLevel = 'foo';
o.verifiedAdditionalAuthenticatedDataCrc32c = true;
o.verifiedPlaintextCrc32c = true;
}
buildCounterEncryptResponse--;
return o;
}
void checkEncryptResponse(api.EncryptResponse o) {
buildCounterEncryptResponse++;
if (buildCounterEncryptResponse < 3) {
unittest.expect(
o.ciphertext!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(
o.verifiedAdditionalAuthenticatedDataCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedPlaintextCrc32c!, unittest.isTrue);
}
buildCounterEncryptResponse--;
}
core.int buildCounterExpr = 0;
api.Expr buildExpr() {
final o = api.Expr();
buildCounterExpr++;
if (buildCounterExpr < 3) {
o.description = 'foo';
o.expression = 'foo';
o.location = 'foo';
o.title = 'foo';
}
buildCounterExpr--;
return o;
}
void checkExpr(api.Expr o) {
buildCounterExpr++;
if (buildCounterExpr < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.expression!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterExpr--;
}
core.int buildCounterExternalProtectionLevelOptions = 0;
api.ExternalProtectionLevelOptions buildExternalProtectionLevelOptions() {
final o = api.ExternalProtectionLevelOptions();
buildCounterExternalProtectionLevelOptions++;
if (buildCounterExternalProtectionLevelOptions < 3) {
o.ekmConnectionKeyPath = 'foo';
o.externalKeyUri = 'foo';
}
buildCounterExternalProtectionLevelOptions--;
return o;
}
void checkExternalProtectionLevelOptions(api.ExternalProtectionLevelOptions o) {
buildCounterExternalProtectionLevelOptions++;
if (buildCounterExternalProtectionLevelOptions < 3) {
unittest.expect(
o.ekmConnectionKeyPath!,
unittest.equals('foo'),
);
unittest.expect(
o.externalKeyUri!,
unittest.equals('foo'),
);
}
buildCounterExternalProtectionLevelOptions--;
}
core.int buildCounterGenerateRandomBytesRequest = 0;
api.GenerateRandomBytesRequest buildGenerateRandomBytesRequest() {
final o = api.GenerateRandomBytesRequest();
buildCounterGenerateRandomBytesRequest++;
if (buildCounterGenerateRandomBytesRequest < 3) {
o.lengthBytes = 42;
o.protectionLevel = 'foo';
}
buildCounterGenerateRandomBytesRequest--;
return o;
}
void checkGenerateRandomBytesRequest(api.GenerateRandomBytesRequest o) {
buildCounterGenerateRandomBytesRequest++;
if (buildCounterGenerateRandomBytesRequest < 3) {
unittest.expect(
o.lengthBytes!,
unittest.equals(42),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
}
buildCounterGenerateRandomBytesRequest--;
}
core.int buildCounterGenerateRandomBytesResponse = 0;
api.GenerateRandomBytesResponse buildGenerateRandomBytesResponse() {
final o = api.GenerateRandomBytesResponse();
buildCounterGenerateRandomBytesResponse++;
if (buildCounterGenerateRandomBytesResponse < 3) {
o.data = 'foo';
o.dataCrc32c = 'foo';
}
buildCounterGenerateRandomBytesResponse--;
return o;
}
void checkGenerateRandomBytesResponse(api.GenerateRandomBytesResponse o) {
buildCounterGenerateRandomBytesResponse++;
if (buildCounterGenerateRandomBytesResponse < 3) {
unittest.expect(
o.data!,
unittest.equals('foo'),
);
unittest.expect(
o.dataCrc32c!,
unittest.equals('foo'),
);
}
buildCounterGenerateRandomBytesResponse--;
}
core.int buildCounterImportCryptoKeyVersionRequest = 0;
api.ImportCryptoKeyVersionRequest buildImportCryptoKeyVersionRequest() {
final o = api.ImportCryptoKeyVersionRequest();
buildCounterImportCryptoKeyVersionRequest++;
if (buildCounterImportCryptoKeyVersionRequest < 3) {
o.algorithm = 'foo';
o.cryptoKeyVersion = 'foo';
o.importJob = 'foo';
o.rsaAesWrappedKey = 'foo';
o.wrappedKey = 'foo';
}
buildCounterImportCryptoKeyVersionRequest--;
return o;
}
void checkImportCryptoKeyVersionRequest(api.ImportCryptoKeyVersionRequest o) {
buildCounterImportCryptoKeyVersionRequest++;
if (buildCounterImportCryptoKeyVersionRequest < 3) {
unittest.expect(
o.algorithm!,
unittest.equals('foo'),
);
unittest.expect(
o.cryptoKeyVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.importJob!,
unittest.equals('foo'),
);
unittest.expect(
o.rsaAesWrappedKey!,
unittest.equals('foo'),
);
unittest.expect(
o.wrappedKey!,
unittest.equals('foo'),
);
}
buildCounterImportCryptoKeyVersionRequest--;
}
core.int buildCounterImportJob = 0;
api.ImportJob buildImportJob() {
final o = api.ImportJob();
buildCounterImportJob++;
if (buildCounterImportJob < 3) {
o.attestation = buildKeyOperationAttestation();
o.createTime = 'foo';
o.expireEventTime = 'foo';
o.expireTime = 'foo';
o.generateTime = 'foo';
o.importMethod = 'foo';
o.name = 'foo';
o.protectionLevel = 'foo';
o.publicKey = buildWrappingPublicKey();
o.state = 'foo';
}
buildCounterImportJob--;
return o;
}
void checkImportJob(api.ImportJob o) {
buildCounterImportJob++;
if (buildCounterImportJob < 3) {
checkKeyOperationAttestation(o.attestation!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.expireEventTime!,
unittest.equals('foo'),
);
unittest.expect(
o.expireTime!,
unittest.equals('foo'),
);
unittest.expect(
o.generateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.importMethod!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
checkWrappingPublicKey(o.publicKey!);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterImportJob--;
}
core.int buildCounterKeyOperationAttestation = 0;
api.KeyOperationAttestation buildKeyOperationAttestation() {
final o = api.KeyOperationAttestation();
buildCounterKeyOperationAttestation++;
if (buildCounterKeyOperationAttestation < 3) {
o.certChains = buildCertificateChains();
o.content = 'foo';
o.format = 'foo';
}
buildCounterKeyOperationAttestation--;
return o;
}
void checkKeyOperationAttestation(api.KeyOperationAttestation o) {
buildCounterKeyOperationAttestation++;
if (buildCounterKeyOperationAttestation < 3) {
checkCertificateChains(o.certChains!);
unittest.expect(
o.content!,
unittest.equals('foo'),
);
unittest.expect(
o.format!,
unittest.equals('foo'),
);
}
buildCounterKeyOperationAttestation--;
}
core.int buildCounterKeyRing = 0;
api.KeyRing buildKeyRing() {
final o = api.KeyRing();
buildCounterKeyRing++;
if (buildCounterKeyRing < 3) {
o.createTime = 'foo';
o.name = 'foo';
}
buildCounterKeyRing--;
return o;
}
void checkKeyRing(api.KeyRing o) {
buildCounterKeyRing++;
if (buildCounterKeyRing < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterKeyRing--;
}
core.List<api.CryptoKeyVersion> buildUnnamed9() => [
buildCryptoKeyVersion(),
buildCryptoKeyVersion(),
];
void checkUnnamed9(core.List<api.CryptoKeyVersion> o) {
unittest.expect(o, unittest.hasLength(2));
checkCryptoKeyVersion(o[0]);
checkCryptoKeyVersion(o[1]);
}
core.int buildCounterListCryptoKeyVersionsResponse = 0;
api.ListCryptoKeyVersionsResponse buildListCryptoKeyVersionsResponse() {
final o = api.ListCryptoKeyVersionsResponse();
buildCounterListCryptoKeyVersionsResponse++;
if (buildCounterListCryptoKeyVersionsResponse < 3) {
o.cryptoKeyVersions = buildUnnamed9();
o.nextPageToken = 'foo';
o.totalSize = 42;
}
buildCounterListCryptoKeyVersionsResponse--;
return o;
}
void checkListCryptoKeyVersionsResponse(api.ListCryptoKeyVersionsResponse o) {
buildCounterListCryptoKeyVersionsResponse++;
if (buildCounterListCryptoKeyVersionsResponse < 3) {
checkUnnamed9(o.cryptoKeyVersions!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.totalSize!,
unittest.equals(42),
);
}
buildCounterListCryptoKeyVersionsResponse--;
}
core.List<api.CryptoKey> buildUnnamed10() => [
buildCryptoKey(),
buildCryptoKey(),
];
void checkUnnamed10(core.List<api.CryptoKey> o) {
unittest.expect(o, unittest.hasLength(2));
checkCryptoKey(o[0]);
checkCryptoKey(o[1]);
}
core.int buildCounterListCryptoKeysResponse = 0;
api.ListCryptoKeysResponse buildListCryptoKeysResponse() {
final o = api.ListCryptoKeysResponse();
buildCounterListCryptoKeysResponse++;
if (buildCounterListCryptoKeysResponse < 3) {
o.cryptoKeys = buildUnnamed10();
o.nextPageToken = 'foo';
o.totalSize = 42;
}
buildCounterListCryptoKeysResponse--;
return o;
}
void checkListCryptoKeysResponse(api.ListCryptoKeysResponse o) {
buildCounterListCryptoKeysResponse++;
if (buildCounterListCryptoKeysResponse < 3) {
checkUnnamed10(o.cryptoKeys!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.totalSize!,
unittest.equals(42),
);
}
buildCounterListCryptoKeysResponse--;
}
core.List<api.EkmConnection> buildUnnamed11() => [
buildEkmConnection(),
buildEkmConnection(),
];
void checkUnnamed11(core.List<api.EkmConnection> o) {
unittest.expect(o, unittest.hasLength(2));
checkEkmConnection(o[0]);
checkEkmConnection(o[1]);
}
core.int buildCounterListEkmConnectionsResponse = 0;
api.ListEkmConnectionsResponse buildListEkmConnectionsResponse() {
final o = api.ListEkmConnectionsResponse();
buildCounterListEkmConnectionsResponse++;
if (buildCounterListEkmConnectionsResponse < 3) {
o.ekmConnections = buildUnnamed11();
o.nextPageToken = 'foo';
o.totalSize = 42;
}
buildCounterListEkmConnectionsResponse--;
return o;
}
void checkListEkmConnectionsResponse(api.ListEkmConnectionsResponse o) {
buildCounterListEkmConnectionsResponse++;
if (buildCounterListEkmConnectionsResponse < 3) {
checkUnnamed11(o.ekmConnections!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.totalSize!,
unittest.equals(42),
);
}
buildCounterListEkmConnectionsResponse--;
}
core.List<api.ImportJob> buildUnnamed12() => [
buildImportJob(),
buildImportJob(),
];
void checkUnnamed12(core.List<api.ImportJob> o) {
unittest.expect(o, unittest.hasLength(2));
checkImportJob(o[0]);
checkImportJob(o[1]);
}
core.int buildCounterListImportJobsResponse = 0;
api.ListImportJobsResponse buildListImportJobsResponse() {
final o = api.ListImportJobsResponse();
buildCounterListImportJobsResponse++;
if (buildCounterListImportJobsResponse < 3) {
o.importJobs = buildUnnamed12();
o.nextPageToken = 'foo';
o.totalSize = 42;
}
buildCounterListImportJobsResponse--;
return o;
}
void checkListImportJobsResponse(api.ListImportJobsResponse o) {
buildCounterListImportJobsResponse++;
if (buildCounterListImportJobsResponse < 3) {
checkUnnamed12(o.importJobs!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.totalSize!,
unittest.equals(42),
);
}
buildCounterListImportJobsResponse--;
}
core.List<api.KeyRing> buildUnnamed13() => [
buildKeyRing(),
buildKeyRing(),
];
void checkUnnamed13(core.List<api.KeyRing> o) {
unittest.expect(o, unittest.hasLength(2));
checkKeyRing(o[0]);
checkKeyRing(o[1]);
}
core.int buildCounterListKeyRingsResponse = 0;
api.ListKeyRingsResponse buildListKeyRingsResponse() {
final o = api.ListKeyRingsResponse();
buildCounterListKeyRingsResponse++;
if (buildCounterListKeyRingsResponse < 3) {
o.keyRings = buildUnnamed13();
o.nextPageToken = 'foo';
o.totalSize = 42;
}
buildCounterListKeyRingsResponse--;
return o;
}
void checkListKeyRingsResponse(api.ListKeyRingsResponse o) {
buildCounterListKeyRingsResponse++;
if (buildCounterListKeyRingsResponse < 3) {
checkUnnamed13(o.keyRings!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.totalSize!,
unittest.equals(42),
);
}
buildCounterListKeyRingsResponse--;
}
core.List<api.Location> buildUnnamed14() => [
buildLocation(),
buildLocation(),
];
void checkUnnamed14(core.List<api.Location> o) {
unittest.expect(o, unittest.hasLength(2));
checkLocation(o[0]);
checkLocation(o[1]);
}
core.int buildCounterListLocationsResponse = 0;
api.ListLocationsResponse buildListLocationsResponse() {
final o = api.ListLocationsResponse();
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
o.locations = buildUnnamed14();
o.nextPageToken = 'foo';
}
buildCounterListLocationsResponse--;
return o;
}
void checkListLocationsResponse(api.ListLocationsResponse o) {
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
checkUnnamed14(o.locations!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLocationsResponse--;
}
core.Map<core.String, core.String> buildUnnamed15() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed15(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed16() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed16(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.int buildCounterLocation = 0;
api.Location buildLocation() {
final o = api.Location();
buildCounterLocation++;
if (buildCounterLocation < 3) {
o.displayName = 'foo';
o.labels = buildUnnamed15();
o.locationId = 'foo';
o.metadata = buildUnnamed16();
o.name = 'foo';
}
buildCounterLocation--;
return o;
}
void checkLocation(api.Location o) {
buildCounterLocation++;
if (buildCounterLocation < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed15(o.labels!);
unittest.expect(
o.locationId!,
unittest.equals('foo'),
);
checkUnnamed16(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLocation--;
}
core.int buildCounterMacSignRequest = 0;
api.MacSignRequest buildMacSignRequest() {
final o = api.MacSignRequest();
buildCounterMacSignRequest++;
if (buildCounterMacSignRequest < 3) {
o.data = 'foo';
o.dataCrc32c = 'foo';
}
buildCounterMacSignRequest--;
return o;
}
void checkMacSignRequest(api.MacSignRequest o) {
buildCounterMacSignRequest++;
if (buildCounterMacSignRequest < 3) {
unittest.expect(
o.data!,
unittest.equals('foo'),
);
unittest.expect(
o.dataCrc32c!,
unittest.equals('foo'),
);
}
buildCounterMacSignRequest--;
}
core.int buildCounterMacSignResponse = 0;
api.MacSignResponse buildMacSignResponse() {
final o = api.MacSignResponse();
buildCounterMacSignResponse++;
if (buildCounterMacSignResponse < 3) {
o.mac = 'foo';
o.macCrc32c = 'foo';
o.name = 'foo';
o.protectionLevel = 'foo';
o.verifiedDataCrc32c = true;
}
buildCounterMacSignResponse--;
return o;
}
void checkMacSignResponse(api.MacSignResponse o) {
buildCounterMacSignResponse++;
if (buildCounterMacSignResponse < 3) {
unittest.expect(
o.mac!,
unittest.equals('foo'),
);
unittest.expect(
o.macCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(o.verifiedDataCrc32c!, unittest.isTrue);
}
buildCounterMacSignResponse--;
}
core.int buildCounterMacVerifyRequest = 0;
api.MacVerifyRequest buildMacVerifyRequest() {
final o = api.MacVerifyRequest();
buildCounterMacVerifyRequest++;
if (buildCounterMacVerifyRequest < 3) {
o.data = 'foo';
o.dataCrc32c = 'foo';
o.mac = 'foo';
o.macCrc32c = 'foo';
}
buildCounterMacVerifyRequest--;
return o;
}
void checkMacVerifyRequest(api.MacVerifyRequest o) {
buildCounterMacVerifyRequest++;
if (buildCounterMacVerifyRequest < 3) {
unittest.expect(
o.data!,
unittest.equals('foo'),
);
unittest.expect(
o.dataCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.mac!,
unittest.equals('foo'),
);
unittest.expect(
o.macCrc32c!,
unittest.equals('foo'),
);
}
buildCounterMacVerifyRequest--;
}
core.int buildCounterMacVerifyResponse = 0;
api.MacVerifyResponse buildMacVerifyResponse() {
final o = api.MacVerifyResponse();
buildCounterMacVerifyResponse++;
if (buildCounterMacVerifyResponse < 3) {
o.name = 'foo';
o.protectionLevel = 'foo';
o.success = true;
o.verifiedDataCrc32c = true;
o.verifiedMacCrc32c = true;
o.verifiedSuccessIntegrity = true;
}
buildCounterMacVerifyResponse--;
return o;
}
void checkMacVerifyResponse(api.MacVerifyResponse o) {
buildCounterMacVerifyResponse++;
if (buildCounterMacVerifyResponse < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(o.success!, unittest.isTrue);
unittest.expect(o.verifiedDataCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedMacCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedSuccessIntegrity!, unittest.isTrue);
}
buildCounterMacVerifyResponse--;
}
core.List<api.AuditConfig> buildUnnamed17() => [
buildAuditConfig(),
buildAuditConfig(),
];
void checkUnnamed17(core.List<api.AuditConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAuditConfig(o[0]);
checkAuditConfig(o[1]);
}
core.List<api.Binding> buildUnnamed18() => [
buildBinding(),
buildBinding(),
];
void checkUnnamed18(core.List<api.Binding> o) {
unittest.expect(o, unittest.hasLength(2));
checkBinding(o[0]);
checkBinding(o[1]);
}
core.int buildCounterPolicy = 0;
api.Policy buildPolicy() {
final o = api.Policy();
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
o.auditConfigs = buildUnnamed17();
o.bindings = buildUnnamed18();
o.etag = 'foo';
o.version = 42;
}
buildCounterPolicy--;
return o;
}
void checkPolicy(api.Policy o) {
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
checkUnnamed17(o.auditConfigs!);
checkUnnamed18(o.bindings!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals(42),
);
}
buildCounterPolicy--;
}
core.int buildCounterPublicKey = 0;
api.PublicKey buildPublicKey() {
final o = api.PublicKey();
buildCounterPublicKey++;
if (buildCounterPublicKey < 3) {
o.algorithm = 'foo';
o.name = 'foo';
o.pem = 'foo';
o.pemCrc32c = 'foo';
o.protectionLevel = 'foo';
}
buildCounterPublicKey--;
return o;
}
void checkPublicKey(api.PublicKey o) {
buildCounterPublicKey++;
if (buildCounterPublicKey < 3) {
unittest.expect(
o.algorithm!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.pem!,
unittest.equals('foo'),
);
unittest.expect(
o.pemCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
}
buildCounterPublicKey--;
}
core.int buildCounterRawDecryptRequest = 0;
api.RawDecryptRequest buildRawDecryptRequest() {
final o = api.RawDecryptRequest();
buildCounterRawDecryptRequest++;
if (buildCounterRawDecryptRequest < 3) {
o.additionalAuthenticatedData = 'foo';
o.additionalAuthenticatedDataCrc32c = 'foo';
o.ciphertext = 'foo';
o.ciphertextCrc32c = 'foo';
o.initializationVector = 'foo';
o.initializationVectorCrc32c = 'foo';
o.tagLength = 42;
}
buildCounterRawDecryptRequest--;
return o;
}
void checkRawDecryptRequest(api.RawDecryptRequest o) {
buildCounterRawDecryptRequest++;
if (buildCounterRawDecryptRequest < 3) {
unittest.expect(
o.additionalAuthenticatedData!,
unittest.equals('foo'),
);
unittest.expect(
o.additionalAuthenticatedDataCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertext!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVector!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVectorCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.tagLength!,
unittest.equals(42),
);
}
buildCounterRawDecryptRequest--;
}
core.int buildCounterRawDecryptResponse = 0;
api.RawDecryptResponse buildRawDecryptResponse() {
final o = api.RawDecryptResponse();
buildCounterRawDecryptResponse++;
if (buildCounterRawDecryptResponse < 3) {
o.plaintext = 'foo';
o.plaintextCrc32c = 'foo';
o.protectionLevel = 'foo';
o.verifiedAdditionalAuthenticatedDataCrc32c = true;
o.verifiedCiphertextCrc32c = true;
o.verifiedInitializationVectorCrc32c = true;
}
buildCounterRawDecryptResponse--;
return o;
}
void checkRawDecryptResponse(api.RawDecryptResponse o) {
buildCounterRawDecryptResponse++;
if (buildCounterRawDecryptResponse < 3) {
unittest.expect(
o.plaintext!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(
o.verifiedAdditionalAuthenticatedDataCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedCiphertextCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedInitializationVectorCrc32c!, unittest.isTrue);
}
buildCounterRawDecryptResponse--;
}
core.int buildCounterRawEncryptRequest = 0;
api.RawEncryptRequest buildRawEncryptRequest() {
final o = api.RawEncryptRequest();
buildCounterRawEncryptRequest++;
if (buildCounterRawEncryptRequest < 3) {
o.additionalAuthenticatedData = 'foo';
o.additionalAuthenticatedDataCrc32c = 'foo';
o.initializationVector = 'foo';
o.initializationVectorCrc32c = 'foo';
o.plaintext = 'foo';
o.plaintextCrc32c = 'foo';
}
buildCounterRawEncryptRequest--;
return o;
}
void checkRawEncryptRequest(api.RawEncryptRequest o) {
buildCounterRawEncryptRequest++;
if (buildCounterRawEncryptRequest < 3) {
unittest.expect(
o.additionalAuthenticatedData!,
unittest.equals('foo'),
);
unittest.expect(
o.additionalAuthenticatedDataCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVector!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVectorCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintext!,
unittest.equals('foo'),
);
unittest.expect(
o.plaintextCrc32c!,
unittest.equals('foo'),
);
}
buildCounterRawEncryptRequest--;
}
core.int buildCounterRawEncryptResponse = 0;
api.RawEncryptResponse buildRawEncryptResponse() {
final o = api.RawEncryptResponse();
buildCounterRawEncryptResponse++;
if (buildCounterRawEncryptResponse < 3) {
o.ciphertext = 'foo';
o.ciphertextCrc32c = 'foo';
o.initializationVector = 'foo';
o.initializationVectorCrc32c = 'foo';
o.name = 'foo';
o.protectionLevel = 'foo';
o.tagLength = 42;
o.verifiedAdditionalAuthenticatedDataCrc32c = true;
o.verifiedInitializationVectorCrc32c = true;
o.verifiedPlaintextCrc32c = true;
}
buildCounterRawEncryptResponse--;
return o;
}
void checkRawEncryptResponse(api.RawEncryptResponse o) {
buildCounterRawEncryptResponse++;
if (buildCounterRawEncryptResponse < 3) {
unittest.expect(
o.ciphertext!,
unittest.equals('foo'),
);
unittest.expect(
o.ciphertextCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVector!,
unittest.equals('foo'),
);
unittest.expect(
o.initializationVectorCrc32c!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protectionLevel!,
unittest.equals('foo'),
);
unittest.expect(
o.tagLength!,
unittest.equals(42),
);
unittest.expect(
o.verifiedAdditionalAuthenticatedDataCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedInitializationVectorCrc32c!, unittest.isTrue);
unittest.expect(o.verifiedPlaintextCrc32c!, unittest.isTrue);
}
buildCounterRawEncryptResponse--;
}
core.int buildCounterRestoreCryptoKeyVersionRequest = 0;
api.RestoreCryptoKeyVersionRequest buildRestoreCryptoKeyVersionRequest() {
final o = api.RestoreCryptoKeyVersionRequest();
buildCounterRestoreCryptoKeyVersionRequest++;
if (buildCounterRestoreCryptoKeyVersionRequest < 3) {}
buildCounterRestoreCryptoKeyVersionRequest--;
return o;
}
void checkRestoreCryptoKeyVersionRequest(api.RestoreCryptoKeyVersionRequest o) {
buildCounterRestoreCryptoKeyVersionRequest++;
if (buildCounterRestoreCryptoKeyVersionRequest < 3) {}
buildCounterRestoreCryptoKeyVersionRequest--;
}
core.List<api.Certificate> buildUnnamed19() => [
buildCertificate(),
buildCertificate(),
];
void checkUnnamed19(core.List<api.Certificate> o) {
unittest.expect(o, unittest.hasLength(2));
checkCertificate(o[0]);
checkCertificate(o[1]);
}
core.int buildCounterServiceResolver = 0;
api.ServiceResolver buildServiceResolver() {
final o = api.ServiceResolver();
buildCounterServiceResolver++;
if (buildCounterServiceResolver < 3) {
o.endpointFilter = 'foo';
o.hostname = 'foo';
o.serverCertificates = buildUnnamed19();
o.serviceDirectoryService = 'foo';
}
buildCounterServiceResolver--;
return o;
}
void checkServiceResolver(api.ServiceResolver o) {
buildCounterServiceResolver++;
if (buildCounterServiceResolver < 3) {
unittest.expect(
o.endpointFilter!,
unittest.equals('foo'),
);
unittest.expect(
o.hostname!,
unittest.equals('foo'),
);
checkUnnamed19(o.serverCertificates!);
unittest.expect(
o.serviceDirectoryService!,
unittest.equals('foo'),
);
}
buildCounterServiceResolver--;
}
core.int buildCounterSetIamPolicyRequest = 0;
api.SetIamPolicyRequest buildSetIamPolicyRequest() {
final o = api.SetIamPolicyRequest();
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
o.policy = buildPolicy();
o.updateMask = 'foo';
}
buildCounterSetIamPolicyRequest--;
return o;
}
void checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
checkPolicy(o.policy!);
unittest.expect(
o.updateMask!,
unittest.equals('foo'),
);
}
buildCounterSetIamPolicyRequest--;
}
core.List<core.String> buildUnnamed20() => [
'foo',
'foo',
];
void checkUnnamed20(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsRequest = 0;
api.TestIamPermissionsRequest buildTestIamPermissionsRequest() {
final o = api.TestIamPermissionsRequest();
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
o.permissions = buildUnnamed20();
}
buildCounterTestIamPermissionsRequest--;
return o;
}
void checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
checkUnnamed20(o.permissions!);
}
buildCounterTestIamPermissionsRequest--;
}
core.List<core.String> buildUnnamed21() => [
'foo',
'foo',
];
void checkUnnamed21(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsResponse = 0;
api.TestIamPermissionsResponse buildTestIamPermissionsResponse() {
final o = api.TestIamPermissionsResponse();
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
o.permissions = buildUnnamed21();
}
buildCounterTestIamPermissionsResponse--;
return o;
}
void checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
checkUnnamed21(o.permissions!);
}
buildCounterTestIamPermissionsResponse--;
}
core.int buildCounterUpdateCryptoKeyPrimaryVersionRequest = 0;
api.UpdateCryptoKeyPrimaryVersionRequest
buildUpdateCryptoKeyPrimaryVersionRequest() {
final o = api.UpdateCryptoKeyPrimaryVersionRequest();
buildCounterUpdateCryptoKeyPrimaryVersionRequest++;
if (buildCounterUpdateCryptoKeyPrimaryVersionRequest < 3) {
o.cryptoKeyVersionId = 'foo';
}
buildCounterUpdateCryptoKeyPrimaryVersionRequest--;
return o;
}
void checkUpdateCryptoKeyPrimaryVersionRequest(
api.UpdateCryptoKeyPrimaryVersionRequest o) {
buildCounterUpdateCryptoKeyPrimaryVersionRequest++;
if (buildCounterUpdateCryptoKeyPrimaryVersionRequest < 3) {
unittest.expect(
o.cryptoKeyVersionId!,
unittest.equals('foo'),
);
}
buildCounterUpdateCryptoKeyPrimaryVersionRequest--;
}
core.int buildCounterVerifyConnectivityResponse = 0;
api.VerifyConnectivityResponse buildVerifyConnectivityResponse() {
final o = api.VerifyConnectivityResponse();
buildCounterVerifyConnectivityResponse++;
if (buildCounterVerifyConnectivityResponse < 3) {}
buildCounterVerifyConnectivityResponse--;
return o;
}
void checkVerifyConnectivityResponse(api.VerifyConnectivityResponse o) {
buildCounterVerifyConnectivityResponse++;
if (buildCounterVerifyConnectivityResponse < 3) {}
buildCounterVerifyConnectivityResponse--;
}
core.int buildCounterWrappingPublicKey = 0;
api.WrappingPublicKey buildWrappingPublicKey() {
final o = api.WrappingPublicKey();
buildCounterWrappingPublicKey++;
if (buildCounterWrappingPublicKey < 3) {
o.pem = 'foo';
}
buildCounterWrappingPublicKey--;
return o;
}
void checkWrappingPublicKey(api.WrappingPublicKey o) {
buildCounterWrappingPublicKey++;
if (buildCounterWrappingPublicKey < 3) {
unittest.expect(
o.pem!,
unittest.equals('foo'),
);
}
buildCounterWrappingPublicKey--;
}
void main() {
unittest.group('obj-schema-AsymmetricDecryptRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildAsymmetricDecryptRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AsymmetricDecryptRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAsymmetricDecryptRequest(od);
});
});
unittest.group('obj-schema-AsymmetricDecryptResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAsymmetricDecryptResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AsymmetricDecryptResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAsymmetricDecryptResponse(od);
});
});
unittest.group('obj-schema-AsymmetricSignRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildAsymmetricSignRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AsymmetricSignRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAsymmetricSignRequest(od);
});
});
unittest.group('obj-schema-AsymmetricSignResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAsymmetricSignResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AsymmetricSignResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAsymmetricSignResponse(od);
});
});
unittest.group('obj-schema-AuditConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAuditConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AuditConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAuditConfig(od);
});
});
unittest.group('obj-schema-AuditLogConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAuditLogConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AuditLogConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAuditLogConfig(od);
});
});
unittest.group('obj-schema-Binding', () {
unittest.test('to-json--from-json', () async {
final o = buildBinding();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Binding.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkBinding(od);
});
});
unittest.group('obj-schema-Certificate', () {
unittest.test('to-json--from-json', () async {
final o = buildCertificate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Certificate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCertificate(od);
});
});
unittest.group('obj-schema-CertificateChains', () {
unittest.test('to-json--from-json', () async {
final o = buildCertificateChains();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CertificateChains.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCertificateChains(od);
});
});
unittest.group('obj-schema-CryptoKey', () {
unittest.test('to-json--from-json', () async {
final o = buildCryptoKey();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.CryptoKey.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCryptoKey(od);
});
});
unittest.group('obj-schema-CryptoKeyVersion', () {
unittest.test('to-json--from-json', () async {
final o = buildCryptoKeyVersion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CryptoKeyVersion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCryptoKeyVersion(od);
});
});
unittest.group('obj-schema-CryptoKeyVersionTemplate', () {
unittest.test('to-json--from-json', () async {
final o = buildCryptoKeyVersionTemplate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CryptoKeyVersionTemplate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCryptoKeyVersionTemplate(od);
});
});
unittest.group('obj-schema-DecryptRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildDecryptRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DecryptRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDecryptRequest(od);
});
});
unittest.group('obj-schema-DecryptResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildDecryptResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DecryptResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDecryptResponse(od);
});
});
unittest.group('obj-schema-DestroyCryptoKeyVersionRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildDestroyCryptoKeyVersionRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DestroyCryptoKeyVersionRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDestroyCryptoKeyVersionRequest(od);
});
});
unittest.group('obj-schema-Digest', () {
unittest.test('to-json--from-json', () async {
final o = buildDigest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Digest.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDigest(od);
});
});
unittest.group('obj-schema-EkmConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildEkmConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.EkmConfig.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEkmConfig(od);
});
});
unittest.group('obj-schema-EkmConnection', () {
unittest.test('to-json--from-json', () async {
final o = buildEkmConnection();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EkmConnection.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEkmConnection(od);
});
});
unittest.group('obj-schema-EncryptRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildEncryptRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EncryptRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEncryptRequest(od);
});
});
unittest.group('obj-schema-EncryptResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildEncryptResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EncryptResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEncryptResponse(od);
});
});
unittest.group('obj-schema-Expr', () {
unittest.test('to-json--from-json', () async {
final o = buildExpr();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Expr.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkExpr(od);
});
});
unittest.group('obj-schema-ExternalProtectionLevelOptions', () {
unittest.test('to-json--from-json', () async {
final o = buildExternalProtectionLevelOptions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ExternalProtectionLevelOptions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkExternalProtectionLevelOptions(od);
});
});
unittest.group('obj-schema-GenerateRandomBytesRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateRandomBytesRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateRandomBytesRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateRandomBytesRequest(od);
});
});
unittest.group('obj-schema-GenerateRandomBytesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateRandomBytesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateRandomBytesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateRandomBytesResponse(od);
});
});
unittest.group('obj-schema-ImportCryptoKeyVersionRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildImportCryptoKeyVersionRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ImportCryptoKeyVersionRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkImportCryptoKeyVersionRequest(od);
});
});
unittest.group('obj-schema-ImportJob', () {
unittest.test('to-json--from-json', () async {
final o = buildImportJob();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ImportJob.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkImportJob(od);
});
});
unittest.group('obj-schema-KeyOperationAttestation', () {
unittest.test('to-json--from-json', () async {
final o = buildKeyOperationAttestation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.KeyOperationAttestation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkKeyOperationAttestation(od);
});
});
unittest.group('obj-schema-KeyRing', () {
unittest.test('to-json--from-json', () async {
final o = buildKeyRing();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.KeyRing.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkKeyRing(od);
});
});
unittest.group('obj-schema-ListCryptoKeyVersionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListCryptoKeyVersionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListCryptoKeyVersionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListCryptoKeyVersionsResponse(od);
});
});
unittest.group('obj-schema-ListCryptoKeysResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListCryptoKeysResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListCryptoKeysResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListCryptoKeysResponse(od);
});
});
unittest.group('obj-schema-ListEkmConnectionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListEkmConnectionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListEkmConnectionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListEkmConnectionsResponse(od);
});
});
unittest.group('obj-schema-ListImportJobsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListImportJobsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListImportJobsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListImportJobsResponse(od);
});
});
unittest.group('obj-schema-ListKeyRingsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListKeyRingsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListKeyRingsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListKeyRingsResponse(od);
});
});
unittest.group('obj-schema-ListLocationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLocationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLocationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLocationsResponse(od);
});
});
unittest.group('obj-schema-Location', () {
unittest.test('to-json--from-json', () async {
final o = buildLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Location.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLocation(od);
});
});
unittest.group('obj-schema-MacSignRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildMacSignRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MacSignRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMacSignRequest(od);
});
});
unittest.group('obj-schema-MacSignResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildMacSignResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MacSignResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMacSignResponse(od);
});
});
unittest.group('obj-schema-MacVerifyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildMacVerifyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MacVerifyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMacVerifyRequest(od);
});
});
unittest.group('obj-schema-MacVerifyResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildMacVerifyResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MacVerifyResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMacVerifyResponse(od);
});
});
unittest.group('obj-schema-Policy', () {
unittest.test('to-json--from-json', () async {
final o = buildPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Policy.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPolicy(od);
});
});
unittest.group('obj-schema-PublicKey', () {
unittest.test('to-json--from-json', () async {
final o = buildPublicKey();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.PublicKey.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPublicKey(od);
});
});
unittest.group('obj-schema-RawDecryptRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRawDecryptRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RawDecryptRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRawDecryptRequest(od);
});
});
unittest.group('obj-schema-RawDecryptResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildRawDecryptResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RawDecryptResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRawDecryptResponse(od);
});
});
unittest.group('obj-schema-RawEncryptRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRawEncryptRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RawEncryptRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRawEncryptRequest(od);
});
});
unittest.group('obj-schema-RawEncryptResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildRawEncryptResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RawEncryptResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRawEncryptResponse(od);
});
});
unittest.group('obj-schema-RestoreCryptoKeyVersionRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRestoreCryptoKeyVersionRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RestoreCryptoKeyVersionRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRestoreCryptoKeyVersionRequest(od);
});
});
unittest.group('obj-schema-ServiceResolver', () {
unittest.test('to-json--from-json', () async {
final o = buildServiceResolver();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ServiceResolver.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkServiceResolver(od);
});
});
unittest.group('obj-schema-SetIamPolicyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetIamPolicyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetIamPolicyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(od);
});
});
unittest.group('obj-schema-TestIamPermissionsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(od);
});
});
unittest.group('obj-schema-TestIamPermissionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsResponse(od);
});
});
unittest.group('obj-schema-UpdateCryptoKeyPrimaryVersionRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateCryptoKeyPrimaryVersionRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateCryptoKeyPrimaryVersionRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateCryptoKeyPrimaryVersionRequest(od);
});
});
unittest.group('obj-schema-VerifyConnectivityResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildVerifyConnectivityResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VerifyConnectivityResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVerifyConnectivityResponse(od);
});
});
unittest.group('obj-schema-WrappingPublicKey', () {
unittest.test('to-json--from-json', () async {
final o = buildWrappingPublicKey();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WrappingPublicKey.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWrappingPublicKey(od);
});
});
unittest.group('resource-ProjectsLocationsResource', () {
unittest.test('method--generateRandomBytes', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations;
final arg_request = buildGenerateRandomBytesRequest();
final arg_location = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.GenerateRandomBytesRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkGenerateRandomBytesRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGenerateRandomBytesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateRandomBytes(arg_request, arg_location,
$fields: arg_$fields);
checkGenerateRandomBytesResponse(
response as api.GenerateRandomBytesResponse);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--getEkmConfig', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEkmConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getEkmConfig(arg_name, $fields: arg_$fields);
checkEkmConfig(response as api.EkmConfig);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
unittest.test('method--updateEkmConfig', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations;
final arg_request = buildEkmConfig();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.EkmConfig.fromJson(json as core.Map<core.String, core.dynamic>);
checkEkmConfig(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEkmConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateEkmConfig(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkEkmConfig(response as api.EkmConfig);
});
});
unittest.group('resource-ProjectsLocationsEkmConfigResource', () {
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConfig;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConfig;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConfig;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
});
unittest.group('resource-ProjectsLocationsEkmConnectionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_request = buildEkmConnection();
final arg_parent = 'foo';
final arg_ekmConnectionId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.EkmConnection.fromJson(
json as core.Map<core.String, core.dynamic>);
checkEkmConnection(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ekmConnectionId']!.first,
unittest.equals(arg_ekmConnectionId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEkmConnection());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
ekmConnectionId: arg_ekmConnectionId, $fields: arg_$fields);
checkEkmConnection(response as api.EkmConnection);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEkmConnection());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkEkmConnection(response as api.EkmConnection);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListEkmConnectionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListEkmConnectionsResponse(
response as api.ListEkmConnectionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_request = buildEkmConnection();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.EkmConnection.fromJson(
json as core.Map<core.String, core.dynamic>);
checkEkmConnection(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEkmConnection());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkEkmConnection(response as api.EkmConnection);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
unittest.test('method--verifyConnectivity', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.ekmConnections;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVerifyConnectivityResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.verifyConnectivity(arg_name, $fields: arg_$fields);
checkVerifyConnectivityResponse(
response as api.VerifyConnectivityResponse);
});
});
unittest.group('resource-ProjectsLocationsKeyRingsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_request = buildKeyRing();
final arg_parent = 'foo';
final arg_keyRingId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.KeyRing.fromJson(json as core.Map<core.String, core.dynamic>);
checkKeyRing(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['keyRingId']!.first,
unittest.equals(arg_keyRingId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildKeyRing());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
keyRingId: arg_keyRingId, $fields: arg_$fields);
checkKeyRing(response as api.KeyRing);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildKeyRing());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkKeyRing(response as api.KeyRing);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListKeyRingsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListKeyRingsResponse(response as api.ListKeyRingsResponse);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
});
unittest.group('resource-ProjectsLocationsKeyRingsCryptoKeysResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildCryptoKey();
final arg_parent = 'foo';
final arg_cryptoKeyId = 'foo';
final arg_skipInitialVersionCreation = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.CryptoKey.fromJson(json as core.Map<core.String, core.dynamic>);
checkCryptoKey(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['cryptoKeyId']!.first,
unittest.equals(arg_cryptoKeyId),
);
unittest.expect(
queryMap['skipInitialVersionCreation']!.first,
unittest.equals('$arg_skipInitialVersionCreation'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
cryptoKeyId: arg_cryptoKeyId,
skipInitialVersionCreation: arg_skipInitialVersionCreation,
$fields: arg_$fields);
checkCryptoKey(response as api.CryptoKey);
});
unittest.test('method--decrypt', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildDecryptRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DecryptRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDecryptRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDecryptResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.decrypt(arg_request, arg_name, $fields: arg_$fields);
checkDecryptResponse(response as api.DecryptResponse);
});
unittest.test('method--encrypt', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildEncryptRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.EncryptRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkEncryptRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEncryptResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.encrypt(arg_request, arg_name, $fields: arg_$fields);
checkEncryptResponse(response as api.EncryptResponse);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkCryptoKey(response as api.CryptoKey);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_versionView = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['versionView']!.first,
unittest.equals(arg_versionView),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListCryptoKeysResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
versionView: arg_versionView,
$fields: arg_$fields);
checkListCryptoKeysResponse(response as api.ListCryptoKeysResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildCryptoKey();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.CryptoKey.fromJson(json as core.Map<core.String, core.dynamic>);
checkCryptoKey(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkCryptoKey(response as api.CryptoKey);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
unittest.test('method--updatePrimaryVersion', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.cryptoKeys;
final arg_request = buildUpdateCryptoKeyPrimaryVersionRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateCryptoKeyPrimaryVersionRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateCryptoKeyPrimaryVersionRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updatePrimaryVersion(arg_request, arg_name,
$fields: arg_$fields);
checkCryptoKey(response as api.CryptoKey);
});
});
unittest.group(
'resource-ProjectsLocationsKeyRingsCryptoKeysCryptoKeyVersionsResource',
() {
unittest.test('method--asymmetricDecrypt', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildAsymmetricDecryptRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AsymmetricDecryptRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAsymmetricDecryptRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAsymmetricDecryptResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.asymmetricDecrypt(arg_request, arg_name,
$fields: arg_$fields);
checkAsymmetricDecryptResponse(response as api.AsymmetricDecryptResponse);
});
unittest.test('method--asymmetricSign', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildAsymmetricSignRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AsymmetricSignRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAsymmetricSignRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAsymmetricSignResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.asymmetricSign(arg_request, arg_name, $fields: arg_$fields);
checkAsymmetricSignResponse(response as api.AsymmetricSignResponse);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildCryptoKeyVersion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CryptoKeyVersion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCryptoKeyVersion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
unittest.test('method--destroy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildDestroyCryptoKeyVersionRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DestroyCryptoKeyVersionRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDestroyCryptoKeyVersionRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.destroy(arg_request, arg_name, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
unittest.test('method--getPublicKey', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPublicKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getPublicKey(arg_name, $fields: arg_$fields);
checkPublicKey(response as api.PublicKey);
});
unittest.test('method--import', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildImportCryptoKeyVersionRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ImportCryptoKeyVersionRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkImportCryptoKeyVersionRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.import(arg_request, arg_parent, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_view = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['view']!.first,
unittest.equals(arg_view),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListCryptoKeyVersionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
view: arg_view,
$fields: arg_$fields);
checkListCryptoKeyVersionsResponse(
response as api.ListCryptoKeyVersionsResponse);
});
unittest.test('method--macSign', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildMacSignRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.MacSignRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkMacSignRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMacSignResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.macSign(arg_request, arg_name, $fields: arg_$fields);
checkMacSignResponse(response as api.MacSignResponse);
});
unittest.test('method--macVerify', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildMacVerifyRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.MacVerifyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkMacVerifyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMacVerifyResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.macVerify(arg_request, arg_name, $fields: arg_$fields);
checkMacVerifyResponse(response as api.MacVerifyResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildCryptoKeyVersion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CryptoKeyVersion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCryptoKeyVersion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
unittest.test('method--rawDecrypt', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildRawDecryptRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RawDecryptRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRawDecryptRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRawDecryptResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.rawDecrypt(arg_request, arg_name, $fields: arg_$fields);
checkRawDecryptResponse(response as api.RawDecryptResponse);
});
unittest.test('method--rawEncrypt', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildRawEncryptRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RawEncryptRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRawEncryptRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRawEncryptResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.rawEncrypt(arg_request, arg_name, $fields: arg_$fields);
checkRawEncryptResponse(response as api.RawEncryptResponse);
});
unittest.test('method--restore', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock)
.projects
.locations
.keyRings
.cryptoKeys
.cryptoKeyVersions;
final arg_request = buildRestoreCryptoKeyVersionRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RestoreCryptoKeyVersionRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRestoreCryptoKeyVersionRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCryptoKeyVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.restore(arg_request, arg_name, $fields: arg_$fields);
checkCryptoKeyVersion(response as api.CryptoKeyVersion);
});
});
unittest.group('resource-ProjectsLocationsKeyRingsImportJobsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_request = buildImportJob();
final arg_parent = 'foo';
final arg_importJobId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.ImportJob.fromJson(json as core.Map<core.String, core.dynamic>);
checkImportJob(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['importJobId']!.first,
unittest.equals(arg_importJobId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildImportJob());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
importJobId: arg_importJobId, $fields: arg_$fields);
checkImportJob(response as api.ImportJob);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildImportJob());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkImportJob(response as api.ImportJob);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListImportJobsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListImportJobsResponse(response as api.ListImportJobsResponse);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.CloudKMSApi(mock).projects.locations.keyRings.importJobs;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/cloudkms/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/cloudkms/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 83065}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/container/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterAcceleratorConfig = 0;
api.AcceleratorConfig buildAcceleratorConfig() {
final o = api.AcceleratorConfig();
buildCounterAcceleratorConfig++;
if (buildCounterAcceleratorConfig < 3) {
o.acceleratorCount = 'foo';
o.acceleratorType = 'foo';
o.gpuDriverInstallationConfig = buildGPUDriverInstallationConfig();
o.gpuPartitionSize = 'foo';
o.gpuSharingConfig = buildGPUSharingConfig();
}
buildCounterAcceleratorConfig--;
return o;
}
void checkAcceleratorConfig(api.AcceleratorConfig o) {
buildCounterAcceleratorConfig++;
if (buildCounterAcceleratorConfig < 3) {
unittest.expect(
o.acceleratorCount!,
unittest.equals('foo'),
);
unittest.expect(
o.acceleratorType!,
unittest.equals('foo'),
);
checkGPUDriverInstallationConfig(o.gpuDriverInstallationConfig!);
unittest.expect(
o.gpuPartitionSize!,
unittest.equals('foo'),
);
checkGPUSharingConfig(o.gpuSharingConfig!);
}
buildCounterAcceleratorConfig--;
}
core.int buildCounterAdditionalNodeNetworkConfig = 0;
api.AdditionalNodeNetworkConfig buildAdditionalNodeNetworkConfig() {
final o = api.AdditionalNodeNetworkConfig();
buildCounterAdditionalNodeNetworkConfig++;
if (buildCounterAdditionalNodeNetworkConfig < 3) {
o.network = 'foo';
o.subnetwork = 'foo';
}
buildCounterAdditionalNodeNetworkConfig--;
return o;
}
void checkAdditionalNodeNetworkConfig(api.AdditionalNodeNetworkConfig o) {
buildCounterAdditionalNodeNetworkConfig++;
if (buildCounterAdditionalNodeNetworkConfig < 3) {
unittest.expect(
o.network!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetwork!,
unittest.equals('foo'),
);
}
buildCounterAdditionalNodeNetworkConfig--;
}
core.int buildCounterAdditionalPodNetworkConfig = 0;
api.AdditionalPodNetworkConfig buildAdditionalPodNetworkConfig() {
final o = api.AdditionalPodNetworkConfig();
buildCounterAdditionalPodNetworkConfig++;
if (buildCounterAdditionalPodNetworkConfig < 3) {
o.maxPodsPerNode = buildMaxPodsConstraint();
o.secondaryPodRange = 'foo';
o.subnetwork = 'foo';
}
buildCounterAdditionalPodNetworkConfig--;
return o;
}
void checkAdditionalPodNetworkConfig(api.AdditionalPodNetworkConfig o) {
buildCounterAdditionalPodNetworkConfig++;
if (buildCounterAdditionalPodNetworkConfig < 3) {
checkMaxPodsConstraint(o.maxPodsPerNode!);
unittest.expect(
o.secondaryPodRange!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetwork!,
unittest.equals('foo'),
);
}
buildCounterAdditionalPodNetworkConfig--;
}
core.List<api.RangeInfo> buildUnnamed0() => [
buildRangeInfo(),
buildRangeInfo(),
];
void checkUnnamed0(core.List<api.RangeInfo> o) {
unittest.expect(o, unittest.hasLength(2));
checkRangeInfo(o[0]);
checkRangeInfo(o[1]);
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAdditionalPodRangesConfig = 0;
api.AdditionalPodRangesConfig buildAdditionalPodRangesConfig() {
final o = api.AdditionalPodRangesConfig();
buildCounterAdditionalPodRangesConfig++;
if (buildCounterAdditionalPodRangesConfig < 3) {
o.podRangeInfo = buildUnnamed0();
o.podRangeNames = buildUnnamed1();
}
buildCounterAdditionalPodRangesConfig--;
return o;
}
void checkAdditionalPodRangesConfig(api.AdditionalPodRangesConfig o) {
buildCounterAdditionalPodRangesConfig++;
if (buildCounterAdditionalPodRangesConfig < 3) {
checkUnnamed0(o.podRangeInfo!);
checkUnnamed1(o.podRangeNames!);
}
buildCounterAdditionalPodRangesConfig--;
}
core.int buildCounterAddonsConfig = 0;
api.AddonsConfig buildAddonsConfig() {
final o = api.AddonsConfig();
buildCounterAddonsConfig++;
if (buildCounterAddonsConfig < 3) {
o.cloudRunConfig = buildCloudRunConfig();
o.configConnectorConfig = buildConfigConnectorConfig();
o.dnsCacheConfig = buildDnsCacheConfig();
o.gcePersistentDiskCsiDriverConfig =
buildGcePersistentDiskCsiDriverConfig();
o.gcpFilestoreCsiDriverConfig = buildGcpFilestoreCsiDriverConfig();
o.gcsFuseCsiDriverConfig = buildGcsFuseCsiDriverConfig();
o.gkeBackupAgentConfig = buildGkeBackupAgentConfig();
o.horizontalPodAutoscaling = buildHorizontalPodAutoscaling();
o.httpLoadBalancing = buildHttpLoadBalancing();
o.kubernetesDashboard = buildKubernetesDashboard();
o.networkPolicyConfig = buildNetworkPolicyConfig();
}
buildCounterAddonsConfig--;
return o;
}
void checkAddonsConfig(api.AddonsConfig o) {
buildCounterAddonsConfig++;
if (buildCounterAddonsConfig < 3) {
checkCloudRunConfig(o.cloudRunConfig!);
checkConfigConnectorConfig(o.configConnectorConfig!);
checkDnsCacheConfig(o.dnsCacheConfig!);
checkGcePersistentDiskCsiDriverConfig(o.gcePersistentDiskCsiDriverConfig!);
checkGcpFilestoreCsiDriverConfig(o.gcpFilestoreCsiDriverConfig!);
checkGcsFuseCsiDriverConfig(o.gcsFuseCsiDriverConfig!);
checkGkeBackupAgentConfig(o.gkeBackupAgentConfig!);
checkHorizontalPodAutoscaling(o.horizontalPodAutoscaling!);
checkHttpLoadBalancing(o.httpLoadBalancing!);
checkKubernetesDashboard(o.kubernetesDashboard!);
checkNetworkPolicyConfig(o.networkPolicyConfig!);
}
buildCounterAddonsConfig--;
}
core.int buildCounterAdvancedDatapathObservabilityConfig = 0;
api.AdvancedDatapathObservabilityConfig
buildAdvancedDatapathObservabilityConfig() {
final o = api.AdvancedDatapathObservabilityConfig();
buildCounterAdvancedDatapathObservabilityConfig++;
if (buildCounterAdvancedDatapathObservabilityConfig < 3) {
o.enableMetrics = true;
o.relayMode = 'foo';
}
buildCounterAdvancedDatapathObservabilityConfig--;
return o;
}
void checkAdvancedDatapathObservabilityConfig(
api.AdvancedDatapathObservabilityConfig o) {
buildCounterAdvancedDatapathObservabilityConfig++;
if (buildCounterAdvancedDatapathObservabilityConfig < 3) {
unittest.expect(o.enableMetrics!, unittest.isTrue);
unittest.expect(
o.relayMode!,
unittest.equals('foo'),
);
}
buildCounterAdvancedDatapathObservabilityConfig--;
}
core.int buildCounterAdvancedMachineFeatures = 0;
api.AdvancedMachineFeatures buildAdvancedMachineFeatures() {
final o = api.AdvancedMachineFeatures();
buildCounterAdvancedMachineFeatures++;
if (buildCounterAdvancedMachineFeatures < 3) {
o.threadsPerCore = 'foo';
}
buildCounterAdvancedMachineFeatures--;
return o;
}
void checkAdvancedMachineFeatures(api.AdvancedMachineFeatures o) {
buildCounterAdvancedMachineFeatures++;
if (buildCounterAdvancedMachineFeatures < 3) {
unittest.expect(
o.threadsPerCore!,
unittest.equals('foo'),
);
}
buildCounterAdvancedMachineFeatures--;
}
core.int buildCounterAuthenticatorGroupsConfig = 0;
api.AuthenticatorGroupsConfig buildAuthenticatorGroupsConfig() {
final o = api.AuthenticatorGroupsConfig();
buildCounterAuthenticatorGroupsConfig++;
if (buildCounterAuthenticatorGroupsConfig < 3) {
o.enabled = true;
o.securityGroup = 'foo';
}
buildCounterAuthenticatorGroupsConfig--;
return o;
}
void checkAuthenticatorGroupsConfig(api.AuthenticatorGroupsConfig o) {
buildCounterAuthenticatorGroupsConfig++;
if (buildCounterAuthenticatorGroupsConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.securityGroup!,
unittest.equals('foo'),
);
}
buildCounterAuthenticatorGroupsConfig--;
}
core.int buildCounterAutoUpgradeOptions = 0;
api.AutoUpgradeOptions buildAutoUpgradeOptions() {
final o = api.AutoUpgradeOptions();
buildCounterAutoUpgradeOptions++;
if (buildCounterAutoUpgradeOptions < 3) {
o.autoUpgradeStartTime = 'foo';
o.description = 'foo';
}
buildCounterAutoUpgradeOptions--;
return o;
}
void checkAutoUpgradeOptions(api.AutoUpgradeOptions o) {
buildCounterAutoUpgradeOptions++;
if (buildCounterAutoUpgradeOptions < 3) {
unittest.expect(
o.autoUpgradeStartTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
}
buildCounterAutoUpgradeOptions--;
}
core.int buildCounterAutopilot = 0;
api.Autopilot buildAutopilot() {
final o = api.Autopilot();
buildCounterAutopilot++;
if (buildCounterAutopilot < 3) {
o.enabled = true;
o.workloadPolicyConfig = buildWorkloadPolicyConfig();
}
buildCounterAutopilot--;
return o;
}
void checkAutopilot(api.Autopilot o) {
buildCounterAutopilot++;
if (buildCounterAutopilot < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
checkWorkloadPolicyConfig(o.workloadPolicyConfig!);
}
buildCounterAutopilot--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAutopilotCompatibilityIssue = 0;
api.AutopilotCompatibilityIssue buildAutopilotCompatibilityIssue() {
final o = api.AutopilotCompatibilityIssue();
buildCounterAutopilotCompatibilityIssue++;
if (buildCounterAutopilotCompatibilityIssue < 3) {
o.constraintType = 'foo';
o.description = 'foo';
o.documentationUrl = 'foo';
o.incompatibilityType = 'foo';
o.lastObservation = 'foo';
o.subjects = buildUnnamed2();
}
buildCounterAutopilotCompatibilityIssue--;
return o;
}
void checkAutopilotCompatibilityIssue(api.AutopilotCompatibilityIssue o) {
buildCounterAutopilotCompatibilityIssue++;
if (buildCounterAutopilotCompatibilityIssue < 3) {
unittest.expect(
o.constraintType!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.documentationUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.incompatibilityType!,
unittest.equals('foo'),
);
unittest.expect(
o.lastObservation!,
unittest.equals('foo'),
);
checkUnnamed2(o.subjects!);
}
buildCounterAutopilotCompatibilityIssue--;
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAutoprovisioningNodePoolDefaults = 0;
api.AutoprovisioningNodePoolDefaults buildAutoprovisioningNodePoolDefaults() {
final o = api.AutoprovisioningNodePoolDefaults();
buildCounterAutoprovisioningNodePoolDefaults++;
if (buildCounterAutoprovisioningNodePoolDefaults < 3) {
o.bootDiskKmsKey = 'foo';
o.diskSizeGb = 42;
o.diskType = 'foo';
o.imageType = 'foo';
o.insecureKubeletReadonlyPortEnabled = true;
o.management = buildNodeManagement();
o.minCpuPlatform = 'foo';
o.oauthScopes = buildUnnamed3();
o.serviceAccount = 'foo';
o.shieldedInstanceConfig = buildShieldedInstanceConfig();
o.upgradeSettings = buildUpgradeSettings();
}
buildCounterAutoprovisioningNodePoolDefaults--;
return o;
}
void checkAutoprovisioningNodePoolDefaults(
api.AutoprovisioningNodePoolDefaults o) {
buildCounterAutoprovisioningNodePoolDefaults++;
if (buildCounterAutoprovisioningNodePoolDefaults < 3) {
unittest.expect(
o.bootDiskKmsKey!,
unittest.equals('foo'),
);
unittest.expect(
o.diskSizeGb!,
unittest.equals(42),
);
unittest.expect(
o.diskType!,
unittest.equals('foo'),
);
unittest.expect(
o.imageType!,
unittest.equals('foo'),
);
unittest.expect(o.insecureKubeletReadonlyPortEnabled!, unittest.isTrue);
checkNodeManagement(o.management!);
unittest.expect(
o.minCpuPlatform!,
unittest.equals('foo'),
);
checkUnnamed3(o.oauthScopes!);
unittest.expect(
o.serviceAccount!,
unittest.equals('foo'),
);
checkShieldedInstanceConfig(o.shieldedInstanceConfig!);
checkUpgradeSettings(o.upgradeSettings!);
}
buildCounterAutoprovisioningNodePoolDefaults--;
}
core.int buildCounterBestEffortProvisioning = 0;
api.BestEffortProvisioning buildBestEffortProvisioning() {
final o = api.BestEffortProvisioning();
buildCounterBestEffortProvisioning++;
if (buildCounterBestEffortProvisioning < 3) {
o.enabled = true;
o.minProvisionNodes = 42;
}
buildCounterBestEffortProvisioning--;
return o;
}
void checkBestEffortProvisioning(api.BestEffortProvisioning o) {
buildCounterBestEffortProvisioning++;
if (buildCounterBestEffortProvisioning < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.minProvisionNodes!,
unittest.equals(42),
);
}
buildCounterBestEffortProvisioning--;
}
core.int buildCounterBigQueryDestination = 0;
api.BigQueryDestination buildBigQueryDestination() {
final o = api.BigQueryDestination();
buildCounterBigQueryDestination++;
if (buildCounterBigQueryDestination < 3) {
o.datasetId = 'foo';
}
buildCounterBigQueryDestination--;
return o;
}
void checkBigQueryDestination(api.BigQueryDestination o) {
buildCounterBigQueryDestination++;
if (buildCounterBigQueryDestination < 3) {
unittest.expect(
o.datasetId!,
unittest.equals('foo'),
);
}
buildCounterBigQueryDestination--;
}
core.int buildCounterBinaryAuthorization = 0;
api.BinaryAuthorization buildBinaryAuthorization() {
final o = api.BinaryAuthorization();
buildCounterBinaryAuthorization++;
if (buildCounterBinaryAuthorization < 3) {
o.enabled = true;
o.evaluationMode = 'foo';
}
buildCounterBinaryAuthorization--;
return o;
}
void checkBinaryAuthorization(api.BinaryAuthorization o) {
buildCounterBinaryAuthorization++;
if (buildCounterBinaryAuthorization < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.evaluationMode!,
unittest.equals('foo'),
);
}
buildCounterBinaryAuthorization--;
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed5() => [
'foo',
'foo',
];
void checkUnnamed5(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterBlueGreenInfo = 0;
api.BlueGreenInfo buildBlueGreenInfo() {
final o = api.BlueGreenInfo();
buildCounterBlueGreenInfo++;
if (buildCounterBlueGreenInfo < 3) {
o.blueInstanceGroupUrls = buildUnnamed4();
o.bluePoolDeletionStartTime = 'foo';
o.greenInstanceGroupUrls = buildUnnamed5();
o.greenPoolVersion = 'foo';
o.phase = 'foo';
}
buildCounterBlueGreenInfo--;
return o;
}
void checkBlueGreenInfo(api.BlueGreenInfo o) {
buildCounterBlueGreenInfo++;
if (buildCounterBlueGreenInfo < 3) {
checkUnnamed4(o.blueInstanceGroupUrls!);
unittest.expect(
o.bluePoolDeletionStartTime!,
unittest.equals('foo'),
);
checkUnnamed5(o.greenInstanceGroupUrls!);
unittest.expect(
o.greenPoolVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.phase!,
unittest.equals('foo'),
);
}
buildCounterBlueGreenInfo--;
}
core.int buildCounterBlueGreenSettings = 0;
api.BlueGreenSettings buildBlueGreenSettings() {
final o = api.BlueGreenSettings();
buildCounterBlueGreenSettings++;
if (buildCounterBlueGreenSettings < 3) {
o.nodePoolSoakDuration = 'foo';
o.standardRolloutPolicy = buildStandardRolloutPolicy();
}
buildCounterBlueGreenSettings--;
return o;
}
void checkBlueGreenSettings(api.BlueGreenSettings o) {
buildCounterBlueGreenSettings++;
if (buildCounterBlueGreenSettings < 3) {
unittest.expect(
o.nodePoolSoakDuration!,
unittest.equals('foo'),
);
checkStandardRolloutPolicy(o.standardRolloutPolicy!);
}
buildCounterBlueGreenSettings--;
}
core.int buildCounterCancelOperationRequest = 0;
api.CancelOperationRequest buildCancelOperationRequest() {
final o = api.CancelOperationRequest();
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {
o.name = 'foo';
o.operationId = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterCancelOperationRequest--;
return o;
}
void checkCancelOperationRequest(api.CancelOperationRequest o) {
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.operationId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterCancelOperationRequest--;
}
core.List<api.AutopilotCompatibilityIssue> buildUnnamed6() => [
buildAutopilotCompatibilityIssue(),
buildAutopilotCompatibilityIssue(),
];
void checkUnnamed6(core.List<api.AutopilotCompatibilityIssue> o) {
unittest.expect(o, unittest.hasLength(2));
checkAutopilotCompatibilityIssue(o[0]);
checkAutopilotCompatibilityIssue(o[1]);
}
core.int buildCounterCheckAutopilotCompatibilityResponse = 0;
api.CheckAutopilotCompatibilityResponse
buildCheckAutopilotCompatibilityResponse() {
final o = api.CheckAutopilotCompatibilityResponse();
buildCounterCheckAutopilotCompatibilityResponse++;
if (buildCounterCheckAutopilotCompatibilityResponse < 3) {
o.issues = buildUnnamed6();
o.summary = 'foo';
}
buildCounterCheckAutopilotCompatibilityResponse--;
return o;
}
void checkCheckAutopilotCompatibilityResponse(
api.CheckAutopilotCompatibilityResponse o) {
buildCounterCheckAutopilotCompatibilityResponse++;
if (buildCounterCheckAutopilotCompatibilityResponse < 3) {
checkUnnamed6(o.issues!);
unittest.expect(
o.summary!,
unittest.equals('foo'),
);
}
buildCounterCheckAutopilotCompatibilityResponse--;
}
core.int buildCounterCidrBlock = 0;
api.CidrBlock buildCidrBlock() {
final o = api.CidrBlock();
buildCounterCidrBlock++;
if (buildCounterCidrBlock < 3) {
o.cidrBlock = 'foo';
o.displayName = 'foo';
}
buildCounterCidrBlock--;
return o;
}
void checkCidrBlock(api.CidrBlock o) {
buildCounterCidrBlock++;
if (buildCounterCidrBlock < 3) {
unittest.expect(
o.cidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
}
buildCounterCidrBlock--;
}
core.int buildCounterClientCertificateConfig = 0;
api.ClientCertificateConfig buildClientCertificateConfig() {
final o = api.ClientCertificateConfig();
buildCounterClientCertificateConfig++;
if (buildCounterClientCertificateConfig < 3) {
o.issueClientCertificate = true;
}
buildCounterClientCertificateConfig--;
return o;
}
void checkClientCertificateConfig(api.ClientCertificateConfig o) {
buildCounterClientCertificateConfig++;
if (buildCounterClientCertificateConfig < 3) {
unittest.expect(o.issueClientCertificate!, unittest.isTrue);
}
buildCounterClientCertificateConfig--;
}
core.int buildCounterCloudRunConfig = 0;
api.CloudRunConfig buildCloudRunConfig() {
final o = api.CloudRunConfig();
buildCounterCloudRunConfig++;
if (buildCounterCloudRunConfig < 3) {
o.disabled = true;
o.loadBalancerType = 'foo';
}
buildCounterCloudRunConfig--;
return o;
}
void checkCloudRunConfig(api.CloudRunConfig o) {
buildCounterCloudRunConfig++;
if (buildCounterCloudRunConfig < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
unittest.expect(
o.loadBalancerType!,
unittest.equals('foo'),
);
}
buildCounterCloudRunConfig--;
}
core.List<api.StatusCondition> buildUnnamed7() => [
buildStatusCondition(),
buildStatusCondition(),
];
void checkUnnamed7(core.List<api.StatusCondition> o) {
unittest.expect(o, unittest.hasLength(2));
checkStatusCondition(o[0]);
checkStatusCondition(o[1]);
}
core.List<core.String> buildUnnamed8() => [
'foo',
'foo',
];
void checkUnnamed8(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed9() => [
'foo',
'foo',
];
void checkUnnamed9(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.NodePool> buildUnnamed10() => [
buildNodePool(),
buildNodePool(),
];
void checkUnnamed10(core.List<api.NodePool> o) {
unittest.expect(o, unittest.hasLength(2));
checkNodePool(o[0]);
checkNodePool(o[1]);
}
core.Map<core.String, core.String> buildUnnamed11() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed11(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterCluster = 0;
api.Cluster buildCluster() {
final o = api.Cluster();
buildCounterCluster++;
if (buildCounterCluster < 3) {
o.addonsConfig = buildAddonsConfig();
o.authenticatorGroupsConfig = buildAuthenticatorGroupsConfig();
o.autopilot = buildAutopilot();
o.autoscaling = buildClusterAutoscaling();
o.binaryAuthorization = buildBinaryAuthorization();
o.clusterIpv4Cidr = 'foo';
o.conditions = buildUnnamed7();
o.confidentialNodes = buildConfidentialNodes();
o.costManagementConfig = buildCostManagementConfig();
o.createTime = 'foo';
o.currentMasterVersion = 'foo';
o.currentNodeCount = 42;
o.currentNodeVersion = 'foo';
o.databaseEncryption = buildDatabaseEncryption();
o.defaultMaxPodsConstraint = buildMaxPodsConstraint();
o.description = 'foo';
o.enableK8sBetaApis = buildK8sBetaAPIConfig();
o.enableKubernetesAlpha = true;
o.enableTpu = true;
o.endpoint = 'foo';
o.etag = 'foo';
o.expireTime = 'foo';
o.fleet = buildFleet();
o.id = 'foo';
o.identityServiceConfig = buildIdentityServiceConfig();
o.initialClusterVersion = 'foo';
o.initialNodeCount = 42;
o.instanceGroupUrls = buildUnnamed8();
o.ipAllocationPolicy = buildIPAllocationPolicy();
o.labelFingerprint = 'foo';
o.legacyAbac = buildLegacyAbac();
o.location = 'foo';
o.locations = buildUnnamed9();
o.loggingConfig = buildLoggingConfig();
o.loggingService = 'foo';
o.maintenancePolicy = buildMaintenancePolicy();
o.masterAuth = buildMasterAuth();
o.masterAuthorizedNetworksConfig = buildMasterAuthorizedNetworksConfig();
o.meshCertificates = buildMeshCertificates();
o.monitoringConfig = buildMonitoringConfig();
o.monitoringService = 'foo';
o.name = 'foo';
o.network = 'foo';
o.networkConfig = buildNetworkConfig();
o.networkPolicy = buildNetworkPolicy();
o.nodeConfig = buildNodeConfig();
o.nodeIpv4CidrSize = 42;
o.nodePoolAutoConfig = buildNodePoolAutoConfig();
o.nodePoolDefaults = buildNodePoolDefaults();
o.nodePools = buildUnnamed10();
o.notificationConfig = buildNotificationConfig();
o.privateClusterConfig = buildPrivateClusterConfig();
o.releaseChannel = buildReleaseChannel();
o.resourceLabels = buildUnnamed11();
o.resourceUsageExportConfig = buildResourceUsageExportConfig();
o.securityPostureConfig = buildSecurityPostureConfig();
o.selfLink = 'foo';
o.servicesIpv4Cidr = 'foo';
o.shieldedNodes = buildShieldedNodes();
o.status = 'foo';
o.statusMessage = 'foo';
o.subnetwork = 'foo';
o.tpuIpv4CidrBlock = 'foo';
o.verticalPodAutoscaling = buildVerticalPodAutoscaling();
o.workloadIdentityConfig = buildWorkloadIdentityConfig();
o.zone = 'foo';
}
buildCounterCluster--;
return o;
}
void checkCluster(api.Cluster o) {
buildCounterCluster++;
if (buildCounterCluster < 3) {
checkAddonsConfig(o.addonsConfig!);
checkAuthenticatorGroupsConfig(o.authenticatorGroupsConfig!);
checkAutopilot(o.autopilot!);
checkClusterAutoscaling(o.autoscaling!);
checkBinaryAuthorization(o.binaryAuthorization!);
unittest.expect(
o.clusterIpv4Cidr!,
unittest.equals('foo'),
);
checkUnnamed7(o.conditions!);
checkConfidentialNodes(o.confidentialNodes!);
checkCostManagementConfig(o.costManagementConfig!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.currentMasterVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.currentNodeCount!,
unittest.equals(42),
);
unittest.expect(
o.currentNodeVersion!,
unittest.equals('foo'),
);
checkDatabaseEncryption(o.databaseEncryption!);
checkMaxPodsConstraint(o.defaultMaxPodsConstraint!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkK8sBetaAPIConfig(o.enableK8sBetaApis!);
unittest.expect(o.enableKubernetesAlpha!, unittest.isTrue);
unittest.expect(o.enableTpu!, unittest.isTrue);
unittest.expect(
o.endpoint!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.expireTime!,
unittest.equals('foo'),
);
checkFleet(o.fleet!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkIdentityServiceConfig(o.identityServiceConfig!);
unittest.expect(
o.initialClusterVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.initialNodeCount!,
unittest.equals(42),
);
checkUnnamed8(o.instanceGroupUrls!);
checkIPAllocationPolicy(o.ipAllocationPolicy!);
unittest.expect(
o.labelFingerprint!,
unittest.equals('foo'),
);
checkLegacyAbac(o.legacyAbac!);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
checkUnnamed9(o.locations!);
checkLoggingConfig(o.loggingConfig!);
unittest.expect(
o.loggingService!,
unittest.equals('foo'),
);
checkMaintenancePolicy(o.maintenancePolicy!);
checkMasterAuth(o.masterAuth!);
checkMasterAuthorizedNetworksConfig(o.masterAuthorizedNetworksConfig!);
checkMeshCertificates(o.meshCertificates!);
checkMonitoringConfig(o.monitoringConfig!);
unittest.expect(
o.monitoringService!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.network!,
unittest.equals('foo'),
);
checkNetworkConfig(o.networkConfig!);
checkNetworkPolicy(o.networkPolicy!);
checkNodeConfig(o.nodeConfig!);
unittest.expect(
o.nodeIpv4CidrSize!,
unittest.equals(42),
);
checkNodePoolAutoConfig(o.nodePoolAutoConfig!);
checkNodePoolDefaults(o.nodePoolDefaults!);
checkUnnamed10(o.nodePools!);
checkNotificationConfig(o.notificationConfig!);
checkPrivateClusterConfig(o.privateClusterConfig!);
checkReleaseChannel(o.releaseChannel!);
checkUnnamed11(o.resourceLabels!);
checkResourceUsageExportConfig(o.resourceUsageExportConfig!);
checkSecurityPostureConfig(o.securityPostureConfig!);
unittest.expect(
o.selfLink!,
unittest.equals('foo'),
);
unittest.expect(
o.servicesIpv4Cidr!,
unittest.equals('foo'),
);
checkShieldedNodes(o.shieldedNodes!);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.statusMessage!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetwork!,
unittest.equals('foo'),
);
unittest.expect(
o.tpuIpv4CidrBlock!,
unittest.equals('foo'),
);
checkVerticalPodAutoscaling(o.verticalPodAutoscaling!);
checkWorkloadIdentityConfig(o.workloadIdentityConfig!);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterCluster--;
}
core.List<core.String> buildUnnamed12() => [
'foo',
'foo',
];
void checkUnnamed12(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.ResourceLimit> buildUnnamed13() => [
buildResourceLimit(),
buildResourceLimit(),
];
void checkUnnamed13(core.List<api.ResourceLimit> o) {
unittest.expect(o, unittest.hasLength(2));
checkResourceLimit(o[0]);
checkResourceLimit(o[1]);
}
core.int buildCounterClusterAutoscaling = 0;
api.ClusterAutoscaling buildClusterAutoscaling() {
final o = api.ClusterAutoscaling();
buildCounterClusterAutoscaling++;
if (buildCounterClusterAutoscaling < 3) {
o.autoprovisioningLocations = buildUnnamed12();
o.autoprovisioningNodePoolDefaults =
buildAutoprovisioningNodePoolDefaults();
o.autoscalingProfile = 'foo';
o.enableNodeAutoprovisioning = true;
o.resourceLimits = buildUnnamed13();
}
buildCounterClusterAutoscaling--;
return o;
}
void checkClusterAutoscaling(api.ClusterAutoscaling o) {
buildCounterClusterAutoscaling++;
if (buildCounterClusterAutoscaling < 3) {
checkUnnamed12(o.autoprovisioningLocations!);
checkAutoprovisioningNodePoolDefaults(o.autoprovisioningNodePoolDefaults!);
unittest.expect(
o.autoscalingProfile!,
unittest.equals('foo'),
);
unittest.expect(o.enableNodeAutoprovisioning!, unittest.isTrue);
checkUnnamed13(o.resourceLimits!);
}
buildCounterClusterAutoscaling--;
}
core.int buildCounterClusterNetworkPerformanceConfig = 0;
api.ClusterNetworkPerformanceConfig buildClusterNetworkPerformanceConfig() {
final o = api.ClusterNetworkPerformanceConfig();
buildCounterClusterNetworkPerformanceConfig++;
if (buildCounterClusterNetworkPerformanceConfig < 3) {
o.totalEgressBandwidthTier = 'foo';
}
buildCounterClusterNetworkPerformanceConfig--;
return o;
}
void checkClusterNetworkPerformanceConfig(
api.ClusterNetworkPerformanceConfig o) {
buildCounterClusterNetworkPerformanceConfig++;
if (buildCounterClusterNetworkPerformanceConfig < 3) {
unittest.expect(
o.totalEgressBandwidthTier!,
unittest.equals('foo'),
);
}
buildCounterClusterNetworkPerformanceConfig--;
}
core.List<core.String> buildUnnamed14() => [
'foo',
'foo',
];
void checkUnnamed14(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterClusterUpdate = 0;
api.ClusterUpdate buildClusterUpdate() {
final o = api.ClusterUpdate();
buildCounterClusterUpdate++;
if (buildCounterClusterUpdate < 3) {
o.additionalPodRangesConfig = buildAdditionalPodRangesConfig();
o.desiredAddonsConfig = buildAddonsConfig();
o.desiredAuthenticatorGroupsConfig = buildAuthenticatorGroupsConfig();
o.desiredAutopilotWorkloadPolicyConfig = buildWorkloadPolicyConfig();
o.desiredBinaryAuthorization = buildBinaryAuthorization();
o.desiredClusterAutoscaling = buildClusterAutoscaling();
o.desiredCostManagementConfig = buildCostManagementConfig();
o.desiredDatabaseEncryption = buildDatabaseEncryption();
o.desiredDatapathProvider = 'foo';
o.desiredDefaultSnatStatus = buildDefaultSnatStatus();
o.desiredDnsConfig = buildDNSConfig();
o.desiredEnableFqdnNetworkPolicy = true;
o.desiredEnablePrivateEndpoint = true;
o.desiredFleet = buildFleet();
o.desiredGatewayApiConfig = buildGatewayAPIConfig();
o.desiredGcfsConfig = buildGcfsConfig();
o.desiredIdentityServiceConfig = buildIdentityServiceConfig();
o.desiredImageType = 'foo';
o.desiredIntraNodeVisibilityConfig = buildIntraNodeVisibilityConfig();
o.desiredK8sBetaApis = buildK8sBetaAPIConfig();
o.desiredL4ilbSubsettingConfig = buildILBSubsettingConfig();
o.desiredLocations = buildUnnamed14();
o.desiredLoggingConfig = buildLoggingConfig();
o.desiredLoggingService = 'foo';
o.desiredMasterAuthorizedNetworksConfig =
buildMasterAuthorizedNetworksConfig();
o.desiredMasterVersion = 'foo';
o.desiredMeshCertificates = buildMeshCertificates();
o.desiredMonitoringConfig = buildMonitoringConfig();
o.desiredMonitoringService = 'foo';
o.desiredNetworkPerformanceConfig = buildClusterNetworkPerformanceConfig();
o.desiredNodePoolAutoConfigNetworkTags = buildNetworkTags();
o.desiredNodePoolAutoscaling = buildNodePoolAutoscaling();
o.desiredNodePoolId = 'foo';
o.desiredNodePoolLoggingConfig = buildNodePoolLoggingConfig();
o.desiredNodeVersion = 'foo';
o.desiredNotificationConfig = buildNotificationConfig();
o.desiredPrivateClusterConfig = buildPrivateClusterConfig();
o.desiredPrivateIpv6GoogleAccess = 'foo';
o.desiredReleaseChannel = buildReleaseChannel();
o.desiredResourceUsageExportConfig = buildResourceUsageExportConfig();
o.desiredSecurityPostureConfig = buildSecurityPostureConfig();
o.desiredServiceExternalIpsConfig = buildServiceExternalIPsConfig();
o.desiredShieldedNodes = buildShieldedNodes();
o.desiredStackType = 'foo';
o.desiredVerticalPodAutoscaling = buildVerticalPodAutoscaling();
o.desiredWorkloadIdentityConfig = buildWorkloadIdentityConfig();
o.enableK8sBetaApis = buildK8sBetaAPIConfig();
o.etag = 'foo';
o.removedAdditionalPodRangesConfig = buildAdditionalPodRangesConfig();
}
buildCounterClusterUpdate--;
return o;
}
void checkClusterUpdate(api.ClusterUpdate o) {
buildCounterClusterUpdate++;
if (buildCounterClusterUpdate < 3) {
checkAdditionalPodRangesConfig(o.additionalPodRangesConfig!);
checkAddonsConfig(o.desiredAddonsConfig!);
checkAuthenticatorGroupsConfig(o.desiredAuthenticatorGroupsConfig!);
checkWorkloadPolicyConfig(o.desiredAutopilotWorkloadPolicyConfig!);
checkBinaryAuthorization(o.desiredBinaryAuthorization!);
checkClusterAutoscaling(o.desiredClusterAutoscaling!);
checkCostManagementConfig(o.desiredCostManagementConfig!);
checkDatabaseEncryption(o.desiredDatabaseEncryption!);
unittest.expect(
o.desiredDatapathProvider!,
unittest.equals('foo'),
);
checkDefaultSnatStatus(o.desiredDefaultSnatStatus!);
checkDNSConfig(o.desiredDnsConfig!);
unittest.expect(o.desiredEnableFqdnNetworkPolicy!, unittest.isTrue);
unittest.expect(o.desiredEnablePrivateEndpoint!, unittest.isTrue);
checkFleet(o.desiredFleet!);
checkGatewayAPIConfig(o.desiredGatewayApiConfig!);
checkGcfsConfig(o.desiredGcfsConfig!);
checkIdentityServiceConfig(o.desiredIdentityServiceConfig!);
unittest.expect(
o.desiredImageType!,
unittest.equals('foo'),
);
checkIntraNodeVisibilityConfig(o.desiredIntraNodeVisibilityConfig!);
checkK8sBetaAPIConfig(o.desiredK8sBetaApis!);
checkILBSubsettingConfig(o.desiredL4ilbSubsettingConfig!);
checkUnnamed14(o.desiredLocations!);
checkLoggingConfig(o.desiredLoggingConfig!);
unittest.expect(
o.desiredLoggingService!,
unittest.equals('foo'),
);
checkMasterAuthorizedNetworksConfig(
o.desiredMasterAuthorizedNetworksConfig!);
unittest.expect(
o.desiredMasterVersion!,
unittest.equals('foo'),
);
checkMeshCertificates(o.desiredMeshCertificates!);
checkMonitoringConfig(o.desiredMonitoringConfig!);
unittest.expect(
o.desiredMonitoringService!,
unittest.equals('foo'),
);
checkClusterNetworkPerformanceConfig(o.desiredNetworkPerformanceConfig!);
checkNetworkTags(o.desiredNodePoolAutoConfigNetworkTags!);
checkNodePoolAutoscaling(o.desiredNodePoolAutoscaling!);
unittest.expect(
o.desiredNodePoolId!,
unittest.equals('foo'),
);
checkNodePoolLoggingConfig(o.desiredNodePoolLoggingConfig!);
unittest.expect(
o.desiredNodeVersion!,
unittest.equals('foo'),
);
checkNotificationConfig(o.desiredNotificationConfig!);
checkPrivateClusterConfig(o.desiredPrivateClusterConfig!);
unittest.expect(
o.desiredPrivateIpv6GoogleAccess!,
unittest.equals('foo'),
);
checkReleaseChannel(o.desiredReleaseChannel!);
checkResourceUsageExportConfig(o.desiredResourceUsageExportConfig!);
checkSecurityPostureConfig(o.desiredSecurityPostureConfig!);
checkServiceExternalIPsConfig(o.desiredServiceExternalIpsConfig!);
checkShieldedNodes(o.desiredShieldedNodes!);
unittest.expect(
o.desiredStackType!,
unittest.equals('foo'),
);
checkVerticalPodAutoscaling(o.desiredVerticalPodAutoscaling!);
checkWorkloadIdentityConfig(o.desiredWorkloadIdentityConfig!);
checkK8sBetaAPIConfig(o.enableK8sBetaApis!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkAdditionalPodRangesConfig(o.removedAdditionalPodRangesConfig!);
}
buildCounterClusterUpdate--;
}
core.int buildCounterCompleteIPRotationRequest = 0;
api.CompleteIPRotationRequest buildCompleteIPRotationRequest() {
final o = api.CompleteIPRotationRequest();
buildCounterCompleteIPRotationRequest++;
if (buildCounterCompleteIPRotationRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterCompleteIPRotationRequest--;
return o;
}
void checkCompleteIPRotationRequest(api.CompleteIPRotationRequest o) {
buildCounterCompleteIPRotationRequest++;
if (buildCounterCompleteIPRotationRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterCompleteIPRotationRequest--;
}
core.int buildCounterCompleteNodePoolUpgradeRequest = 0;
api.CompleteNodePoolUpgradeRequest buildCompleteNodePoolUpgradeRequest() {
final o = api.CompleteNodePoolUpgradeRequest();
buildCounterCompleteNodePoolUpgradeRequest++;
if (buildCounterCompleteNodePoolUpgradeRequest < 3) {}
buildCounterCompleteNodePoolUpgradeRequest--;
return o;
}
void checkCompleteNodePoolUpgradeRequest(api.CompleteNodePoolUpgradeRequest o) {
buildCounterCompleteNodePoolUpgradeRequest++;
if (buildCounterCompleteNodePoolUpgradeRequest < 3) {}
buildCounterCompleteNodePoolUpgradeRequest--;
}
core.int buildCounterConfidentialNodes = 0;
api.ConfidentialNodes buildConfidentialNodes() {
final o = api.ConfidentialNodes();
buildCounterConfidentialNodes++;
if (buildCounterConfidentialNodes < 3) {
o.enabled = true;
}
buildCounterConfidentialNodes--;
return o;
}
void checkConfidentialNodes(api.ConfidentialNodes o) {
buildCounterConfidentialNodes++;
if (buildCounterConfidentialNodes < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterConfidentialNodes--;
}
core.int buildCounterConfigConnectorConfig = 0;
api.ConfigConnectorConfig buildConfigConnectorConfig() {
final o = api.ConfigConnectorConfig();
buildCounterConfigConnectorConfig++;
if (buildCounterConfigConnectorConfig < 3) {
o.enabled = true;
}
buildCounterConfigConnectorConfig--;
return o;
}
void checkConfigConnectorConfig(api.ConfigConnectorConfig o) {
buildCounterConfigConnectorConfig++;
if (buildCounterConfigConnectorConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterConfigConnectorConfig--;
}
core.int buildCounterConsumptionMeteringConfig = 0;
api.ConsumptionMeteringConfig buildConsumptionMeteringConfig() {
final o = api.ConsumptionMeteringConfig();
buildCounterConsumptionMeteringConfig++;
if (buildCounterConsumptionMeteringConfig < 3) {
o.enabled = true;
}
buildCounterConsumptionMeteringConfig--;
return o;
}
void checkConsumptionMeteringConfig(api.ConsumptionMeteringConfig o) {
buildCounterConsumptionMeteringConfig++;
if (buildCounterConsumptionMeteringConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterConsumptionMeteringConfig--;
}
core.int buildCounterCostManagementConfig = 0;
api.CostManagementConfig buildCostManagementConfig() {
final o = api.CostManagementConfig();
buildCounterCostManagementConfig++;
if (buildCounterCostManagementConfig < 3) {
o.enabled = true;
}
buildCounterCostManagementConfig--;
return o;
}
void checkCostManagementConfig(api.CostManagementConfig o) {
buildCounterCostManagementConfig++;
if (buildCounterCostManagementConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterCostManagementConfig--;
}
core.int buildCounterCreateClusterRequest = 0;
api.CreateClusterRequest buildCreateClusterRequest() {
final o = api.CreateClusterRequest();
buildCounterCreateClusterRequest++;
if (buildCounterCreateClusterRequest < 3) {
o.cluster = buildCluster();
o.parent = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterCreateClusterRequest--;
return o;
}
void checkCreateClusterRequest(api.CreateClusterRequest o) {
buildCounterCreateClusterRequest++;
if (buildCounterCreateClusterRequest < 3) {
checkCluster(o.cluster!);
unittest.expect(
o.parent!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterCreateClusterRequest--;
}
core.int buildCounterCreateNodePoolRequest = 0;
api.CreateNodePoolRequest buildCreateNodePoolRequest() {
final o = api.CreateNodePoolRequest();
buildCounterCreateNodePoolRequest++;
if (buildCounterCreateNodePoolRequest < 3) {
o.clusterId = 'foo';
o.nodePool = buildNodePool();
o.parent = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterCreateNodePoolRequest--;
return o;
}
void checkCreateNodePoolRequest(api.CreateNodePoolRequest o) {
buildCounterCreateNodePoolRequest++;
if (buildCounterCreateNodePoolRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
checkNodePool(o.nodePool!);
unittest.expect(
o.parent!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterCreateNodePoolRequest--;
}
core.int buildCounterDNSConfig = 0;
api.DNSConfig buildDNSConfig() {
final o = api.DNSConfig();
buildCounterDNSConfig++;
if (buildCounterDNSConfig < 3) {
o.clusterDns = 'foo';
o.clusterDnsDomain = 'foo';
o.clusterDnsScope = 'foo';
}
buildCounterDNSConfig--;
return o;
}
void checkDNSConfig(api.DNSConfig o) {
buildCounterDNSConfig++;
if (buildCounterDNSConfig < 3) {
unittest.expect(
o.clusterDns!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterDnsDomain!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterDnsScope!,
unittest.equals('foo'),
);
}
buildCounterDNSConfig--;
}
core.int buildCounterDailyMaintenanceWindow = 0;
api.DailyMaintenanceWindow buildDailyMaintenanceWindow() {
final o = api.DailyMaintenanceWindow();
buildCounterDailyMaintenanceWindow++;
if (buildCounterDailyMaintenanceWindow < 3) {
o.duration = 'foo';
o.startTime = 'foo';
}
buildCounterDailyMaintenanceWindow--;
return o;
}
void checkDailyMaintenanceWindow(api.DailyMaintenanceWindow o) {
buildCounterDailyMaintenanceWindow++;
if (buildCounterDailyMaintenanceWindow < 3) {
unittest.expect(
o.duration!,
unittest.equals('foo'),
);
unittest.expect(
o.startTime!,
unittest.equals('foo'),
);
}
buildCounterDailyMaintenanceWindow--;
}
core.int buildCounterDatabaseEncryption = 0;
api.DatabaseEncryption buildDatabaseEncryption() {
final o = api.DatabaseEncryption();
buildCounterDatabaseEncryption++;
if (buildCounterDatabaseEncryption < 3) {
o.keyName = 'foo';
o.state = 'foo';
}
buildCounterDatabaseEncryption--;
return o;
}
void checkDatabaseEncryption(api.DatabaseEncryption o) {
buildCounterDatabaseEncryption++;
if (buildCounterDatabaseEncryption < 3) {
unittest.expect(
o.keyName!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterDatabaseEncryption--;
}
core.int buildCounterDefaultSnatStatus = 0;
api.DefaultSnatStatus buildDefaultSnatStatus() {
final o = api.DefaultSnatStatus();
buildCounterDefaultSnatStatus++;
if (buildCounterDefaultSnatStatus < 3) {
o.disabled = true;
}
buildCounterDefaultSnatStatus--;
return o;
}
void checkDefaultSnatStatus(api.DefaultSnatStatus o) {
buildCounterDefaultSnatStatus++;
if (buildCounterDefaultSnatStatus < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
}
buildCounterDefaultSnatStatus--;
}
core.int buildCounterDnsCacheConfig = 0;
api.DnsCacheConfig buildDnsCacheConfig() {
final o = api.DnsCacheConfig();
buildCounterDnsCacheConfig++;
if (buildCounterDnsCacheConfig < 3) {
o.enabled = true;
}
buildCounterDnsCacheConfig--;
return o;
}
void checkDnsCacheConfig(api.DnsCacheConfig o) {
buildCounterDnsCacheConfig++;
if (buildCounterDnsCacheConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterDnsCacheConfig--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.int buildCounterEphemeralStorageLocalSsdConfig = 0;
api.EphemeralStorageLocalSsdConfig buildEphemeralStorageLocalSsdConfig() {
final o = api.EphemeralStorageLocalSsdConfig();
buildCounterEphemeralStorageLocalSsdConfig++;
if (buildCounterEphemeralStorageLocalSsdConfig < 3) {
o.localSsdCount = 42;
}
buildCounterEphemeralStorageLocalSsdConfig--;
return o;
}
void checkEphemeralStorageLocalSsdConfig(api.EphemeralStorageLocalSsdConfig o) {
buildCounterEphemeralStorageLocalSsdConfig++;
if (buildCounterEphemeralStorageLocalSsdConfig < 3) {
unittest.expect(
o.localSsdCount!,
unittest.equals(42),
);
}
buildCounterEphemeralStorageLocalSsdConfig--;
}
core.int buildCounterFastSocket = 0;
api.FastSocket buildFastSocket() {
final o = api.FastSocket();
buildCounterFastSocket++;
if (buildCounterFastSocket < 3) {
o.enabled = true;
}
buildCounterFastSocket--;
return o;
}
void checkFastSocket(api.FastSocket o) {
buildCounterFastSocket++;
if (buildCounterFastSocket < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterFastSocket--;
}
core.List<core.String> buildUnnamed15() => [
'foo',
'foo',
];
void checkUnnamed15(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterFilter = 0;
api.Filter buildFilter() {
final o = api.Filter();
buildCounterFilter++;
if (buildCounterFilter < 3) {
o.eventType = buildUnnamed15();
}
buildCounterFilter--;
return o;
}
void checkFilter(api.Filter o) {
buildCounterFilter++;
if (buildCounterFilter < 3) {
checkUnnamed15(o.eventType!);
}
buildCounterFilter--;
}
core.int buildCounterFleet = 0;
api.Fleet buildFleet() {
final o = api.Fleet();
buildCounterFleet++;
if (buildCounterFleet < 3) {
o.membership = 'foo';
o.preRegistered = true;
o.project = 'foo';
}
buildCounterFleet--;
return o;
}
void checkFleet(api.Fleet o) {
buildCounterFleet++;
if (buildCounterFleet < 3) {
unittest.expect(
o.membership!,
unittest.equals('foo'),
);
unittest.expect(o.preRegistered!, unittest.isTrue);
unittest.expect(
o.project!,
unittest.equals('foo'),
);
}
buildCounterFleet--;
}
core.int buildCounterGPUDriverInstallationConfig = 0;
api.GPUDriverInstallationConfig buildGPUDriverInstallationConfig() {
final o = api.GPUDriverInstallationConfig();
buildCounterGPUDriverInstallationConfig++;
if (buildCounterGPUDriverInstallationConfig < 3) {
o.gpuDriverVersion = 'foo';
}
buildCounterGPUDriverInstallationConfig--;
return o;
}
void checkGPUDriverInstallationConfig(api.GPUDriverInstallationConfig o) {
buildCounterGPUDriverInstallationConfig++;
if (buildCounterGPUDriverInstallationConfig < 3) {
unittest.expect(
o.gpuDriverVersion!,
unittest.equals('foo'),
);
}
buildCounterGPUDriverInstallationConfig--;
}
core.int buildCounterGPUSharingConfig = 0;
api.GPUSharingConfig buildGPUSharingConfig() {
final o = api.GPUSharingConfig();
buildCounterGPUSharingConfig++;
if (buildCounterGPUSharingConfig < 3) {
o.gpuSharingStrategy = 'foo';
o.maxSharedClientsPerGpu = 'foo';
}
buildCounterGPUSharingConfig--;
return o;
}
void checkGPUSharingConfig(api.GPUSharingConfig o) {
buildCounterGPUSharingConfig++;
if (buildCounterGPUSharingConfig < 3) {
unittest.expect(
o.gpuSharingStrategy!,
unittest.equals('foo'),
);
unittest.expect(
o.maxSharedClientsPerGpu!,
unittest.equals('foo'),
);
}
buildCounterGPUSharingConfig--;
}
core.int buildCounterGatewayAPIConfig = 0;
api.GatewayAPIConfig buildGatewayAPIConfig() {
final o = api.GatewayAPIConfig();
buildCounterGatewayAPIConfig++;
if (buildCounterGatewayAPIConfig < 3) {
o.channel = 'foo';
}
buildCounterGatewayAPIConfig--;
return o;
}
void checkGatewayAPIConfig(api.GatewayAPIConfig o) {
buildCounterGatewayAPIConfig++;
if (buildCounterGatewayAPIConfig < 3) {
unittest.expect(
o.channel!,
unittest.equals('foo'),
);
}
buildCounterGatewayAPIConfig--;
}
core.int buildCounterGcePersistentDiskCsiDriverConfig = 0;
api.GcePersistentDiskCsiDriverConfig buildGcePersistentDiskCsiDriverConfig() {
final o = api.GcePersistentDiskCsiDriverConfig();
buildCounterGcePersistentDiskCsiDriverConfig++;
if (buildCounterGcePersistentDiskCsiDriverConfig < 3) {
o.enabled = true;
}
buildCounterGcePersistentDiskCsiDriverConfig--;
return o;
}
void checkGcePersistentDiskCsiDriverConfig(
api.GcePersistentDiskCsiDriverConfig o) {
buildCounterGcePersistentDiskCsiDriverConfig++;
if (buildCounterGcePersistentDiskCsiDriverConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterGcePersistentDiskCsiDriverConfig--;
}
core.int buildCounterGcfsConfig = 0;
api.GcfsConfig buildGcfsConfig() {
final o = api.GcfsConfig();
buildCounterGcfsConfig++;
if (buildCounterGcfsConfig < 3) {
o.enabled = true;
}
buildCounterGcfsConfig--;
return o;
}
void checkGcfsConfig(api.GcfsConfig o) {
buildCounterGcfsConfig++;
if (buildCounterGcfsConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterGcfsConfig--;
}
core.int buildCounterGcpFilestoreCsiDriverConfig = 0;
api.GcpFilestoreCsiDriverConfig buildGcpFilestoreCsiDriverConfig() {
final o = api.GcpFilestoreCsiDriverConfig();
buildCounterGcpFilestoreCsiDriverConfig++;
if (buildCounterGcpFilestoreCsiDriverConfig < 3) {
o.enabled = true;
}
buildCounterGcpFilestoreCsiDriverConfig--;
return o;
}
void checkGcpFilestoreCsiDriverConfig(api.GcpFilestoreCsiDriverConfig o) {
buildCounterGcpFilestoreCsiDriverConfig++;
if (buildCounterGcpFilestoreCsiDriverConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterGcpFilestoreCsiDriverConfig--;
}
core.int buildCounterGcsFuseCsiDriverConfig = 0;
api.GcsFuseCsiDriverConfig buildGcsFuseCsiDriverConfig() {
final o = api.GcsFuseCsiDriverConfig();
buildCounterGcsFuseCsiDriverConfig++;
if (buildCounterGcsFuseCsiDriverConfig < 3) {
o.enabled = true;
}
buildCounterGcsFuseCsiDriverConfig--;
return o;
}
void checkGcsFuseCsiDriverConfig(api.GcsFuseCsiDriverConfig o) {
buildCounterGcsFuseCsiDriverConfig++;
if (buildCounterGcsFuseCsiDriverConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterGcsFuseCsiDriverConfig--;
}
core.List<api.Jwk> buildUnnamed16() => [
buildJwk(),
buildJwk(),
];
void checkUnnamed16(core.List<api.Jwk> o) {
unittest.expect(o, unittest.hasLength(2));
checkJwk(o[0]);
checkJwk(o[1]);
}
core.int buildCounterGetJSONWebKeysResponse = 0;
api.GetJSONWebKeysResponse buildGetJSONWebKeysResponse() {
final o = api.GetJSONWebKeysResponse();
buildCounterGetJSONWebKeysResponse++;
if (buildCounterGetJSONWebKeysResponse < 3) {
o.cacheHeader = buildHttpCacheControlResponseHeader();
o.keys = buildUnnamed16();
}
buildCounterGetJSONWebKeysResponse--;
return o;
}
void checkGetJSONWebKeysResponse(api.GetJSONWebKeysResponse o) {
buildCounterGetJSONWebKeysResponse++;
if (buildCounterGetJSONWebKeysResponse < 3) {
checkHttpCacheControlResponseHeader(o.cacheHeader!);
checkUnnamed16(o.keys!);
}
buildCounterGetJSONWebKeysResponse--;
}
core.List<core.String> buildUnnamed17() => [
'foo',
'foo',
];
void checkUnnamed17(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed18() => [
'foo',
'foo',
];
void checkUnnamed18(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed19() => [
'foo',
'foo',
];
void checkUnnamed19(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed20() => [
'foo',
'foo',
];
void checkUnnamed20(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed21() => [
'foo',
'foo',
];
void checkUnnamed21(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterGetOpenIDConfigResponse = 0;
api.GetOpenIDConfigResponse buildGetOpenIDConfigResponse() {
final o = api.GetOpenIDConfigResponse();
buildCounterGetOpenIDConfigResponse++;
if (buildCounterGetOpenIDConfigResponse < 3) {
o.cacheHeader = buildHttpCacheControlResponseHeader();
o.claimsSupported = buildUnnamed17();
o.grantTypes = buildUnnamed18();
o.idTokenSigningAlgValuesSupported = buildUnnamed19();
o.issuer = 'foo';
o.jwksUri = 'foo';
o.responseTypesSupported = buildUnnamed20();
o.subjectTypesSupported = buildUnnamed21();
}
buildCounterGetOpenIDConfigResponse--;
return o;
}
void checkGetOpenIDConfigResponse(api.GetOpenIDConfigResponse o) {
buildCounterGetOpenIDConfigResponse++;
if (buildCounterGetOpenIDConfigResponse < 3) {
checkHttpCacheControlResponseHeader(o.cacheHeader!);
checkUnnamed17(o.claimsSupported!);
checkUnnamed18(o.grantTypes!);
checkUnnamed19(o.idTokenSigningAlgValuesSupported!);
unittest.expect(
o.issuer!,
unittest.equals('foo'),
);
unittest.expect(
o.jwksUri!,
unittest.equals('foo'),
);
checkUnnamed20(o.responseTypesSupported!);
checkUnnamed21(o.subjectTypesSupported!);
}
buildCounterGetOpenIDConfigResponse--;
}
core.int buildCounterGkeBackupAgentConfig = 0;
api.GkeBackupAgentConfig buildGkeBackupAgentConfig() {
final o = api.GkeBackupAgentConfig();
buildCounterGkeBackupAgentConfig++;
if (buildCounterGkeBackupAgentConfig < 3) {
o.enabled = true;
}
buildCounterGkeBackupAgentConfig--;
return o;
}
void checkGkeBackupAgentConfig(api.GkeBackupAgentConfig o) {
buildCounterGkeBackupAgentConfig++;
if (buildCounterGkeBackupAgentConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterGkeBackupAgentConfig--;
}
core.int buildCounterHorizontalPodAutoscaling = 0;
api.HorizontalPodAutoscaling buildHorizontalPodAutoscaling() {
final o = api.HorizontalPodAutoscaling();
buildCounterHorizontalPodAutoscaling++;
if (buildCounterHorizontalPodAutoscaling < 3) {
o.disabled = true;
}
buildCounterHorizontalPodAutoscaling--;
return o;
}
void checkHorizontalPodAutoscaling(api.HorizontalPodAutoscaling o) {
buildCounterHorizontalPodAutoscaling++;
if (buildCounterHorizontalPodAutoscaling < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
}
buildCounterHorizontalPodAutoscaling--;
}
core.int buildCounterHttpCacheControlResponseHeader = 0;
api.HttpCacheControlResponseHeader buildHttpCacheControlResponseHeader() {
final o = api.HttpCacheControlResponseHeader();
buildCounterHttpCacheControlResponseHeader++;
if (buildCounterHttpCacheControlResponseHeader < 3) {
o.age = 'foo';
o.directive = 'foo';
o.expires = 'foo';
}
buildCounterHttpCacheControlResponseHeader--;
return o;
}
void checkHttpCacheControlResponseHeader(api.HttpCacheControlResponseHeader o) {
buildCounterHttpCacheControlResponseHeader++;
if (buildCounterHttpCacheControlResponseHeader < 3) {
unittest.expect(
o.age!,
unittest.equals('foo'),
);
unittest.expect(
o.directive!,
unittest.equals('foo'),
);
unittest.expect(
o.expires!,
unittest.equals('foo'),
);
}
buildCounterHttpCacheControlResponseHeader--;
}
core.int buildCounterHttpLoadBalancing = 0;
api.HttpLoadBalancing buildHttpLoadBalancing() {
final o = api.HttpLoadBalancing();
buildCounterHttpLoadBalancing++;
if (buildCounterHttpLoadBalancing < 3) {
o.disabled = true;
}
buildCounterHttpLoadBalancing--;
return o;
}
void checkHttpLoadBalancing(api.HttpLoadBalancing o) {
buildCounterHttpLoadBalancing++;
if (buildCounterHttpLoadBalancing < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
}
buildCounterHttpLoadBalancing--;
}
core.int buildCounterILBSubsettingConfig = 0;
api.ILBSubsettingConfig buildILBSubsettingConfig() {
final o = api.ILBSubsettingConfig();
buildCounterILBSubsettingConfig++;
if (buildCounterILBSubsettingConfig < 3) {
o.enabled = true;
}
buildCounterILBSubsettingConfig--;
return o;
}
void checkILBSubsettingConfig(api.ILBSubsettingConfig o) {
buildCounterILBSubsettingConfig++;
if (buildCounterILBSubsettingConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterILBSubsettingConfig--;
}
core.int buildCounterIPAllocationPolicy = 0;
api.IPAllocationPolicy buildIPAllocationPolicy() {
final o = api.IPAllocationPolicy();
buildCounterIPAllocationPolicy++;
if (buildCounterIPAllocationPolicy < 3) {
o.additionalPodRangesConfig = buildAdditionalPodRangesConfig();
o.clusterIpv4Cidr = 'foo';
o.clusterIpv4CidrBlock = 'foo';
o.clusterSecondaryRangeName = 'foo';
o.createSubnetwork = true;
o.defaultPodIpv4RangeUtilization = 42.0;
o.ipv6AccessType = 'foo';
o.nodeIpv4Cidr = 'foo';
o.nodeIpv4CidrBlock = 'foo';
o.podCidrOverprovisionConfig = buildPodCIDROverprovisionConfig();
o.servicesIpv4Cidr = 'foo';
o.servicesIpv4CidrBlock = 'foo';
o.servicesIpv6CidrBlock = 'foo';
o.servicesSecondaryRangeName = 'foo';
o.stackType = 'foo';
o.subnetIpv6CidrBlock = 'foo';
o.subnetworkName = 'foo';
o.tpuIpv4CidrBlock = 'foo';
o.useIpAliases = true;
o.useRoutes = true;
}
buildCounterIPAllocationPolicy--;
return o;
}
void checkIPAllocationPolicy(api.IPAllocationPolicy o) {
buildCounterIPAllocationPolicy++;
if (buildCounterIPAllocationPolicy < 3) {
checkAdditionalPodRangesConfig(o.additionalPodRangesConfig!);
unittest.expect(
o.clusterIpv4Cidr!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterIpv4CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterSecondaryRangeName!,
unittest.equals('foo'),
);
unittest.expect(o.createSubnetwork!, unittest.isTrue);
unittest.expect(
o.defaultPodIpv4RangeUtilization!,
unittest.equals(42.0),
);
unittest.expect(
o.ipv6AccessType!,
unittest.equals('foo'),
);
unittest.expect(
o.nodeIpv4Cidr!,
unittest.equals('foo'),
);
unittest.expect(
o.nodeIpv4CidrBlock!,
unittest.equals('foo'),
);
checkPodCIDROverprovisionConfig(o.podCidrOverprovisionConfig!);
unittest.expect(
o.servicesIpv4Cidr!,
unittest.equals('foo'),
);
unittest.expect(
o.servicesIpv4CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.servicesIpv6CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.servicesSecondaryRangeName!,
unittest.equals('foo'),
);
unittest.expect(
o.stackType!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetIpv6CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetworkName!,
unittest.equals('foo'),
);
unittest.expect(
o.tpuIpv4CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(o.useIpAliases!, unittest.isTrue);
unittest.expect(o.useRoutes!, unittest.isTrue);
}
buildCounterIPAllocationPolicy--;
}
core.int buildCounterIdentityServiceConfig = 0;
api.IdentityServiceConfig buildIdentityServiceConfig() {
final o = api.IdentityServiceConfig();
buildCounterIdentityServiceConfig++;
if (buildCounterIdentityServiceConfig < 3) {
o.enabled = true;
}
buildCounterIdentityServiceConfig--;
return o;
}
void checkIdentityServiceConfig(api.IdentityServiceConfig o) {
buildCounterIdentityServiceConfig++;
if (buildCounterIdentityServiceConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterIdentityServiceConfig--;
}
core.int buildCounterIntraNodeVisibilityConfig = 0;
api.IntraNodeVisibilityConfig buildIntraNodeVisibilityConfig() {
final o = api.IntraNodeVisibilityConfig();
buildCounterIntraNodeVisibilityConfig++;
if (buildCounterIntraNodeVisibilityConfig < 3) {
o.enabled = true;
}
buildCounterIntraNodeVisibilityConfig--;
return o;
}
void checkIntraNodeVisibilityConfig(api.IntraNodeVisibilityConfig o) {
buildCounterIntraNodeVisibilityConfig++;
if (buildCounterIntraNodeVisibilityConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterIntraNodeVisibilityConfig--;
}
core.int buildCounterJwk = 0;
api.Jwk buildJwk() {
final o = api.Jwk();
buildCounterJwk++;
if (buildCounterJwk < 3) {
o.alg = 'foo';
o.crv = 'foo';
o.e = 'foo';
o.kid = 'foo';
o.kty = 'foo';
o.n = 'foo';
o.use = 'foo';
o.x = 'foo';
o.y = 'foo';
}
buildCounterJwk--;
return o;
}
void checkJwk(api.Jwk o) {
buildCounterJwk++;
if (buildCounterJwk < 3) {
unittest.expect(
o.alg!,
unittest.equals('foo'),
);
unittest.expect(
o.crv!,
unittest.equals('foo'),
);
unittest.expect(
o.e!,
unittest.equals('foo'),
);
unittest.expect(
o.kid!,
unittest.equals('foo'),
);
unittest.expect(
o.kty!,
unittest.equals('foo'),
);
unittest.expect(
o.n!,
unittest.equals('foo'),
);
unittest.expect(
o.use!,
unittest.equals('foo'),
);
unittest.expect(
o.x!,
unittest.equals('foo'),
);
unittest.expect(
o.y!,
unittest.equals('foo'),
);
}
buildCounterJwk--;
}
core.List<core.String> buildUnnamed22() => [
'foo',
'foo',
];
void checkUnnamed22(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterK8sBetaAPIConfig = 0;
api.K8sBetaAPIConfig buildK8sBetaAPIConfig() {
final o = api.K8sBetaAPIConfig();
buildCounterK8sBetaAPIConfig++;
if (buildCounterK8sBetaAPIConfig < 3) {
o.enabledApis = buildUnnamed22();
}
buildCounterK8sBetaAPIConfig--;
return o;
}
void checkK8sBetaAPIConfig(api.K8sBetaAPIConfig o) {
buildCounterK8sBetaAPIConfig++;
if (buildCounterK8sBetaAPIConfig < 3) {
checkUnnamed22(o.enabledApis!);
}
buildCounterK8sBetaAPIConfig--;
}
core.int buildCounterKubernetesDashboard = 0;
api.KubernetesDashboard buildKubernetesDashboard() {
final o = api.KubernetesDashboard();
buildCounterKubernetesDashboard++;
if (buildCounterKubernetesDashboard < 3) {
o.disabled = true;
}
buildCounterKubernetesDashboard--;
return o;
}
void checkKubernetesDashboard(api.KubernetesDashboard o) {
buildCounterKubernetesDashboard++;
if (buildCounterKubernetesDashboard < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
}
buildCounterKubernetesDashboard--;
}
core.int buildCounterLegacyAbac = 0;
api.LegacyAbac buildLegacyAbac() {
final o = api.LegacyAbac();
buildCounterLegacyAbac++;
if (buildCounterLegacyAbac < 3) {
o.enabled = true;
}
buildCounterLegacyAbac--;
return o;
}
void checkLegacyAbac(api.LegacyAbac o) {
buildCounterLegacyAbac++;
if (buildCounterLegacyAbac < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterLegacyAbac--;
}
core.Map<core.String, core.String> buildUnnamed23() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed23(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterLinuxNodeConfig = 0;
api.LinuxNodeConfig buildLinuxNodeConfig() {
final o = api.LinuxNodeConfig();
buildCounterLinuxNodeConfig++;
if (buildCounterLinuxNodeConfig < 3) {
o.cgroupMode = 'foo';
o.sysctls = buildUnnamed23();
}
buildCounterLinuxNodeConfig--;
return o;
}
void checkLinuxNodeConfig(api.LinuxNodeConfig o) {
buildCounterLinuxNodeConfig++;
if (buildCounterLinuxNodeConfig < 3) {
unittest.expect(
o.cgroupMode!,
unittest.equals('foo'),
);
checkUnnamed23(o.sysctls!);
}
buildCounterLinuxNodeConfig--;
}
core.List<api.Cluster> buildUnnamed24() => [
buildCluster(),
buildCluster(),
];
void checkUnnamed24(core.List<api.Cluster> o) {
unittest.expect(o, unittest.hasLength(2));
checkCluster(o[0]);
checkCluster(o[1]);
}
core.List<core.String> buildUnnamed25() => [
'foo',
'foo',
];
void checkUnnamed25(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterListClustersResponse = 0;
api.ListClustersResponse buildListClustersResponse() {
final o = api.ListClustersResponse();
buildCounterListClustersResponse++;
if (buildCounterListClustersResponse < 3) {
o.clusters = buildUnnamed24();
o.missingZones = buildUnnamed25();
}
buildCounterListClustersResponse--;
return o;
}
void checkListClustersResponse(api.ListClustersResponse o) {
buildCounterListClustersResponse++;
if (buildCounterListClustersResponse < 3) {
checkUnnamed24(o.clusters!);
checkUnnamed25(o.missingZones!);
}
buildCounterListClustersResponse--;
}
core.List<api.NodePool> buildUnnamed26() => [
buildNodePool(),
buildNodePool(),
];
void checkUnnamed26(core.List<api.NodePool> o) {
unittest.expect(o, unittest.hasLength(2));
checkNodePool(o[0]);
checkNodePool(o[1]);
}
core.int buildCounterListNodePoolsResponse = 0;
api.ListNodePoolsResponse buildListNodePoolsResponse() {
final o = api.ListNodePoolsResponse();
buildCounterListNodePoolsResponse++;
if (buildCounterListNodePoolsResponse < 3) {
o.nodePools = buildUnnamed26();
}
buildCounterListNodePoolsResponse--;
return o;
}
void checkListNodePoolsResponse(api.ListNodePoolsResponse o) {
buildCounterListNodePoolsResponse++;
if (buildCounterListNodePoolsResponse < 3) {
checkUnnamed26(o.nodePools!);
}
buildCounterListNodePoolsResponse--;
}
core.List<core.String> buildUnnamed27() => [
'foo',
'foo',
];
void checkUnnamed27(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.Operation> buildUnnamed28() => [
buildOperation(),
buildOperation(),
];
void checkUnnamed28(core.List<api.Operation> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperation(o[0]);
checkOperation(o[1]);
}
core.int buildCounterListOperationsResponse = 0;
api.ListOperationsResponse buildListOperationsResponse() {
final o = api.ListOperationsResponse();
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
o.missingZones = buildUnnamed27();
o.operations = buildUnnamed28();
}
buildCounterListOperationsResponse--;
return o;
}
void checkListOperationsResponse(api.ListOperationsResponse o) {
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
checkUnnamed27(o.missingZones!);
checkUnnamed28(o.operations!);
}
buildCounterListOperationsResponse--;
}
core.List<api.UsableSubnetwork> buildUnnamed29() => [
buildUsableSubnetwork(),
buildUsableSubnetwork(),
];
void checkUnnamed29(core.List<api.UsableSubnetwork> o) {
unittest.expect(o, unittest.hasLength(2));
checkUsableSubnetwork(o[0]);
checkUsableSubnetwork(o[1]);
}
core.int buildCounterListUsableSubnetworksResponse = 0;
api.ListUsableSubnetworksResponse buildListUsableSubnetworksResponse() {
final o = api.ListUsableSubnetworksResponse();
buildCounterListUsableSubnetworksResponse++;
if (buildCounterListUsableSubnetworksResponse < 3) {
o.nextPageToken = 'foo';
o.subnetworks = buildUnnamed29();
}
buildCounterListUsableSubnetworksResponse--;
return o;
}
void checkListUsableSubnetworksResponse(api.ListUsableSubnetworksResponse o) {
buildCounterListUsableSubnetworksResponse++;
if (buildCounterListUsableSubnetworksResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed29(o.subnetworks!);
}
buildCounterListUsableSubnetworksResponse--;
}
core.int buildCounterLocalNvmeSsdBlockConfig = 0;
api.LocalNvmeSsdBlockConfig buildLocalNvmeSsdBlockConfig() {
final o = api.LocalNvmeSsdBlockConfig();
buildCounterLocalNvmeSsdBlockConfig++;
if (buildCounterLocalNvmeSsdBlockConfig < 3) {
o.localSsdCount = 42;
}
buildCounterLocalNvmeSsdBlockConfig--;
return o;
}
void checkLocalNvmeSsdBlockConfig(api.LocalNvmeSsdBlockConfig o) {
buildCounterLocalNvmeSsdBlockConfig++;
if (buildCounterLocalNvmeSsdBlockConfig < 3) {
unittest.expect(
o.localSsdCount!,
unittest.equals(42),
);
}
buildCounterLocalNvmeSsdBlockConfig--;
}
core.List<core.String> buildUnnamed30() => [
'foo',
'foo',
];
void checkUnnamed30(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterLoggingComponentConfig = 0;
api.LoggingComponentConfig buildLoggingComponentConfig() {
final o = api.LoggingComponentConfig();
buildCounterLoggingComponentConfig++;
if (buildCounterLoggingComponentConfig < 3) {
o.enableComponents = buildUnnamed30();
}
buildCounterLoggingComponentConfig--;
return o;
}
void checkLoggingComponentConfig(api.LoggingComponentConfig o) {
buildCounterLoggingComponentConfig++;
if (buildCounterLoggingComponentConfig < 3) {
checkUnnamed30(o.enableComponents!);
}
buildCounterLoggingComponentConfig--;
}
core.int buildCounterLoggingConfig = 0;
api.LoggingConfig buildLoggingConfig() {
final o = api.LoggingConfig();
buildCounterLoggingConfig++;
if (buildCounterLoggingConfig < 3) {
o.componentConfig = buildLoggingComponentConfig();
}
buildCounterLoggingConfig--;
return o;
}
void checkLoggingConfig(api.LoggingConfig o) {
buildCounterLoggingConfig++;
if (buildCounterLoggingConfig < 3) {
checkLoggingComponentConfig(o.componentConfig!);
}
buildCounterLoggingConfig--;
}
core.int buildCounterLoggingVariantConfig = 0;
api.LoggingVariantConfig buildLoggingVariantConfig() {
final o = api.LoggingVariantConfig();
buildCounterLoggingVariantConfig++;
if (buildCounterLoggingVariantConfig < 3) {
o.variant = 'foo';
}
buildCounterLoggingVariantConfig--;
return o;
}
void checkLoggingVariantConfig(api.LoggingVariantConfig o) {
buildCounterLoggingVariantConfig++;
if (buildCounterLoggingVariantConfig < 3) {
unittest.expect(
o.variant!,
unittest.equals('foo'),
);
}
buildCounterLoggingVariantConfig--;
}
core.int buildCounterMaintenanceExclusionOptions = 0;
api.MaintenanceExclusionOptions buildMaintenanceExclusionOptions() {
final o = api.MaintenanceExclusionOptions();
buildCounterMaintenanceExclusionOptions++;
if (buildCounterMaintenanceExclusionOptions < 3) {
o.scope = 'foo';
}
buildCounterMaintenanceExclusionOptions--;
return o;
}
void checkMaintenanceExclusionOptions(api.MaintenanceExclusionOptions o) {
buildCounterMaintenanceExclusionOptions++;
if (buildCounterMaintenanceExclusionOptions < 3) {
unittest.expect(
o.scope!,
unittest.equals('foo'),
);
}
buildCounterMaintenanceExclusionOptions--;
}
core.int buildCounterMaintenancePolicy = 0;
api.MaintenancePolicy buildMaintenancePolicy() {
final o = api.MaintenancePolicy();
buildCounterMaintenancePolicy++;
if (buildCounterMaintenancePolicy < 3) {
o.resourceVersion = 'foo';
o.window = buildMaintenanceWindow();
}
buildCounterMaintenancePolicy--;
return o;
}
void checkMaintenancePolicy(api.MaintenancePolicy o) {
buildCounterMaintenancePolicy++;
if (buildCounterMaintenancePolicy < 3) {
unittest.expect(
o.resourceVersion!,
unittest.equals('foo'),
);
checkMaintenanceWindow(o.window!);
}
buildCounterMaintenancePolicy--;
}
core.Map<core.String, api.TimeWindow> buildUnnamed31() => {
'x': buildTimeWindow(),
'y': buildTimeWindow(),
};
void checkUnnamed31(core.Map<core.String, api.TimeWindow> o) {
unittest.expect(o, unittest.hasLength(2));
checkTimeWindow(o['x']!);
checkTimeWindow(o['y']!);
}
core.int buildCounterMaintenanceWindow = 0;
api.MaintenanceWindow buildMaintenanceWindow() {
final o = api.MaintenanceWindow();
buildCounterMaintenanceWindow++;
if (buildCounterMaintenanceWindow < 3) {
o.dailyMaintenanceWindow = buildDailyMaintenanceWindow();
o.maintenanceExclusions = buildUnnamed31();
o.recurringWindow = buildRecurringTimeWindow();
}
buildCounterMaintenanceWindow--;
return o;
}
void checkMaintenanceWindow(api.MaintenanceWindow o) {
buildCounterMaintenanceWindow++;
if (buildCounterMaintenanceWindow < 3) {
checkDailyMaintenanceWindow(o.dailyMaintenanceWindow!);
checkUnnamed31(o.maintenanceExclusions!);
checkRecurringTimeWindow(o.recurringWindow!);
}
buildCounterMaintenanceWindow--;
}
core.int buildCounterManagedPrometheusConfig = 0;
api.ManagedPrometheusConfig buildManagedPrometheusConfig() {
final o = api.ManagedPrometheusConfig();
buildCounterManagedPrometheusConfig++;
if (buildCounterManagedPrometheusConfig < 3) {
o.enabled = true;
}
buildCounterManagedPrometheusConfig--;
return o;
}
void checkManagedPrometheusConfig(api.ManagedPrometheusConfig o) {
buildCounterManagedPrometheusConfig++;
if (buildCounterManagedPrometheusConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterManagedPrometheusConfig--;
}
core.int buildCounterMasterAuth = 0;
api.MasterAuth buildMasterAuth() {
final o = api.MasterAuth();
buildCounterMasterAuth++;
if (buildCounterMasterAuth < 3) {
o.clientCertificate = 'foo';
o.clientCertificateConfig = buildClientCertificateConfig();
o.clientKey = 'foo';
o.clusterCaCertificate = 'foo';
o.password = 'foo';
o.username = 'foo';
}
buildCounterMasterAuth--;
return o;
}
void checkMasterAuth(api.MasterAuth o) {
buildCounterMasterAuth++;
if (buildCounterMasterAuth < 3) {
unittest.expect(
o.clientCertificate!,
unittest.equals('foo'),
);
checkClientCertificateConfig(o.clientCertificateConfig!);
unittest.expect(
o.clientKey!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterCaCertificate!,
unittest.equals('foo'),
);
unittest.expect(
o.password!,
unittest.equals('foo'),
);
unittest.expect(
o.username!,
unittest.equals('foo'),
);
}
buildCounterMasterAuth--;
}
core.List<api.CidrBlock> buildUnnamed32() => [
buildCidrBlock(),
buildCidrBlock(),
];
void checkUnnamed32(core.List<api.CidrBlock> o) {
unittest.expect(o, unittest.hasLength(2));
checkCidrBlock(o[0]);
checkCidrBlock(o[1]);
}
core.int buildCounterMasterAuthorizedNetworksConfig = 0;
api.MasterAuthorizedNetworksConfig buildMasterAuthorizedNetworksConfig() {
final o = api.MasterAuthorizedNetworksConfig();
buildCounterMasterAuthorizedNetworksConfig++;
if (buildCounterMasterAuthorizedNetworksConfig < 3) {
o.cidrBlocks = buildUnnamed32();
o.enabled = true;
o.gcpPublicCidrsAccessEnabled = true;
}
buildCounterMasterAuthorizedNetworksConfig--;
return o;
}
void checkMasterAuthorizedNetworksConfig(api.MasterAuthorizedNetworksConfig o) {
buildCounterMasterAuthorizedNetworksConfig++;
if (buildCounterMasterAuthorizedNetworksConfig < 3) {
checkUnnamed32(o.cidrBlocks!);
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(o.gcpPublicCidrsAccessEnabled!, unittest.isTrue);
}
buildCounterMasterAuthorizedNetworksConfig--;
}
core.int buildCounterMaxPodsConstraint = 0;
api.MaxPodsConstraint buildMaxPodsConstraint() {
final o = api.MaxPodsConstraint();
buildCounterMaxPodsConstraint++;
if (buildCounterMaxPodsConstraint < 3) {
o.maxPodsPerNode = 'foo';
}
buildCounterMaxPodsConstraint--;
return o;
}
void checkMaxPodsConstraint(api.MaxPodsConstraint o) {
buildCounterMaxPodsConstraint++;
if (buildCounterMaxPodsConstraint < 3) {
unittest.expect(
o.maxPodsPerNode!,
unittest.equals('foo'),
);
}
buildCounterMaxPodsConstraint--;
}
core.int buildCounterMeshCertificates = 0;
api.MeshCertificates buildMeshCertificates() {
final o = api.MeshCertificates();
buildCounterMeshCertificates++;
if (buildCounterMeshCertificates < 3) {
o.enableCertificates = true;
}
buildCounterMeshCertificates--;
return o;
}
void checkMeshCertificates(api.MeshCertificates o) {
buildCounterMeshCertificates++;
if (buildCounterMeshCertificates < 3) {
unittest.expect(o.enableCertificates!, unittest.isTrue);
}
buildCounterMeshCertificates--;
}
core.int buildCounterMetric = 0;
api.Metric buildMetric() {
final o = api.Metric();
buildCounterMetric++;
if (buildCounterMetric < 3) {
o.doubleValue = 42.0;
o.intValue = 'foo';
o.name = 'foo';
o.stringValue = 'foo';
}
buildCounterMetric--;
return o;
}
void checkMetric(api.Metric o) {
buildCounterMetric++;
if (buildCounterMetric < 3) {
unittest.expect(
o.doubleValue!,
unittest.equals(42.0),
);
unittest.expect(
o.intValue!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.stringValue!,
unittest.equals('foo'),
);
}
buildCounterMetric--;
}
core.List<core.String> buildUnnamed33() => [
'foo',
'foo',
];
void checkUnnamed33(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterMonitoringComponentConfig = 0;
api.MonitoringComponentConfig buildMonitoringComponentConfig() {
final o = api.MonitoringComponentConfig();
buildCounterMonitoringComponentConfig++;
if (buildCounterMonitoringComponentConfig < 3) {
o.enableComponents = buildUnnamed33();
}
buildCounterMonitoringComponentConfig--;
return o;
}
void checkMonitoringComponentConfig(api.MonitoringComponentConfig o) {
buildCounterMonitoringComponentConfig++;
if (buildCounterMonitoringComponentConfig < 3) {
checkUnnamed33(o.enableComponents!);
}
buildCounterMonitoringComponentConfig--;
}
core.int buildCounterMonitoringConfig = 0;
api.MonitoringConfig buildMonitoringConfig() {
final o = api.MonitoringConfig();
buildCounterMonitoringConfig++;
if (buildCounterMonitoringConfig < 3) {
o.advancedDatapathObservabilityConfig =
buildAdvancedDatapathObservabilityConfig();
o.componentConfig = buildMonitoringComponentConfig();
o.managedPrometheusConfig = buildManagedPrometheusConfig();
}
buildCounterMonitoringConfig--;
return o;
}
void checkMonitoringConfig(api.MonitoringConfig o) {
buildCounterMonitoringConfig++;
if (buildCounterMonitoringConfig < 3) {
checkAdvancedDatapathObservabilityConfig(
o.advancedDatapathObservabilityConfig!);
checkMonitoringComponentConfig(o.componentConfig!);
checkManagedPrometheusConfig(o.managedPrometheusConfig!);
}
buildCounterMonitoringConfig--;
}
core.int buildCounterNetworkConfig = 0;
api.NetworkConfig buildNetworkConfig() {
final o = api.NetworkConfig();
buildCounterNetworkConfig++;
if (buildCounterNetworkConfig < 3) {
o.datapathProvider = 'foo';
o.defaultSnatStatus = buildDefaultSnatStatus();
o.dnsConfig = buildDNSConfig();
o.enableFqdnNetworkPolicy = true;
o.enableIntraNodeVisibility = true;
o.enableL4ilbSubsetting = true;
o.enableMultiNetworking = true;
o.gatewayApiConfig = buildGatewayAPIConfig();
o.network = 'foo';
o.networkPerformanceConfig = buildClusterNetworkPerformanceConfig();
o.privateIpv6GoogleAccess = 'foo';
o.serviceExternalIpsConfig = buildServiceExternalIPsConfig();
o.subnetwork = 'foo';
}
buildCounterNetworkConfig--;
return o;
}
void checkNetworkConfig(api.NetworkConfig o) {
buildCounterNetworkConfig++;
if (buildCounterNetworkConfig < 3) {
unittest.expect(
o.datapathProvider!,
unittest.equals('foo'),
);
checkDefaultSnatStatus(o.defaultSnatStatus!);
checkDNSConfig(o.dnsConfig!);
unittest.expect(o.enableFqdnNetworkPolicy!, unittest.isTrue);
unittest.expect(o.enableIntraNodeVisibility!, unittest.isTrue);
unittest.expect(o.enableL4ilbSubsetting!, unittest.isTrue);
unittest.expect(o.enableMultiNetworking!, unittest.isTrue);
checkGatewayAPIConfig(o.gatewayApiConfig!);
unittest.expect(
o.network!,
unittest.equals('foo'),
);
checkClusterNetworkPerformanceConfig(o.networkPerformanceConfig!);
unittest.expect(
o.privateIpv6GoogleAccess!,
unittest.equals('foo'),
);
checkServiceExternalIPsConfig(o.serviceExternalIpsConfig!);
unittest.expect(
o.subnetwork!,
unittest.equals('foo'),
);
}
buildCounterNetworkConfig--;
}
core.int buildCounterNetworkPerformanceConfig = 0;
api.NetworkPerformanceConfig buildNetworkPerformanceConfig() {
final o = api.NetworkPerformanceConfig();
buildCounterNetworkPerformanceConfig++;
if (buildCounterNetworkPerformanceConfig < 3) {
o.totalEgressBandwidthTier = 'foo';
}
buildCounterNetworkPerformanceConfig--;
return o;
}
void checkNetworkPerformanceConfig(api.NetworkPerformanceConfig o) {
buildCounterNetworkPerformanceConfig++;
if (buildCounterNetworkPerformanceConfig < 3) {
unittest.expect(
o.totalEgressBandwidthTier!,
unittest.equals('foo'),
);
}
buildCounterNetworkPerformanceConfig--;
}
core.int buildCounterNetworkPolicy = 0;
api.NetworkPolicy buildNetworkPolicy() {
final o = api.NetworkPolicy();
buildCounterNetworkPolicy++;
if (buildCounterNetworkPolicy < 3) {
o.enabled = true;
o.provider = 'foo';
}
buildCounterNetworkPolicy--;
return o;
}
void checkNetworkPolicy(api.NetworkPolicy o) {
buildCounterNetworkPolicy++;
if (buildCounterNetworkPolicy < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.provider!,
unittest.equals('foo'),
);
}
buildCounterNetworkPolicy--;
}
core.int buildCounterNetworkPolicyConfig = 0;
api.NetworkPolicyConfig buildNetworkPolicyConfig() {
final o = api.NetworkPolicyConfig();
buildCounterNetworkPolicyConfig++;
if (buildCounterNetworkPolicyConfig < 3) {
o.disabled = true;
}
buildCounterNetworkPolicyConfig--;
return o;
}
void checkNetworkPolicyConfig(api.NetworkPolicyConfig o) {
buildCounterNetworkPolicyConfig++;
if (buildCounterNetworkPolicyConfig < 3) {
unittest.expect(o.disabled!, unittest.isTrue);
}
buildCounterNetworkPolicyConfig--;
}
core.List<core.String> buildUnnamed34() => [
'foo',
'foo',
];
void checkUnnamed34(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterNetworkTags = 0;
api.NetworkTags buildNetworkTags() {
final o = api.NetworkTags();
buildCounterNetworkTags++;
if (buildCounterNetworkTags < 3) {
o.tags = buildUnnamed34();
}
buildCounterNetworkTags--;
return o;
}
void checkNetworkTags(api.NetworkTags o) {
buildCounterNetworkTags++;
if (buildCounterNetworkTags < 3) {
checkUnnamed34(o.tags!);
}
buildCounterNetworkTags--;
}
core.List<core.String> buildUnnamed35() => [
'foo',
'foo',
];
void checkUnnamed35(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterNodeAffinity = 0;
api.NodeAffinity buildNodeAffinity() {
final o = api.NodeAffinity();
buildCounterNodeAffinity++;
if (buildCounterNodeAffinity < 3) {
o.key = 'foo';
o.operator = 'foo';
o.values = buildUnnamed35();
}
buildCounterNodeAffinity--;
return o;
}
void checkNodeAffinity(api.NodeAffinity o) {
buildCounterNodeAffinity++;
if (buildCounterNodeAffinity < 3) {
unittest.expect(
o.key!,
unittest.equals('foo'),
);
unittest.expect(
o.operator!,
unittest.equals('foo'),
);
checkUnnamed35(o.values!);
}
buildCounterNodeAffinity--;
}
core.List<api.AcceleratorConfig> buildUnnamed36() => [
buildAcceleratorConfig(),
buildAcceleratorConfig(),
];
void checkUnnamed36(core.List<api.AcceleratorConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAcceleratorConfig(o[0]);
checkAcceleratorConfig(o[1]);
}
core.Map<core.String, core.String> buildUnnamed37() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed37(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.String> buildUnnamed38() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed38(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed39() => [
'foo',
'foo',
];
void checkUnnamed39(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.Map<core.String, core.String> buildUnnamed40() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed40(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed41() => [
'foo',
'foo',
];
void checkUnnamed41(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.NodeTaint> buildUnnamed42() => [
buildNodeTaint(),
buildNodeTaint(),
];
void checkUnnamed42(core.List<api.NodeTaint> o) {
unittest.expect(o, unittest.hasLength(2));
checkNodeTaint(o[0]);
checkNodeTaint(o[1]);
}
core.int buildCounterNodeConfig = 0;
api.NodeConfig buildNodeConfig() {
final o = api.NodeConfig();
buildCounterNodeConfig++;
if (buildCounterNodeConfig < 3) {
o.accelerators = buildUnnamed36();
o.advancedMachineFeatures = buildAdvancedMachineFeatures();
o.bootDiskKmsKey = 'foo';
o.confidentialNodes = buildConfidentialNodes();
o.diskSizeGb = 42;
o.diskType = 'foo';
o.ephemeralStorageLocalSsdConfig = buildEphemeralStorageLocalSsdConfig();
o.fastSocket = buildFastSocket();
o.gcfsConfig = buildGcfsConfig();
o.gvnic = buildVirtualNIC();
o.imageType = 'foo';
o.kubeletConfig = buildNodeKubeletConfig();
o.labels = buildUnnamed37();
o.linuxNodeConfig = buildLinuxNodeConfig();
o.localNvmeSsdBlockConfig = buildLocalNvmeSsdBlockConfig();
o.localSsdCount = 42;
o.loggingConfig = buildNodePoolLoggingConfig();
o.machineType = 'foo';
o.metadata = buildUnnamed38();
o.minCpuPlatform = 'foo';
o.nodeGroup = 'foo';
o.oauthScopes = buildUnnamed39();
o.preemptible = true;
o.reservationAffinity = buildReservationAffinity();
o.resourceLabels = buildUnnamed40();
o.sandboxConfig = buildSandboxConfig();
o.serviceAccount = 'foo';
o.shieldedInstanceConfig = buildShieldedInstanceConfig();
o.soleTenantConfig = buildSoleTenantConfig();
o.spot = true;
o.tags = buildUnnamed41();
o.taints = buildUnnamed42();
o.windowsNodeConfig = buildWindowsNodeConfig();
o.workloadMetadataConfig = buildWorkloadMetadataConfig();
}
buildCounterNodeConfig--;
return o;
}
void checkNodeConfig(api.NodeConfig o) {
buildCounterNodeConfig++;
if (buildCounterNodeConfig < 3) {
checkUnnamed36(o.accelerators!);
checkAdvancedMachineFeatures(o.advancedMachineFeatures!);
unittest.expect(
o.bootDiskKmsKey!,
unittest.equals('foo'),
);
checkConfidentialNodes(o.confidentialNodes!);
unittest.expect(
o.diskSizeGb!,
unittest.equals(42),
);
unittest.expect(
o.diskType!,
unittest.equals('foo'),
);
checkEphemeralStorageLocalSsdConfig(o.ephemeralStorageLocalSsdConfig!);
checkFastSocket(o.fastSocket!);
checkGcfsConfig(o.gcfsConfig!);
checkVirtualNIC(o.gvnic!);
unittest.expect(
o.imageType!,
unittest.equals('foo'),
);
checkNodeKubeletConfig(o.kubeletConfig!);
checkUnnamed37(o.labels!);
checkLinuxNodeConfig(o.linuxNodeConfig!);
checkLocalNvmeSsdBlockConfig(o.localNvmeSsdBlockConfig!);
unittest.expect(
o.localSsdCount!,
unittest.equals(42),
);
checkNodePoolLoggingConfig(o.loggingConfig!);
unittest.expect(
o.machineType!,
unittest.equals('foo'),
);
checkUnnamed38(o.metadata!);
unittest.expect(
o.minCpuPlatform!,
unittest.equals('foo'),
);
unittest.expect(
o.nodeGroup!,
unittest.equals('foo'),
);
checkUnnamed39(o.oauthScopes!);
unittest.expect(o.preemptible!, unittest.isTrue);
checkReservationAffinity(o.reservationAffinity!);
checkUnnamed40(o.resourceLabels!);
checkSandboxConfig(o.sandboxConfig!);
unittest.expect(
o.serviceAccount!,
unittest.equals('foo'),
);
checkShieldedInstanceConfig(o.shieldedInstanceConfig!);
checkSoleTenantConfig(o.soleTenantConfig!);
unittest.expect(o.spot!, unittest.isTrue);
checkUnnamed41(o.tags!);
checkUnnamed42(o.taints!);
checkWindowsNodeConfig(o.windowsNodeConfig!);
checkWorkloadMetadataConfig(o.workloadMetadataConfig!);
}
buildCounterNodeConfig--;
}
core.int buildCounterNodeConfigDefaults = 0;
api.NodeConfigDefaults buildNodeConfigDefaults() {
final o = api.NodeConfigDefaults();
buildCounterNodeConfigDefaults++;
if (buildCounterNodeConfigDefaults < 3) {
o.gcfsConfig = buildGcfsConfig();
o.loggingConfig = buildNodePoolLoggingConfig();
}
buildCounterNodeConfigDefaults--;
return o;
}
void checkNodeConfigDefaults(api.NodeConfigDefaults o) {
buildCounterNodeConfigDefaults++;
if (buildCounterNodeConfigDefaults < 3) {
checkGcfsConfig(o.gcfsConfig!);
checkNodePoolLoggingConfig(o.loggingConfig!);
}
buildCounterNodeConfigDefaults--;
}
core.int buildCounterNodeKubeletConfig = 0;
api.NodeKubeletConfig buildNodeKubeletConfig() {
final o = api.NodeKubeletConfig();
buildCounterNodeKubeletConfig++;
if (buildCounterNodeKubeletConfig < 3) {
o.cpuCfsQuota = true;
o.cpuCfsQuotaPeriod = 'foo';
o.cpuManagerPolicy = 'foo';
o.insecureKubeletReadonlyPortEnabled = true;
o.podPidsLimit = 'foo';
}
buildCounterNodeKubeletConfig--;
return o;
}
void checkNodeKubeletConfig(api.NodeKubeletConfig o) {
buildCounterNodeKubeletConfig++;
if (buildCounterNodeKubeletConfig < 3) {
unittest.expect(o.cpuCfsQuota!, unittest.isTrue);
unittest.expect(
o.cpuCfsQuotaPeriod!,
unittest.equals('foo'),
);
unittest.expect(
o.cpuManagerPolicy!,
unittest.equals('foo'),
);
unittest.expect(o.insecureKubeletReadonlyPortEnabled!, unittest.isTrue);
unittest.expect(
o.podPidsLimit!,
unittest.equals('foo'),
);
}
buildCounterNodeKubeletConfig--;
}
core.Map<core.String, core.String> buildUnnamed43() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed43(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterNodeLabels = 0;
api.NodeLabels buildNodeLabels() {
final o = api.NodeLabels();
buildCounterNodeLabels++;
if (buildCounterNodeLabels < 3) {
o.labels = buildUnnamed43();
}
buildCounterNodeLabels--;
return o;
}
void checkNodeLabels(api.NodeLabels o) {
buildCounterNodeLabels++;
if (buildCounterNodeLabels < 3) {
checkUnnamed43(o.labels!);
}
buildCounterNodeLabels--;
}
core.int buildCounterNodeManagement = 0;
api.NodeManagement buildNodeManagement() {
final o = api.NodeManagement();
buildCounterNodeManagement++;
if (buildCounterNodeManagement < 3) {
o.autoRepair = true;
o.autoUpgrade = true;
o.upgradeOptions = buildAutoUpgradeOptions();
}
buildCounterNodeManagement--;
return o;
}
void checkNodeManagement(api.NodeManagement o) {
buildCounterNodeManagement++;
if (buildCounterNodeManagement < 3) {
unittest.expect(o.autoRepair!, unittest.isTrue);
unittest.expect(o.autoUpgrade!, unittest.isTrue);
checkAutoUpgradeOptions(o.upgradeOptions!);
}
buildCounterNodeManagement--;
}
core.List<api.AdditionalNodeNetworkConfig> buildUnnamed44() => [
buildAdditionalNodeNetworkConfig(),
buildAdditionalNodeNetworkConfig(),
];
void checkUnnamed44(core.List<api.AdditionalNodeNetworkConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdditionalNodeNetworkConfig(o[0]);
checkAdditionalNodeNetworkConfig(o[1]);
}
core.List<api.AdditionalPodNetworkConfig> buildUnnamed45() => [
buildAdditionalPodNetworkConfig(),
buildAdditionalPodNetworkConfig(),
];
void checkUnnamed45(core.List<api.AdditionalPodNetworkConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdditionalPodNetworkConfig(o[0]);
checkAdditionalPodNetworkConfig(o[1]);
}
core.int buildCounterNodeNetworkConfig = 0;
api.NodeNetworkConfig buildNodeNetworkConfig() {
final o = api.NodeNetworkConfig();
buildCounterNodeNetworkConfig++;
if (buildCounterNodeNetworkConfig < 3) {
o.additionalNodeNetworkConfigs = buildUnnamed44();
o.additionalPodNetworkConfigs = buildUnnamed45();
o.createPodRange = true;
o.enablePrivateNodes = true;
o.networkPerformanceConfig = buildNetworkPerformanceConfig();
o.podCidrOverprovisionConfig = buildPodCIDROverprovisionConfig();
o.podIpv4CidrBlock = 'foo';
o.podIpv4RangeUtilization = 42.0;
o.podRange = 'foo';
}
buildCounterNodeNetworkConfig--;
return o;
}
void checkNodeNetworkConfig(api.NodeNetworkConfig o) {
buildCounterNodeNetworkConfig++;
if (buildCounterNodeNetworkConfig < 3) {
checkUnnamed44(o.additionalNodeNetworkConfigs!);
checkUnnamed45(o.additionalPodNetworkConfigs!);
unittest.expect(o.createPodRange!, unittest.isTrue);
unittest.expect(o.enablePrivateNodes!, unittest.isTrue);
checkNetworkPerformanceConfig(o.networkPerformanceConfig!);
checkPodCIDROverprovisionConfig(o.podCidrOverprovisionConfig!);
unittest.expect(
o.podIpv4CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.podIpv4RangeUtilization!,
unittest.equals(42.0),
);
unittest.expect(
o.podRange!,
unittest.equals('foo'),
);
}
buildCounterNodeNetworkConfig--;
}
core.List<api.StatusCondition> buildUnnamed46() => [
buildStatusCondition(),
buildStatusCondition(),
];
void checkUnnamed46(core.List<api.StatusCondition> o) {
unittest.expect(o, unittest.hasLength(2));
checkStatusCondition(o[0]);
checkStatusCondition(o[1]);
}
core.List<core.String> buildUnnamed47() => [
'foo',
'foo',
];
void checkUnnamed47(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed48() => [
'foo',
'foo',
];
void checkUnnamed48(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterNodePool = 0;
api.NodePool buildNodePool() {
final o = api.NodePool();
buildCounterNodePool++;
if (buildCounterNodePool < 3) {
o.autoscaling = buildNodePoolAutoscaling();
o.bestEffortProvisioning = buildBestEffortProvisioning();
o.conditions = buildUnnamed46();
o.config = buildNodeConfig();
o.etag = 'foo';
o.initialNodeCount = 42;
o.instanceGroupUrls = buildUnnamed47();
o.locations = buildUnnamed48();
o.management = buildNodeManagement();
o.maxPodsConstraint = buildMaxPodsConstraint();
o.name = 'foo';
o.networkConfig = buildNodeNetworkConfig();
o.placementPolicy = buildPlacementPolicy();
o.podIpv4CidrSize = 42;
o.selfLink = 'foo';
o.status = 'foo';
o.statusMessage = 'foo';
o.updateInfo = buildUpdateInfo();
o.upgradeSettings = buildUpgradeSettings();
o.version = 'foo';
}
buildCounterNodePool--;
return o;
}
void checkNodePool(api.NodePool o) {
buildCounterNodePool++;
if (buildCounterNodePool < 3) {
checkNodePoolAutoscaling(o.autoscaling!);
checkBestEffortProvisioning(o.bestEffortProvisioning!);
checkUnnamed46(o.conditions!);
checkNodeConfig(o.config!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.initialNodeCount!,
unittest.equals(42),
);
checkUnnamed47(o.instanceGroupUrls!);
checkUnnamed48(o.locations!);
checkNodeManagement(o.management!);
checkMaxPodsConstraint(o.maxPodsConstraint!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkNodeNetworkConfig(o.networkConfig!);
checkPlacementPolicy(o.placementPolicy!);
unittest.expect(
o.podIpv4CidrSize!,
unittest.equals(42),
);
unittest.expect(
o.selfLink!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.statusMessage!,
unittest.equals('foo'),
);
checkUpdateInfo(o.updateInfo!);
checkUpgradeSettings(o.upgradeSettings!);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterNodePool--;
}
core.int buildCounterNodePoolAutoConfig = 0;
api.NodePoolAutoConfig buildNodePoolAutoConfig() {
final o = api.NodePoolAutoConfig();
buildCounterNodePoolAutoConfig++;
if (buildCounterNodePoolAutoConfig < 3) {
o.networkTags = buildNetworkTags();
}
buildCounterNodePoolAutoConfig--;
return o;
}
void checkNodePoolAutoConfig(api.NodePoolAutoConfig o) {
buildCounterNodePoolAutoConfig++;
if (buildCounterNodePoolAutoConfig < 3) {
checkNetworkTags(o.networkTags!);
}
buildCounterNodePoolAutoConfig--;
}
core.int buildCounterNodePoolAutoscaling = 0;
api.NodePoolAutoscaling buildNodePoolAutoscaling() {
final o = api.NodePoolAutoscaling();
buildCounterNodePoolAutoscaling++;
if (buildCounterNodePoolAutoscaling < 3) {
o.autoprovisioned = true;
o.enabled = true;
o.locationPolicy = 'foo';
o.maxNodeCount = 42;
o.minNodeCount = 42;
o.totalMaxNodeCount = 42;
o.totalMinNodeCount = 42;
}
buildCounterNodePoolAutoscaling--;
return o;
}
void checkNodePoolAutoscaling(api.NodePoolAutoscaling o) {
buildCounterNodePoolAutoscaling++;
if (buildCounterNodePoolAutoscaling < 3) {
unittest.expect(o.autoprovisioned!, unittest.isTrue);
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.locationPolicy!,
unittest.equals('foo'),
);
unittest.expect(
o.maxNodeCount!,
unittest.equals(42),
);
unittest.expect(
o.minNodeCount!,
unittest.equals(42),
);
unittest.expect(
o.totalMaxNodeCount!,
unittest.equals(42),
);
unittest.expect(
o.totalMinNodeCount!,
unittest.equals(42),
);
}
buildCounterNodePoolAutoscaling--;
}
core.int buildCounterNodePoolDefaults = 0;
api.NodePoolDefaults buildNodePoolDefaults() {
final o = api.NodePoolDefaults();
buildCounterNodePoolDefaults++;
if (buildCounterNodePoolDefaults < 3) {
o.nodeConfigDefaults = buildNodeConfigDefaults();
}
buildCounterNodePoolDefaults--;
return o;
}
void checkNodePoolDefaults(api.NodePoolDefaults o) {
buildCounterNodePoolDefaults++;
if (buildCounterNodePoolDefaults < 3) {
checkNodeConfigDefaults(o.nodeConfigDefaults!);
}
buildCounterNodePoolDefaults--;
}
core.int buildCounterNodePoolLoggingConfig = 0;
api.NodePoolLoggingConfig buildNodePoolLoggingConfig() {
final o = api.NodePoolLoggingConfig();
buildCounterNodePoolLoggingConfig++;
if (buildCounterNodePoolLoggingConfig < 3) {
o.variantConfig = buildLoggingVariantConfig();
}
buildCounterNodePoolLoggingConfig--;
return o;
}
void checkNodePoolLoggingConfig(api.NodePoolLoggingConfig o) {
buildCounterNodePoolLoggingConfig++;
if (buildCounterNodePoolLoggingConfig < 3) {
checkLoggingVariantConfig(o.variantConfig!);
}
buildCounterNodePoolLoggingConfig--;
}
core.int buildCounterNodeTaint = 0;
api.NodeTaint buildNodeTaint() {
final o = api.NodeTaint();
buildCounterNodeTaint++;
if (buildCounterNodeTaint < 3) {
o.effect = 'foo';
o.key = 'foo';
o.value = 'foo';
}
buildCounterNodeTaint--;
return o;
}
void checkNodeTaint(api.NodeTaint o) {
buildCounterNodeTaint++;
if (buildCounterNodeTaint < 3) {
unittest.expect(
o.effect!,
unittest.equals('foo'),
);
unittest.expect(
o.key!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterNodeTaint--;
}
core.List<api.NodeTaint> buildUnnamed49() => [
buildNodeTaint(),
buildNodeTaint(),
];
void checkUnnamed49(core.List<api.NodeTaint> o) {
unittest.expect(o, unittest.hasLength(2));
checkNodeTaint(o[0]);
checkNodeTaint(o[1]);
}
core.int buildCounterNodeTaints = 0;
api.NodeTaints buildNodeTaints() {
final o = api.NodeTaints();
buildCounterNodeTaints++;
if (buildCounterNodeTaints < 3) {
o.taints = buildUnnamed49();
}
buildCounterNodeTaints--;
return o;
}
void checkNodeTaints(api.NodeTaints o) {
buildCounterNodeTaints++;
if (buildCounterNodeTaints < 3) {
checkUnnamed49(o.taints!);
}
buildCounterNodeTaints--;
}
core.int buildCounterNotificationConfig = 0;
api.NotificationConfig buildNotificationConfig() {
final o = api.NotificationConfig();
buildCounterNotificationConfig++;
if (buildCounterNotificationConfig < 3) {
o.pubsub = buildPubSub();
}
buildCounterNotificationConfig--;
return o;
}
void checkNotificationConfig(api.NotificationConfig o) {
buildCounterNotificationConfig++;
if (buildCounterNotificationConfig < 3) {
checkPubSub(o.pubsub!);
}
buildCounterNotificationConfig--;
}
core.List<api.StatusCondition> buildUnnamed50() => [
buildStatusCondition(),
buildStatusCondition(),
];
void checkUnnamed50(core.List<api.StatusCondition> o) {
unittest.expect(o, unittest.hasLength(2));
checkStatusCondition(o[0]);
checkStatusCondition(o[1]);
}
core.List<api.StatusCondition> buildUnnamed51() => [
buildStatusCondition(),
buildStatusCondition(),
];
void checkUnnamed51(core.List<api.StatusCondition> o) {
unittest.expect(o, unittest.hasLength(2));
checkStatusCondition(o[0]);
checkStatusCondition(o[1]);
}
core.int buildCounterOperation = 0;
api.Operation buildOperation() {
final o = api.Operation();
buildCounterOperation++;
if (buildCounterOperation < 3) {
o.clusterConditions = buildUnnamed50();
o.detail = 'foo';
o.endTime = 'foo';
o.error = buildStatus();
o.location = 'foo';
o.name = 'foo';
o.nodepoolConditions = buildUnnamed51();
o.operationType = 'foo';
o.progress = buildOperationProgress();
o.selfLink = 'foo';
o.startTime = 'foo';
o.status = 'foo';
o.statusMessage = 'foo';
o.targetLink = 'foo';
o.zone = 'foo';
}
buildCounterOperation--;
return o;
}
void checkOperation(api.Operation o) {
buildCounterOperation++;
if (buildCounterOperation < 3) {
checkUnnamed50(o.clusterConditions!);
unittest.expect(
o.detail!,
unittest.equals('foo'),
);
unittest.expect(
o.endTime!,
unittest.equals('foo'),
);
checkStatus(o.error!);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed51(o.nodepoolConditions!);
unittest.expect(
o.operationType!,
unittest.equals('foo'),
);
checkOperationProgress(o.progress!);
unittest.expect(
o.selfLink!,
unittest.equals('foo'),
);
unittest.expect(
o.startTime!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.statusMessage!,
unittest.equals('foo'),
);
unittest.expect(
o.targetLink!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterOperation--;
}
core.List<api.Metric> buildUnnamed52() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed52(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.OperationProgress> buildUnnamed53() => [
buildOperationProgress(),
buildOperationProgress(),
];
void checkUnnamed53(core.List<api.OperationProgress> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperationProgress(o[0]);
checkOperationProgress(o[1]);
}
core.int buildCounterOperationProgress = 0;
api.OperationProgress buildOperationProgress() {
final o = api.OperationProgress();
buildCounterOperationProgress++;
if (buildCounterOperationProgress < 3) {
o.metrics = buildUnnamed52();
o.name = 'foo';
o.stages = buildUnnamed53();
o.status = 'foo';
}
buildCounterOperationProgress--;
return o;
}
void checkOperationProgress(api.OperationProgress o) {
buildCounterOperationProgress++;
if (buildCounterOperationProgress < 3) {
checkUnnamed52(o.metrics!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed53(o.stages!);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
}
buildCounterOperationProgress--;
}
core.int buildCounterPlacementPolicy = 0;
api.PlacementPolicy buildPlacementPolicy() {
final o = api.PlacementPolicy();
buildCounterPlacementPolicy++;
if (buildCounterPlacementPolicy < 3) {
o.policyName = 'foo';
o.type = 'foo';
}
buildCounterPlacementPolicy--;
return o;
}
void checkPlacementPolicy(api.PlacementPolicy o) {
buildCounterPlacementPolicy++;
if (buildCounterPlacementPolicy < 3) {
unittest.expect(
o.policyName!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterPlacementPolicy--;
}
core.int buildCounterPodCIDROverprovisionConfig = 0;
api.PodCIDROverprovisionConfig buildPodCIDROverprovisionConfig() {
final o = api.PodCIDROverprovisionConfig();
buildCounterPodCIDROverprovisionConfig++;
if (buildCounterPodCIDROverprovisionConfig < 3) {
o.disable = true;
}
buildCounterPodCIDROverprovisionConfig--;
return o;
}
void checkPodCIDROverprovisionConfig(api.PodCIDROverprovisionConfig o) {
buildCounterPodCIDROverprovisionConfig++;
if (buildCounterPodCIDROverprovisionConfig < 3) {
unittest.expect(o.disable!, unittest.isTrue);
}
buildCounterPodCIDROverprovisionConfig--;
}
core.int buildCounterPrivateClusterConfig = 0;
api.PrivateClusterConfig buildPrivateClusterConfig() {
final o = api.PrivateClusterConfig();
buildCounterPrivateClusterConfig++;
if (buildCounterPrivateClusterConfig < 3) {
o.enablePrivateEndpoint = true;
o.enablePrivateNodes = true;
o.masterGlobalAccessConfig = buildPrivateClusterMasterGlobalAccessConfig();
o.masterIpv4CidrBlock = 'foo';
o.peeringName = 'foo';
o.privateEndpoint = 'foo';
o.privateEndpointSubnetwork = 'foo';
o.publicEndpoint = 'foo';
}
buildCounterPrivateClusterConfig--;
return o;
}
void checkPrivateClusterConfig(api.PrivateClusterConfig o) {
buildCounterPrivateClusterConfig++;
if (buildCounterPrivateClusterConfig < 3) {
unittest.expect(o.enablePrivateEndpoint!, unittest.isTrue);
unittest.expect(o.enablePrivateNodes!, unittest.isTrue);
checkPrivateClusterMasterGlobalAccessConfig(o.masterGlobalAccessConfig!);
unittest.expect(
o.masterIpv4CidrBlock!,
unittest.equals('foo'),
);
unittest.expect(
o.peeringName!,
unittest.equals('foo'),
);
unittest.expect(
o.privateEndpoint!,
unittest.equals('foo'),
);
unittest.expect(
o.privateEndpointSubnetwork!,
unittest.equals('foo'),
);
unittest.expect(
o.publicEndpoint!,
unittest.equals('foo'),
);
}
buildCounterPrivateClusterConfig--;
}
core.int buildCounterPrivateClusterMasterGlobalAccessConfig = 0;
api.PrivateClusterMasterGlobalAccessConfig
buildPrivateClusterMasterGlobalAccessConfig() {
final o = api.PrivateClusterMasterGlobalAccessConfig();
buildCounterPrivateClusterMasterGlobalAccessConfig++;
if (buildCounterPrivateClusterMasterGlobalAccessConfig < 3) {
o.enabled = true;
}
buildCounterPrivateClusterMasterGlobalAccessConfig--;
return o;
}
void checkPrivateClusterMasterGlobalAccessConfig(
api.PrivateClusterMasterGlobalAccessConfig o) {
buildCounterPrivateClusterMasterGlobalAccessConfig++;
if (buildCounterPrivateClusterMasterGlobalAccessConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterPrivateClusterMasterGlobalAccessConfig--;
}
core.int buildCounterPubSub = 0;
api.PubSub buildPubSub() {
final o = api.PubSub();
buildCounterPubSub++;
if (buildCounterPubSub < 3) {
o.enabled = true;
o.filter = buildFilter();
o.topic = 'foo';
}
buildCounterPubSub--;
return o;
}
void checkPubSub(api.PubSub o) {
buildCounterPubSub++;
if (buildCounterPubSub < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
checkFilter(o.filter!);
unittest.expect(
o.topic!,
unittest.equals('foo'),
);
}
buildCounterPubSub--;
}
core.int buildCounterRangeInfo = 0;
api.RangeInfo buildRangeInfo() {
final o = api.RangeInfo();
buildCounterRangeInfo++;
if (buildCounterRangeInfo < 3) {
o.rangeName = 'foo';
o.utilization = 42.0;
}
buildCounterRangeInfo--;
return o;
}
void checkRangeInfo(api.RangeInfo o) {
buildCounterRangeInfo++;
if (buildCounterRangeInfo < 3) {
unittest.expect(
o.rangeName!,
unittest.equals('foo'),
);
unittest.expect(
o.utilization!,
unittest.equals(42.0),
);
}
buildCounterRangeInfo--;
}
core.int buildCounterRecurringTimeWindow = 0;
api.RecurringTimeWindow buildRecurringTimeWindow() {
final o = api.RecurringTimeWindow();
buildCounterRecurringTimeWindow++;
if (buildCounterRecurringTimeWindow < 3) {
o.recurrence = 'foo';
o.window = buildTimeWindow();
}
buildCounterRecurringTimeWindow--;
return o;
}
void checkRecurringTimeWindow(api.RecurringTimeWindow o) {
buildCounterRecurringTimeWindow++;
if (buildCounterRecurringTimeWindow < 3) {
unittest.expect(
o.recurrence!,
unittest.equals('foo'),
);
checkTimeWindow(o.window!);
}
buildCounterRecurringTimeWindow--;
}
core.int buildCounterReleaseChannel = 0;
api.ReleaseChannel buildReleaseChannel() {
final o = api.ReleaseChannel();
buildCounterReleaseChannel++;
if (buildCounterReleaseChannel < 3) {
o.channel = 'foo';
}
buildCounterReleaseChannel--;
return o;
}
void checkReleaseChannel(api.ReleaseChannel o) {
buildCounterReleaseChannel++;
if (buildCounterReleaseChannel < 3) {
unittest.expect(
o.channel!,
unittest.equals('foo'),
);
}
buildCounterReleaseChannel--;
}
core.List<core.String> buildUnnamed54() => [
'foo',
'foo',
];
void checkUnnamed54(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReleaseChannelConfig = 0;
api.ReleaseChannelConfig buildReleaseChannelConfig() {
final o = api.ReleaseChannelConfig();
buildCounterReleaseChannelConfig++;
if (buildCounterReleaseChannelConfig < 3) {
o.channel = 'foo';
o.defaultVersion = 'foo';
o.validVersions = buildUnnamed54();
}
buildCounterReleaseChannelConfig--;
return o;
}
void checkReleaseChannelConfig(api.ReleaseChannelConfig o) {
buildCounterReleaseChannelConfig++;
if (buildCounterReleaseChannelConfig < 3) {
unittest.expect(
o.channel!,
unittest.equals('foo'),
);
unittest.expect(
o.defaultVersion!,
unittest.equals('foo'),
);
checkUnnamed54(o.validVersions!);
}
buildCounterReleaseChannelConfig--;
}
core.List<core.String> buildUnnamed55() => [
'foo',
'foo',
];
void checkUnnamed55(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReservationAffinity = 0;
api.ReservationAffinity buildReservationAffinity() {
final o = api.ReservationAffinity();
buildCounterReservationAffinity++;
if (buildCounterReservationAffinity < 3) {
o.consumeReservationType = 'foo';
o.key = 'foo';
o.values = buildUnnamed55();
}
buildCounterReservationAffinity--;
return o;
}
void checkReservationAffinity(api.ReservationAffinity o) {
buildCounterReservationAffinity++;
if (buildCounterReservationAffinity < 3) {
unittest.expect(
o.consumeReservationType!,
unittest.equals('foo'),
);
unittest.expect(
o.key!,
unittest.equals('foo'),
);
checkUnnamed55(o.values!);
}
buildCounterReservationAffinity--;
}
core.Map<core.String, core.String> buildUnnamed56() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed56(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterResourceLabels = 0;
api.ResourceLabels buildResourceLabels() {
final o = api.ResourceLabels();
buildCounterResourceLabels++;
if (buildCounterResourceLabels < 3) {
o.labels = buildUnnamed56();
}
buildCounterResourceLabels--;
return o;
}
void checkResourceLabels(api.ResourceLabels o) {
buildCounterResourceLabels++;
if (buildCounterResourceLabels < 3) {
checkUnnamed56(o.labels!);
}
buildCounterResourceLabels--;
}
core.int buildCounterResourceLimit = 0;
api.ResourceLimit buildResourceLimit() {
final o = api.ResourceLimit();
buildCounterResourceLimit++;
if (buildCounterResourceLimit < 3) {
o.maximum = 'foo';
o.minimum = 'foo';
o.resourceType = 'foo';
}
buildCounterResourceLimit--;
return o;
}
void checkResourceLimit(api.ResourceLimit o) {
buildCounterResourceLimit++;
if (buildCounterResourceLimit < 3) {
unittest.expect(
o.maximum!,
unittest.equals('foo'),
);
unittest.expect(
o.minimum!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceType!,
unittest.equals('foo'),
);
}
buildCounterResourceLimit--;
}
core.int buildCounterResourceUsageExportConfig = 0;
api.ResourceUsageExportConfig buildResourceUsageExportConfig() {
final o = api.ResourceUsageExportConfig();
buildCounterResourceUsageExportConfig++;
if (buildCounterResourceUsageExportConfig < 3) {
o.bigqueryDestination = buildBigQueryDestination();
o.consumptionMeteringConfig = buildConsumptionMeteringConfig();
o.enableNetworkEgressMetering = true;
}
buildCounterResourceUsageExportConfig--;
return o;
}
void checkResourceUsageExportConfig(api.ResourceUsageExportConfig o) {
buildCounterResourceUsageExportConfig++;
if (buildCounterResourceUsageExportConfig < 3) {
checkBigQueryDestination(o.bigqueryDestination!);
checkConsumptionMeteringConfig(o.consumptionMeteringConfig!);
unittest.expect(o.enableNetworkEgressMetering!, unittest.isTrue);
}
buildCounterResourceUsageExportConfig--;
}
core.int buildCounterRollbackNodePoolUpgradeRequest = 0;
api.RollbackNodePoolUpgradeRequest buildRollbackNodePoolUpgradeRequest() {
final o = api.RollbackNodePoolUpgradeRequest();
buildCounterRollbackNodePoolUpgradeRequest++;
if (buildCounterRollbackNodePoolUpgradeRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.nodePoolId = 'foo';
o.projectId = 'foo';
o.respectPdb = true;
o.zone = 'foo';
}
buildCounterRollbackNodePoolUpgradeRequest--;
return o;
}
void checkRollbackNodePoolUpgradeRequest(api.RollbackNodePoolUpgradeRequest o) {
buildCounterRollbackNodePoolUpgradeRequest++;
if (buildCounterRollbackNodePoolUpgradeRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.nodePoolId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(o.respectPdb!, unittest.isTrue);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterRollbackNodePoolUpgradeRequest--;
}
core.int buildCounterSandboxConfig = 0;
api.SandboxConfig buildSandboxConfig() {
final o = api.SandboxConfig();
buildCounterSandboxConfig++;
if (buildCounterSandboxConfig < 3) {
o.type = 'foo';
}
buildCounterSandboxConfig--;
return o;
}
void checkSandboxConfig(api.SandboxConfig o) {
buildCounterSandboxConfig++;
if (buildCounterSandboxConfig < 3) {
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterSandboxConfig--;
}
core.int buildCounterSecurityPostureConfig = 0;
api.SecurityPostureConfig buildSecurityPostureConfig() {
final o = api.SecurityPostureConfig();
buildCounterSecurityPostureConfig++;
if (buildCounterSecurityPostureConfig < 3) {
o.mode = 'foo';
o.vulnerabilityMode = 'foo';
}
buildCounterSecurityPostureConfig--;
return o;
}
void checkSecurityPostureConfig(api.SecurityPostureConfig o) {
buildCounterSecurityPostureConfig++;
if (buildCounterSecurityPostureConfig < 3) {
unittest.expect(
o.mode!,
unittest.equals('foo'),
);
unittest.expect(
o.vulnerabilityMode!,
unittest.equals('foo'),
);
}
buildCounterSecurityPostureConfig--;
}
core.List<api.ReleaseChannelConfig> buildUnnamed57() => [
buildReleaseChannelConfig(),
buildReleaseChannelConfig(),
];
void checkUnnamed57(core.List<api.ReleaseChannelConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkReleaseChannelConfig(o[0]);
checkReleaseChannelConfig(o[1]);
}
core.List<core.String> buildUnnamed58() => [
'foo',
'foo',
];
void checkUnnamed58(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed59() => [
'foo',
'foo',
];
void checkUnnamed59(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed60() => [
'foo',
'foo',
];
void checkUnnamed60(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterServerConfig = 0;
api.ServerConfig buildServerConfig() {
final o = api.ServerConfig();
buildCounterServerConfig++;
if (buildCounterServerConfig < 3) {
o.channels = buildUnnamed57();
o.defaultClusterVersion = 'foo';
o.defaultImageType = 'foo';
o.validImageTypes = buildUnnamed58();
o.validMasterVersions = buildUnnamed59();
o.validNodeVersions = buildUnnamed60();
}
buildCounterServerConfig--;
return o;
}
void checkServerConfig(api.ServerConfig o) {
buildCounterServerConfig++;
if (buildCounterServerConfig < 3) {
checkUnnamed57(o.channels!);
unittest.expect(
o.defaultClusterVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.defaultImageType!,
unittest.equals('foo'),
);
checkUnnamed58(o.validImageTypes!);
checkUnnamed59(o.validMasterVersions!);
checkUnnamed60(o.validNodeVersions!);
}
buildCounterServerConfig--;
}
core.int buildCounterServiceExternalIPsConfig = 0;
api.ServiceExternalIPsConfig buildServiceExternalIPsConfig() {
final o = api.ServiceExternalIPsConfig();
buildCounterServiceExternalIPsConfig++;
if (buildCounterServiceExternalIPsConfig < 3) {
o.enabled = true;
}
buildCounterServiceExternalIPsConfig--;
return o;
}
void checkServiceExternalIPsConfig(api.ServiceExternalIPsConfig o) {
buildCounterServiceExternalIPsConfig++;
if (buildCounterServiceExternalIPsConfig < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterServiceExternalIPsConfig--;
}
core.int buildCounterSetAddonsConfigRequest = 0;
api.SetAddonsConfigRequest buildSetAddonsConfigRequest() {
final o = api.SetAddonsConfigRequest();
buildCounterSetAddonsConfigRequest++;
if (buildCounterSetAddonsConfigRequest < 3) {
o.addonsConfig = buildAddonsConfig();
o.clusterId = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetAddonsConfigRequest--;
return o;
}
void checkSetAddonsConfigRequest(api.SetAddonsConfigRequest o) {
buildCounterSetAddonsConfigRequest++;
if (buildCounterSetAddonsConfigRequest < 3) {
checkAddonsConfig(o.addonsConfig!);
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetAddonsConfigRequest--;
}
core.Map<core.String, core.String> buildUnnamed61() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed61(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterSetLabelsRequest = 0;
api.SetLabelsRequest buildSetLabelsRequest() {
final o = api.SetLabelsRequest();
buildCounterSetLabelsRequest++;
if (buildCounterSetLabelsRequest < 3) {
o.clusterId = 'foo';
o.labelFingerprint = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.resourceLabels = buildUnnamed61();
o.zone = 'foo';
}
buildCounterSetLabelsRequest--;
return o;
}
void checkSetLabelsRequest(api.SetLabelsRequest o) {
buildCounterSetLabelsRequest++;
if (buildCounterSetLabelsRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.labelFingerprint!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
checkUnnamed61(o.resourceLabels!);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetLabelsRequest--;
}
core.int buildCounterSetLegacyAbacRequest = 0;
api.SetLegacyAbacRequest buildSetLegacyAbacRequest() {
final o = api.SetLegacyAbacRequest();
buildCounterSetLegacyAbacRequest++;
if (buildCounterSetLegacyAbacRequest < 3) {
o.clusterId = 'foo';
o.enabled = true;
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetLegacyAbacRequest--;
return o;
}
void checkSetLegacyAbacRequest(api.SetLegacyAbacRequest o) {
buildCounterSetLegacyAbacRequest++;
if (buildCounterSetLegacyAbacRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetLegacyAbacRequest--;
}
core.List<core.String> buildUnnamed62() => [
'foo',
'foo',
];
void checkUnnamed62(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterSetLocationsRequest = 0;
api.SetLocationsRequest buildSetLocationsRequest() {
final o = api.SetLocationsRequest();
buildCounterSetLocationsRequest++;
if (buildCounterSetLocationsRequest < 3) {
o.clusterId = 'foo';
o.locations = buildUnnamed62();
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetLocationsRequest--;
return o;
}
void checkSetLocationsRequest(api.SetLocationsRequest o) {
buildCounterSetLocationsRequest++;
if (buildCounterSetLocationsRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
checkUnnamed62(o.locations!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetLocationsRequest--;
}
core.int buildCounterSetLoggingServiceRequest = 0;
api.SetLoggingServiceRequest buildSetLoggingServiceRequest() {
final o = api.SetLoggingServiceRequest();
buildCounterSetLoggingServiceRequest++;
if (buildCounterSetLoggingServiceRequest < 3) {
o.clusterId = 'foo';
o.loggingService = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetLoggingServiceRequest--;
return o;
}
void checkSetLoggingServiceRequest(api.SetLoggingServiceRequest o) {
buildCounterSetLoggingServiceRequest++;
if (buildCounterSetLoggingServiceRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.loggingService!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetLoggingServiceRequest--;
}
core.int buildCounterSetMaintenancePolicyRequest = 0;
api.SetMaintenancePolicyRequest buildSetMaintenancePolicyRequest() {
final o = api.SetMaintenancePolicyRequest();
buildCounterSetMaintenancePolicyRequest++;
if (buildCounterSetMaintenancePolicyRequest < 3) {
o.clusterId = 'foo';
o.maintenancePolicy = buildMaintenancePolicy();
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetMaintenancePolicyRequest--;
return o;
}
void checkSetMaintenancePolicyRequest(api.SetMaintenancePolicyRequest o) {
buildCounterSetMaintenancePolicyRequest++;
if (buildCounterSetMaintenancePolicyRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
checkMaintenancePolicy(o.maintenancePolicy!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetMaintenancePolicyRequest--;
}
core.int buildCounterSetMasterAuthRequest = 0;
api.SetMasterAuthRequest buildSetMasterAuthRequest() {
final o = api.SetMasterAuthRequest();
buildCounterSetMasterAuthRequest++;
if (buildCounterSetMasterAuthRequest < 3) {
o.action = 'foo';
o.clusterId = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.update = buildMasterAuth();
o.zone = 'foo';
}
buildCounterSetMasterAuthRequest--;
return o;
}
void checkSetMasterAuthRequest(api.SetMasterAuthRequest o) {
buildCounterSetMasterAuthRequest++;
if (buildCounterSetMasterAuthRequest < 3) {
unittest.expect(
o.action!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
checkMasterAuth(o.update!);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetMasterAuthRequest--;
}
core.int buildCounterSetMonitoringServiceRequest = 0;
api.SetMonitoringServiceRequest buildSetMonitoringServiceRequest() {
final o = api.SetMonitoringServiceRequest();
buildCounterSetMonitoringServiceRequest++;
if (buildCounterSetMonitoringServiceRequest < 3) {
o.clusterId = 'foo';
o.monitoringService = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetMonitoringServiceRequest--;
return o;
}
void checkSetMonitoringServiceRequest(api.SetMonitoringServiceRequest o) {
buildCounterSetMonitoringServiceRequest++;
if (buildCounterSetMonitoringServiceRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.monitoringService!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetMonitoringServiceRequest--;
}
core.int buildCounterSetNetworkPolicyRequest = 0;
api.SetNetworkPolicyRequest buildSetNetworkPolicyRequest() {
final o = api.SetNetworkPolicyRequest();
buildCounterSetNetworkPolicyRequest++;
if (buildCounterSetNetworkPolicyRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.networkPolicy = buildNetworkPolicy();
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetNetworkPolicyRequest--;
return o;
}
void checkSetNetworkPolicyRequest(api.SetNetworkPolicyRequest o) {
buildCounterSetNetworkPolicyRequest++;
if (buildCounterSetNetworkPolicyRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkNetworkPolicy(o.networkPolicy!);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetNetworkPolicyRequest--;
}
core.int buildCounterSetNodePoolAutoscalingRequest = 0;
api.SetNodePoolAutoscalingRequest buildSetNodePoolAutoscalingRequest() {
final o = api.SetNodePoolAutoscalingRequest();
buildCounterSetNodePoolAutoscalingRequest++;
if (buildCounterSetNodePoolAutoscalingRequest < 3) {
o.autoscaling = buildNodePoolAutoscaling();
o.clusterId = 'foo';
o.name = 'foo';
o.nodePoolId = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetNodePoolAutoscalingRequest--;
return o;
}
void checkSetNodePoolAutoscalingRequest(api.SetNodePoolAutoscalingRequest o) {
buildCounterSetNodePoolAutoscalingRequest++;
if (buildCounterSetNodePoolAutoscalingRequest < 3) {
checkNodePoolAutoscaling(o.autoscaling!);
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.nodePoolId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetNodePoolAutoscalingRequest--;
}
core.int buildCounterSetNodePoolManagementRequest = 0;
api.SetNodePoolManagementRequest buildSetNodePoolManagementRequest() {
final o = api.SetNodePoolManagementRequest();
buildCounterSetNodePoolManagementRequest++;
if (buildCounterSetNodePoolManagementRequest < 3) {
o.clusterId = 'foo';
o.management = buildNodeManagement();
o.name = 'foo';
o.nodePoolId = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetNodePoolManagementRequest--;
return o;
}
void checkSetNodePoolManagementRequest(api.SetNodePoolManagementRequest o) {
buildCounterSetNodePoolManagementRequest++;
if (buildCounterSetNodePoolManagementRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
checkNodeManagement(o.management!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.nodePoolId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetNodePoolManagementRequest--;
}
core.int buildCounterSetNodePoolSizeRequest = 0;
api.SetNodePoolSizeRequest buildSetNodePoolSizeRequest() {
final o = api.SetNodePoolSizeRequest();
buildCounterSetNodePoolSizeRequest++;
if (buildCounterSetNodePoolSizeRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.nodeCount = 42;
o.nodePoolId = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterSetNodePoolSizeRequest--;
return o;
}
void checkSetNodePoolSizeRequest(api.SetNodePoolSizeRequest o) {
buildCounterSetNodePoolSizeRequest++;
if (buildCounterSetNodePoolSizeRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.nodeCount!,
unittest.equals(42),
);
unittest.expect(
o.nodePoolId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterSetNodePoolSizeRequest--;
}
core.int buildCounterShieldedInstanceConfig = 0;
api.ShieldedInstanceConfig buildShieldedInstanceConfig() {
final o = api.ShieldedInstanceConfig();
buildCounterShieldedInstanceConfig++;
if (buildCounterShieldedInstanceConfig < 3) {
o.enableIntegrityMonitoring = true;
o.enableSecureBoot = true;
}
buildCounterShieldedInstanceConfig--;
return o;
}
void checkShieldedInstanceConfig(api.ShieldedInstanceConfig o) {
buildCounterShieldedInstanceConfig++;
if (buildCounterShieldedInstanceConfig < 3) {
unittest.expect(o.enableIntegrityMonitoring!, unittest.isTrue);
unittest.expect(o.enableSecureBoot!, unittest.isTrue);
}
buildCounterShieldedInstanceConfig--;
}
core.int buildCounterShieldedNodes = 0;
api.ShieldedNodes buildShieldedNodes() {
final o = api.ShieldedNodes();
buildCounterShieldedNodes++;
if (buildCounterShieldedNodes < 3) {
o.enabled = true;
}
buildCounterShieldedNodes--;
return o;
}
void checkShieldedNodes(api.ShieldedNodes o) {
buildCounterShieldedNodes++;
if (buildCounterShieldedNodes < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterShieldedNodes--;
}
core.List<api.NodeAffinity> buildUnnamed63() => [
buildNodeAffinity(),
buildNodeAffinity(),
];
void checkUnnamed63(core.List<api.NodeAffinity> o) {
unittest.expect(o, unittest.hasLength(2));
checkNodeAffinity(o[0]);
checkNodeAffinity(o[1]);
}
core.int buildCounterSoleTenantConfig = 0;
api.SoleTenantConfig buildSoleTenantConfig() {
final o = api.SoleTenantConfig();
buildCounterSoleTenantConfig++;
if (buildCounterSoleTenantConfig < 3) {
o.nodeAffinities = buildUnnamed63();
}
buildCounterSoleTenantConfig--;
return o;
}
void checkSoleTenantConfig(api.SoleTenantConfig o) {
buildCounterSoleTenantConfig++;
if (buildCounterSoleTenantConfig < 3) {
checkUnnamed63(o.nodeAffinities!);
}
buildCounterSoleTenantConfig--;
}
core.int buildCounterStandardRolloutPolicy = 0;
api.StandardRolloutPolicy buildStandardRolloutPolicy() {
final o = api.StandardRolloutPolicy();
buildCounterStandardRolloutPolicy++;
if (buildCounterStandardRolloutPolicy < 3) {
o.batchNodeCount = 42;
o.batchPercentage = 42.0;
o.batchSoakDuration = 'foo';
}
buildCounterStandardRolloutPolicy--;
return o;
}
void checkStandardRolloutPolicy(api.StandardRolloutPolicy o) {
buildCounterStandardRolloutPolicy++;
if (buildCounterStandardRolloutPolicy < 3) {
unittest.expect(
o.batchNodeCount!,
unittest.equals(42),
);
unittest.expect(
o.batchPercentage!,
unittest.equals(42.0),
);
unittest.expect(
o.batchSoakDuration!,
unittest.equals('foo'),
);
}
buildCounterStandardRolloutPolicy--;
}
core.int buildCounterStartIPRotationRequest = 0;
api.StartIPRotationRequest buildStartIPRotationRequest() {
final o = api.StartIPRotationRequest();
buildCounterStartIPRotationRequest++;
if (buildCounterStartIPRotationRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.rotateCredentials = true;
o.zone = 'foo';
}
buildCounterStartIPRotationRequest--;
return o;
}
void checkStartIPRotationRequest(api.StartIPRotationRequest o) {
buildCounterStartIPRotationRequest++;
if (buildCounterStartIPRotationRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(o.rotateCredentials!, unittest.isTrue);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterStartIPRotationRequest--;
}
core.Map<core.String, core.Object?> buildUnnamed64() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed64(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.List<core.Map<core.String, core.Object?>> buildUnnamed65() => [
buildUnnamed64(),
buildUnnamed64(),
];
void checkUnnamed65(core.List<core.Map<core.String, core.Object?>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed64(o[0]);
checkUnnamed64(o[1]);
}
core.int buildCounterStatus = 0;
api.Status buildStatus() {
final o = api.Status();
buildCounterStatus++;
if (buildCounterStatus < 3) {
o.code = 42;
o.details = buildUnnamed65();
o.message = 'foo';
}
buildCounterStatus--;
return o;
}
void checkStatus(api.Status o) {
buildCounterStatus++;
if (buildCounterStatus < 3) {
unittest.expect(
o.code!,
unittest.equals(42),
);
checkUnnamed65(o.details!);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterStatus--;
}
core.int buildCounterStatusCondition = 0;
api.StatusCondition buildStatusCondition() {
final o = api.StatusCondition();
buildCounterStatusCondition++;
if (buildCounterStatusCondition < 3) {
o.canonicalCode = 'foo';
o.code = 'foo';
o.message = 'foo';
}
buildCounterStatusCondition--;
return o;
}
void checkStatusCondition(api.StatusCondition o) {
buildCounterStatusCondition++;
if (buildCounterStatusCondition < 3) {
unittest.expect(
o.canonicalCode!,
unittest.equals('foo'),
);
unittest.expect(
o.code!,
unittest.equals('foo'),
);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterStatusCondition--;
}
core.int buildCounterTimeWindow = 0;
api.TimeWindow buildTimeWindow() {
final o = api.TimeWindow();
buildCounterTimeWindow++;
if (buildCounterTimeWindow < 3) {
o.endTime = 'foo';
o.maintenanceExclusionOptions = buildMaintenanceExclusionOptions();
o.startTime = 'foo';
}
buildCounterTimeWindow--;
return o;
}
void checkTimeWindow(api.TimeWindow o) {
buildCounterTimeWindow++;
if (buildCounterTimeWindow < 3) {
unittest.expect(
o.endTime!,
unittest.equals('foo'),
);
checkMaintenanceExclusionOptions(o.maintenanceExclusionOptions!);
unittest.expect(
o.startTime!,
unittest.equals('foo'),
);
}
buildCounterTimeWindow--;
}
core.int buildCounterUpdateClusterRequest = 0;
api.UpdateClusterRequest buildUpdateClusterRequest() {
final o = api.UpdateClusterRequest();
buildCounterUpdateClusterRequest++;
if (buildCounterUpdateClusterRequest < 3) {
o.clusterId = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.update = buildClusterUpdate();
o.zone = 'foo';
}
buildCounterUpdateClusterRequest--;
return o;
}
void checkUpdateClusterRequest(api.UpdateClusterRequest o) {
buildCounterUpdateClusterRequest++;
if (buildCounterUpdateClusterRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
checkClusterUpdate(o.update!);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterUpdateClusterRequest--;
}
core.int buildCounterUpdateInfo = 0;
api.UpdateInfo buildUpdateInfo() {
final o = api.UpdateInfo();
buildCounterUpdateInfo++;
if (buildCounterUpdateInfo < 3) {
o.blueGreenInfo = buildBlueGreenInfo();
}
buildCounterUpdateInfo--;
return o;
}
void checkUpdateInfo(api.UpdateInfo o) {
buildCounterUpdateInfo++;
if (buildCounterUpdateInfo < 3) {
checkBlueGreenInfo(o.blueGreenInfo!);
}
buildCounterUpdateInfo--;
}
core.int buildCounterUpdateMasterRequest = 0;
api.UpdateMasterRequest buildUpdateMasterRequest() {
final o = api.UpdateMasterRequest();
buildCounterUpdateMasterRequest++;
if (buildCounterUpdateMasterRequest < 3) {
o.clusterId = 'foo';
o.masterVersion = 'foo';
o.name = 'foo';
o.projectId = 'foo';
o.zone = 'foo';
}
buildCounterUpdateMasterRequest--;
return o;
}
void checkUpdateMasterRequest(api.UpdateMasterRequest o) {
buildCounterUpdateMasterRequest++;
if (buildCounterUpdateMasterRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
unittest.expect(
o.masterVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterUpdateMasterRequest--;
}
core.List<core.String> buildUnnamed66() => [
'foo',
'foo',
];
void checkUnnamed66(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterUpdateNodePoolRequest = 0;
api.UpdateNodePoolRequest buildUpdateNodePoolRequest() {
final o = api.UpdateNodePoolRequest();
buildCounterUpdateNodePoolRequest++;
if (buildCounterUpdateNodePoolRequest < 3) {
o.clusterId = 'foo';
o.confidentialNodes = buildConfidentialNodes();
o.etag = 'foo';
o.fastSocket = buildFastSocket();
o.gcfsConfig = buildGcfsConfig();
o.gvnic = buildVirtualNIC();
o.imageType = 'foo';
o.kubeletConfig = buildNodeKubeletConfig();
o.labels = buildNodeLabels();
o.linuxNodeConfig = buildLinuxNodeConfig();
o.locations = buildUnnamed66();
o.loggingConfig = buildNodePoolLoggingConfig();
o.name = 'foo';
o.nodeNetworkConfig = buildNodeNetworkConfig();
o.nodePoolId = 'foo';
o.nodeVersion = 'foo';
o.projectId = 'foo';
o.resourceLabels = buildResourceLabels();
o.tags = buildNetworkTags();
o.taints = buildNodeTaints();
o.upgradeSettings = buildUpgradeSettings();
o.windowsNodeConfig = buildWindowsNodeConfig();
o.workloadMetadataConfig = buildWorkloadMetadataConfig();
o.zone = 'foo';
}
buildCounterUpdateNodePoolRequest--;
return o;
}
void checkUpdateNodePoolRequest(api.UpdateNodePoolRequest o) {
buildCounterUpdateNodePoolRequest++;
if (buildCounterUpdateNodePoolRequest < 3) {
unittest.expect(
o.clusterId!,
unittest.equals('foo'),
);
checkConfidentialNodes(o.confidentialNodes!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkFastSocket(o.fastSocket!);
checkGcfsConfig(o.gcfsConfig!);
checkVirtualNIC(o.gvnic!);
unittest.expect(
o.imageType!,
unittest.equals('foo'),
);
checkNodeKubeletConfig(o.kubeletConfig!);
checkNodeLabels(o.labels!);
checkLinuxNodeConfig(o.linuxNodeConfig!);
checkUnnamed66(o.locations!);
checkNodePoolLoggingConfig(o.loggingConfig!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkNodeNetworkConfig(o.nodeNetworkConfig!);
unittest.expect(
o.nodePoolId!,
unittest.equals('foo'),
);
unittest.expect(
o.nodeVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
checkResourceLabels(o.resourceLabels!);
checkNetworkTags(o.tags!);
checkNodeTaints(o.taints!);
checkUpgradeSettings(o.upgradeSettings!);
checkWindowsNodeConfig(o.windowsNodeConfig!);
checkWorkloadMetadataConfig(o.workloadMetadataConfig!);
unittest.expect(
o.zone!,
unittest.equals('foo'),
);
}
buildCounterUpdateNodePoolRequest--;
}
core.int buildCounterUpgradeSettings = 0;
api.UpgradeSettings buildUpgradeSettings() {
final o = api.UpgradeSettings();
buildCounterUpgradeSettings++;
if (buildCounterUpgradeSettings < 3) {
o.blueGreenSettings = buildBlueGreenSettings();
o.maxSurge = 42;
o.maxUnavailable = 42;
o.strategy = 'foo';
}
buildCounterUpgradeSettings--;
return o;
}
void checkUpgradeSettings(api.UpgradeSettings o) {
buildCounterUpgradeSettings++;
if (buildCounterUpgradeSettings < 3) {
checkBlueGreenSettings(o.blueGreenSettings!);
unittest.expect(
o.maxSurge!,
unittest.equals(42),
);
unittest.expect(
o.maxUnavailable!,
unittest.equals(42),
);
unittest.expect(
o.strategy!,
unittest.equals('foo'),
);
}
buildCounterUpgradeSettings--;
}
core.List<api.UsableSubnetworkSecondaryRange> buildUnnamed67() => [
buildUsableSubnetworkSecondaryRange(),
buildUsableSubnetworkSecondaryRange(),
];
void checkUnnamed67(core.List<api.UsableSubnetworkSecondaryRange> o) {
unittest.expect(o, unittest.hasLength(2));
checkUsableSubnetworkSecondaryRange(o[0]);
checkUsableSubnetworkSecondaryRange(o[1]);
}
core.int buildCounterUsableSubnetwork = 0;
api.UsableSubnetwork buildUsableSubnetwork() {
final o = api.UsableSubnetwork();
buildCounterUsableSubnetwork++;
if (buildCounterUsableSubnetwork < 3) {
o.ipCidrRange = 'foo';
o.network = 'foo';
o.secondaryIpRanges = buildUnnamed67();
o.statusMessage = 'foo';
o.subnetwork = 'foo';
}
buildCounterUsableSubnetwork--;
return o;
}
void checkUsableSubnetwork(api.UsableSubnetwork o) {
buildCounterUsableSubnetwork++;
if (buildCounterUsableSubnetwork < 3) {
unittest.expect(
o.ipCidrRange!,
unittest.equals('foo'),
);
unittest.expect(
o.network!,
unittest.equals('foo'),
);
checkUnnamed67(o.secondaryIpRanges!);
unittest.expect(
o.statusMessage!,
unittest.equals('foo'),
);
unittest.expect(
o.subnetwork!,
unittest.equals('foo'),
);
}
buildCounterUsableSubnetwork--;
}
core.int buildCounterUsableSubnetworkSecondaryRange = 0;
api.UsableSubnetworkSecondaryRange buildUsableSubnetworkSecondaryRange() {
final o = api.UsableSubnetworkSecondaryRange();
buildCounterUsableSubnetworkSecondaryRange++;
if (buildCounterUsableSubnetworkSecondaryRange < 3) {
o.ipCidrRange = 'foo';
o.rangeName = 'foo';
o.status = 'foo';
}
buildCounterUsableSubnetworkSecondaryRange--;
return o;
}
void checkUsableSubnetworkSecondaryRange(api.UsableSubnetworkSecondaryRange o) {
buildCounterUsableSubnetworkSecondaryRange++;
if (buildCounterUsableSubnetworkSecondaryRange < 3) {
unittest.expect(
o.ipCidrRange!,
unittest.equals('foo'),
);
unittest.expect(
o.rangeName!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
}
buildCounterUsableSubnetworkSecondaryRange--;
}
core.int buildCounterVerticalPodAutoscaling = 0;
api.VerticalPodAutoscaling buildVerticalPodAutoscaling() {
final o = api.VerticalPodAutoscaling();
buildCounterVerticalPodAutoscaling++;
if (buildCounterVerticalPodAutoscaling < 3) {
o.enabled = true;
}
buildCounterVerticalPodAutoscaling--;
return o;
}
void checkVerticalPodAutoscaling(api.VerticalPodAutoscaling o) {
buildCounterVerticalPodAutoscaling++;
if (buildCounterVerticalPodAutoscaling < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterVerticalPodAutoscaling--;
}
core.int buildCounterVirtualNIC = 0;
api.VirtualNIC buildVirtualNIC() {
final o = api.VirtualNIC();
buildCounterVirtualNIC++;
if (buildCounterVirtualNIC < 3) {
o.enabled = true;
}
buildCounterVirtualNIC--;
return o;
}
void checkVirtualNIC(api.VirtualNIC o) {
buildCounterVirtualNIC++;
if (buildCounterVirtualNIC < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterVirtualNIC--;
}
core.int buildCounterWindowsNodeConfig = 0;
api.WindowsNodeConfig buildWindowsNodeConfig() {
final o = api.WindowsNodeConfig();
buildCounterWindowsNodeConfig++;
if (buildCounterWindowsNodeConfig < 3) {
o.osVersion = 'foo';
}
buildCounterWindowsNodeConfig--;
return o;
}
void checkWindowsNodeConfig(api.WindowsNodeConfig o) {
buildCounterWindowsNodeConfig++;
if (buildCounterWindowsNodeConfig < 3) {
unittest.expect(
o.osVersion!,
unittest.equals('foo'),
);
}
buildCounterWindowsNodeConfig--;
}
core.int buildCounterWorkloadIdentityConfig = 0;
api.WorkloadIdentityConfig buildWorkloadIdentityConfig() {
final o = api.WorkloadIdentityConfig();
buildCounterWorkloadIdentityConfig++;
if (buildCounterWorkloadIdentityConfig < 3) {
o.workloadPool = 'foo';
}
buildCounterWorkloadIdentityConfig--;
return o;
}
void checkWorkloadIdentityConfig(api.WorkloadIdentityConfig o) {
buildCounterWorkloadIdentityConfig++;
if (buildCounterWorkloadIdentityConfig < 3) {
unittest.expect(
o.workloadPool!,
unittest.equals('foo'),
);
}
buildCounterWorkloadIdentityConfig--;
}
core.int buildCounterWorkloadMetadataConfig = 0;
api.WorkloadMetadataConfig buildWorkloadMetadataConfig() {
final o = api.WorkloadMetadataConfig();
buildCounterWorkloadMetadataConfig++;
if (buildCounterWorkloadMetadataConfig < 3) {
o.mode = 'foo';
}
buildCounterWorkloadMetadataConfig--;
return o;
}
void checkWorkloadMetadataConfig(api.WorkloadMetadataConfig o) {
buildCounterWorkloadMetadataConfig++;
if (buildCounterWorkloadMetadataConfig < 3) {
unittest.expect(
o.mode!,
unittest.equals('foo'),
);
}
buildCounterWorkloadMetadataConfig--;
}
core.int buildCounterWorkloadPolicyConfig = 0;
api.WorkloadPolicyConfig buildWorkloadPolicyConfig() {
final o = api.WorkloadPolicyConfig();
buildCounterWorkloadPolicyConfig++;
if (buildCounterWorkloadPolicyConfig < 3) {
o.allowNetAdmin = true;
}
buildCounterWorkloadPolicyConfig--;
return o;
}
void checkWorkloadPolicyConfig(api.WorkloadPolicyConfig o) {
buildCounterWorkloadPolicyConfig++;
if (buildCounterWorkloadPolicyConfig < 3) {
unittest.expect(o.allowNetAdmin!, unittest.isTrue);
}
buildCounterWorkloadPolicyConfig--;
}
void main() {
unittest.group('obj-schema-AcceleratorConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAcceleratorConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AcceleratorConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAcceleratorConfig(od);
});
});
unittest.group('obj-schema-AdditionalNodeNetworkConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAdditionalNodeNetworkConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdditionalNodeNetworkConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdditionalNodeNetworkConfig(od);
});
});
unittest.group('obj-schema-AdditionalPodNetworkConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAdditionalPodNetworkConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdditionalPodNetworkConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdditionalPodNetworkConfig(od);
});
});
unittest.group('obj-schema-AdditionalPodRangesConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAdditionalPodRangesConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdditionalPodRangesConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdditionalPodRangesConfig(od);
});
});
unittest.group('obj-schema-AddonsConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAddonsConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AddonsConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAddonsConfig(od);
});
});
unittest.group('obj-schema-AdvancedDatapathObservabilityConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvancedDatapathObservabilityConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvancedDatapathObservabilityConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvancedDatapathObservabilityConfig(od);
});
});
unittest.group('obj-schema-AdvancedMachineFeatures', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvancedMachineFeatures();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvancedMachineFeatures.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvancedMachineFeatures(od);
});
});
unittest.group('obj-schema-AuthenticatorGroupsConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAuthenticatorGroupsConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AuthenticatorGroupsConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAuthenticatorGroupsConfig(od);
});
});
unittest.group('obj-schema-AutoUpgradeOptions', () {
unittest.test('to-json--from-json', () async {
final o = buildAutoUpgradeOptions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AutoUpgradeOptions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAutoUpgradeOptions(od);
});
});
unittest.group('obj-schema-Autopilot', () {
unittest.test('to-json--from-json', () async {
final o = buildAutopilot();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Autopilot.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAutopilot(od);
});
});
unittest.group('obj-schema-AutopilotCompatibilityIssue', () {
unittest.test('to-json--from-json', () async {
final o = buildAutopilotCompatibilityIssue();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AutopilotCompatibilityIssue.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAutopilotCompatibilityIssue(od);
});
});
unittest.group('obj-schema-AutoprovisioningNodePoolDefaults', () {
unittest.test('to-json--from-json', () async {
final o = buildAutoprovisioningNodePoolDefaults();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AutoprovisioningNodePoolDefaults.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAutoprovisioningNodePoolDefaults(od);
});
});
unittest.group('obj-schema-BestEffortProvisioning', () {
unittest.test('to-json--from-json', () async {
final o = buildBestEffortProvisioning();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BestEffortProvisioning.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBestEffortProvisioning(od);
});
});
unittest.group('obj-schema-BigQueryDestination', () {
unittest.test('to-json--from-json', () async {
final o = buildBigQueryDestination();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BigQueryDestination.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBigQueryDestination(od);
});
});
unittest.group('obj-schema-BinaryAuthorization', () {
unittest.test('to-json--from-json', () async {
final o = buildBinaryAuthorization();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BinaryAuthorization.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBinaryAuthorization(od);
});
});
unittest.group('obj-schema-BlueGreenInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildBlueGreenInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BlueGreenInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBlueGreenInfo(od);
});
});
unittest.group('obj-schema-BlueGreenSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildBlueGreenSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BlueGreenSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBlueGreenSettings(od);
});
});
unittest.group('obj-schema-CancelOperationRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCancelOperationRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CancelOperationRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(od);
});
});
unittest.group('obj-schema-CheckAutopilotCompatibilityResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCheckAutopilotCompatibilityResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CheckAutopilotCompatibilityResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCheckAutopilotCompatibilityResponse(od);
});
});
unittest.group('obj-schema-CidrBlock', () {
unittest.test('to-json--from-json', () async {
final o = buildCidrBlock();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.CidrBlock.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCidrBlock(od);
});
});
unittest.group('obj-schema-ClientCertificateConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildClientCertificateConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClientCertificateConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClientCertificateConfig(od);
});
});
unittest.group('obj-schema-CloudRunConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudRunConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudRunConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudRunConfig(od);
});
});
unittest.group('obj-schema-Cluster', () {
unittest.test('to-json--from-json', () async {
final o = buildCluster();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Cluster.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCluster(od);
});
});
unittest.group('obj-schema-ClusterAutoscaling', () {
unittest.test('to-json--from-json', () async {
final o = buildClusterAutoscaling();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClusterAutoscaling.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClusterAutoscaling(od);
});
});
unittest.group('obj-schema-ClusterNetworkPerformanceConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildClusterNetworkPerformanceConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClusterNetworkPerformanceConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClusterNetworkPerformanceConfig(od);
});
});
unittest.group('obj-schema-ClusterUpdate', () {
unittest.test('to-json--from-json', () async {
final o = buildClusterUpdate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClusterUpdate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClusterUpdate(od);
});
});
unittest.group('obj-schema-CompleteIPRotationRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCompleteIPRotationRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CompleteIPRotationRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCompleteIPRotationRequest(od);
});
});
unittest.group('obj-schema-CompleteNodePoolUpgradeRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCompleteNodePoolUpgradeRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CompleteNodePoolUpgradeRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCompleteNodePoolUpgradeRequest(od);
});
});
unittest.group('obj-schema-ConfidentialNodes', () {
unittest.test('to-json--from-json', () async {
final o = buildConfidentialNodes();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConfidentialNodes.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConfidentialNodes(od);
});
});
unittest.group('obj-schema-ConfigConnectorConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildConfigConnectorConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConfigConnectorConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConfigConnectorConfig(od);
});
});
unittest.group('obj-schema-ConsumptionMeteringConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildConsumptionMeteringConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConsumptionMeteringConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConsumptionMeteringConfig(od);
});
});
unittest.group('obj-schema-CostManagementConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildCostManagementConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CostManagementConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCostManagementConfig(od);
});
});
unittest.group('obj-schema-CreateClusterRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateClusterRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateClusterRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateClusterRequest(od);
});
});
unittest.group('obj-schema-CreateNodePoolRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateNodePoolRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateNodePoolRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateNodePoolRequest(od);
});
});
unittest.group('obj-schema-DNSConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildDNSConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.DNSConfig.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDNSConfig(od);
});
});
unittest.group('obj-schema-DailyMaintenanceWindow', () {
unittest.test('to-json--from-json', () async {
final o = buildDailyMaintenanceWindow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DailyMaintenanceWindow.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDailyMaintenanceWindow(od);
});
});
unittest.group('obj-schema-DatabaseEncryption', () {
unittest.test('to-json--from-json', () async {
final o = buildDatabaseEncryption();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DatabaseEncryption.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDatabaseEncryption(od);
});
});
unittest.group('obj-schema-DefaultSnatStatus', () {
unittest.test('to-json--from-json', () async {
final o = buildDefaultSnatStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DefaultSnatStatus.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDefaultSnatStatus(od);
});
});
unittest.group('obj-schema-DnsCacheConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildDnsCacheConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DnsCacheConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDnsCacheConfig(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-EphemeralStorageLocalSsdConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildEphemeralStorageLocalSsdConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EphemeralStorageLocalSsdConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEphemeralStorageLocalSsdConfig(od);
});
});
unittest.group('obj-schema-FastSocket', () {
unittest.test('to-json--from-json', () async {
final o = buildFastSocket();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.FastSocket.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFastSocket(od);
});
});
unittest.group('obj-schema-Filter', () {
unittest.test('to-json--from-json', () async {
final o = buildFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Filter.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFilter(od);
});
});
unittest.group('obj-schema-Fleet', () {
unittest.test('to-json--from-json', () async {
final o = buildFleet();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Fleet.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFleet(od);
});
});
unittest.group('obj-schema-GPUDriverInstallationConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGPUDriverInstallationConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GPUDriverInstallationConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGPUDriverInstallationConfig(od);
});
});
unittest.group('obj-schema-GPUSharingConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGPUSharingConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GPUSharingConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGPUSharingConfig(od);
});
});
unittest.group('obj-schema-GatewayAPIConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGatewayAPIConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GatewayAPIConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGatewayAPIConfig(od);
});
});
unittest.group('obj-schema-GcePersistentDiskCsiDriverConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGcePersistentDiskCsiDriverConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GcePersistentDiskCsiDriverConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGcePersistentDiskCsiDriverConfig(od);
});
});
unittest.group('obj-schema-GcfsConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGcfsConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.GcfsConfig.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkGcfsConfig(od);
});
});
unittest.group('obj-schema-GcpFilestoreCsiDriverConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGcpFilestoreCsiDriverConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GcpFilestoreCsiDriverConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGcpFilestoreCsiDriverConfig(od);
});
});
unittest.group('obj-schema-GcsFuseCsiDriverConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGcsFuseCsiDriverConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GcsFuseCsiDriverConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGcsFuseCsiDriverConfig(od);
});
});
unittest.group('obj-schema-GetJSONWebKeysResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildGetJSONWebKeysResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GetJSONWebKeysResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGetJSONWebKeysResponse(od);
});
});
unittest.group('obj-schema-GetOpenIDConfigResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildGetOpenIDConfigResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GetOpenIDConfigResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGetOpenIDConfigResponse(od);
});
});
unittest.group('obj-schema-GkeBackupAgentConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildGkeBackupAgentConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GkeBackupAgentConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGkeBackupAgentConfig(od);
});
});
unittest.group('obj-schema-HorizontalPodAutoscaling', () {
unittest.test('to-json--from-json', () async {
final o = buildHorizontalPodAutoscaling();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.HorizontalPodAutoscaling.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkHorizontalPodAutoscaling(od);
});
});
unittest.group('obj-schema-HttpCacheControlResponseHeader', () {
unittest.test('to-json--from-json', () async {
final o = buildHttpCacheControlResponseHeader();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.HttpCacheControlResponseHeader.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkHttpCacheControlResponseHeader(od);
});
});
unittest.group('obj-schema-HttpLoadBalancing', () {
unittest.test('to-json--from-json', () async {
final o = buildHttpLoadBalancing();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.HttpLoadBalancing.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkHttpLoadBalancing(od);
});
});
unittest.group('obj-schema-ILBSubsettingConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildILBSubsettingConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ILBSubsettingConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkILBSubsettingConfig(od);
});
});
unittest.group('obj-schema-IPAllocationPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildIPAllocationPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.IPAllocationPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkIPAllocationPolicy(od);
});
});
unittest.group('obj-schema-IdentityServiceConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildIdentityServiceConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.IdentityServiceConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkIdentityServiceConfig(od);
});
});
unittest.group('obj-schema-IntraNodeVisibilityConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildIntraNodeVisibilityConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.IntraNodeVisibilityConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkIntraNodeVisibilityConfig(od);
});
});
unittest.group('obj-schema-Jwk', () {
unittest.test('to-json--from-json', () async {
final o = buildJwk();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Jwk.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkJwk(od);
});
});
unittest.group('obj-schema-K8sBetaAPIConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildK8sBetaAPIConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.K8sBetaAPIConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkK8sBetaAPIConfig(od);
});
});
unittest.group('obj-schema-KubernetesDashboard', () {
unittest.test('to-json--from-json', () async {
final o = buildKubernetesDashboard();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.KubernetesDashboard.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkKubernetesDashboard(od);
});
});
unittest.group('obj-schema-LegacyAbac', () {
unittest.test('to-json--from-json', () async {
final o = buildLegacyAbac();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LegacyAbac.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLegacyAbac(od);
});
});
unittest.group('obj-schema-LinuxNodeConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildLinuxNodeConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LinuxNodeConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLinuxNodeConfig(od);
});
});
unittest.group('obj-schema-ListClustersResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListClustersResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListClustersResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListClustersResponse(od);
});
});
unittest.group('obj-schema-ListNodePoolsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListNodePoolsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListNodePoolsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListNodePoolsResponse(od);
});
});
unittest.group('obj-schema-ListOperationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListOperationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListOperationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListOperationsResponse(od);
});
});
unittest.group('obj-schema-ListUsableSubnetworksResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListUsableSubnetworksResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListUsableSubnetworksResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListUsableSubnetworksResponse(od);
});
});
unittest.group('obj-schema-LocalNvmeSsdBlockConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildLocalNvmeSsdBlockConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LocalNvmeSsdBlockConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLocalNvmeSsdBlockConfig(od);
});
});
unittest.group('obj-schema-LoggingComponentConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildLoggingComponentConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LoggingComponentConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLoggingComponentConfig(od);
});
});
unittest.group('obj-schema-LoggingConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildLoggingConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LoggingConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLoggingConfig(od);
});
});
unittest.group('obj-schema-LoggingVariantConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildLoggingVariantConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LoggingVariantConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLoggingVariantConfig(od);
});
});
unittest.group('obj-schema-MaintenanceExclusionOptions', () {
unittest.test('to-json--from-json', () async {
final o = buildMaintenanceExclusionOptions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MaintenanceExclusionOptions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMaintenanceExclusionOptions(od);
});
});
unittest.group('obj-schema-MaintenancePolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildMaintenancePolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MaintenancePolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMaintenancePolicy(od);
});
});
unittest.group('obj-schema-MaintenanceWindow', () {
unittest.test('to-json--from-json', () async {
final o = buildMaintenanceWindow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MaintenanceWindow.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMaintenanceWindow(od);
});
});
unittest.group('obj-schema-ManagedPrometheusConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildManagedPrometheusConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ManagedPrometheusConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkManagedPrometheusConfig(od);
});
});
unittest.group('obj-schema-MasterAuth', () {
unittest.test('to-json--from-json', () async {
final o = buildMasterAuth();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.MasterAuth.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkMasterAuth(od);
});
});
unittest.group('obj-schema-MasterAuthorizedNetworksConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildMasterAuthorizedNetworksConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MasterAuthorizedNetworksConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMasterAuthorizedNetworksConfig(od);
});
});
unittest.group('obj-schema-MaxPodsConstraint', () {
unittest.test('to-json--from-json', () async {
final o = buildMaxPodsConstraint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MaxPodsConstraint.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMaxPodsConstraint(od);
});
});
unittest.group('obj-schema-MeshCertificates', () {
unittest.test('to-json--from-json', () async {
final o = buildMeshCertificates();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MeshCertificates.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMeshCertificates(od);
});
});
unittest.group('obj-schema-Metric', () {
unittest.test('to-json--from-json', () async {
final o = buildMetric();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Metric.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkMetric(od);
});
});
unittest.group('obj-schema-MonitoringComponentConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildMonitoringComponentConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MonitoringComponentConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMonitoringComponentConfig(od);
});
});
unittest.group('obj-schema-MonitoringConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildMonitoringConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MonitoringConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMonitoringConfig(od);
});
});
unittest.group('obj-schema-NetworkConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkConfig(od);
});
});
unittest.group('obj-schema-NetworkPerformanceConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkPerformanceConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkPerformanceConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkPerformanceConfig(od);
});
});
unittest.group('obj-schema-NetworkPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkPolicy(od);
});
});
unittest.group('obj-schema-NetworkPolicyConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkPolicyConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkPolicyConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkPolicyConfig(od);
});
});
unittest.group('obj-schema-NetworkTags', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkTags();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkTags.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkTags(od);
});
});
unittest.group('obj-schema-NodeAffinity', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeAffinity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodeAffinity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodeAffinity(od);
});
});
unittest.group('obj-schema-NodeConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NodeConfig.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNodeConfig(od);
});
});
unittest.group('obj-schema-NodeConfigDefaults', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeConfigDefaults();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodeConfigDefaults.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodeConfigDefaults(od);
});
});
unittest.group('obj-schema-NodeKubeletConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeKubeletConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodeKubeletConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodeKubeletConfig(od);
});
});
unittest.group('obj-schema-NodeLabels', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeLabels();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NodeLabels.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNodeLabels(od);
});
});
unittest.group('obj-schema-NodeManagement', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeManagement();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodeManagement.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodeManagement(od);
});
});
unittest.group('obj-schema-NodeNetworkConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeNetworkConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodeNetworkConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodeNetworkConfig(od);
});
});
unittest.group('obj-schema-NodePool', () {
unittest.test('to-json--from-json', () async {
final o = buildNodePool();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NodePool.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNodePool(od);
});
});
unittest.group('obj-schema-NodePoolAutoConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNodePoolAutoConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodePoolAutoConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodePoolAutoConfig(od);
});
});
unittest.group('obj-schema-NodePoolAutoscaling', () {
unittest.test('to-json--from-json', () async {
final o = buildNodePoolAutoscaling();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodePoolAutoscaling.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodePoolAutoscaling(od);
});
});
unittest.group('obj-schema-NodePoolDefaults', () {
unittest.test('to-json--from-json', () async {
final o = buildNodePoolDefaults();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodePoolDefaults.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodePoolDefaults(od);
});
});
unittest.group('obj-schema-NodePoolLoggingConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNodePoolLoggingConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NodePoolLoggingConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNodePoolLoggingConfig(od);
});
});
unittest.group('obj-schema-NodeTaint', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeTaint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NodeTaint.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNodeTaint(od);
});
});
unittest.group('obj-schema-NodeTaints', () {
unittest.test('to-json--from-json', () async {
final o = buildNodeTaints();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.NodeTaints.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkNodeTaints(od);
});
});
unittest.group('obj-schema-NotificationConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildNotificationConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NotificationConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNotificationConfig(od);
});
});
unittest.group('obj-schema-Operation', () {
unittest.test('to-json--from-json', () async {
final o = buildOperation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Operation.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOperation(od);
});
});
unittest.group('obj-schema-OperationProgress', () {
unittest.test('to-json--from-json', () async {
final o = buildOperationProgress();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OperationProgress.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOperationProgress(od);
});
});
unittest.group('obj-schema-PlacementPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementPolicy(od);
});
});
unittest.group('obj-schema-PodCIDROverprovisionConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildPodCIDROverprovisionConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PodCIDROverprovisionConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPodCIDROverprovisionConfig(od);
});
});
unittest.group('obj-schema-PrivateClusterConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildPrivateClusterConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PrivateClusterConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPrivateClusterConfig(od);
});
});
unittest.group('obj-schema-PrivateClusterMasterGlobalAccessConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildPrivateClusterMasterGlobalAccessConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PrivateClusterMasterGlobalAccessConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPrivateClusterMasterGlobalAccessConfig(od);
});
});
unittest.group('obj-schema-PubSub', () {
unittest.test('to-json--from-json', () async {
final o = buildPubSub();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.PubSub.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPubSub(od);
});
});
unittest.group('obj-schema-RangeInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildRangeInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.RangeInfo.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRangeInfo(od);
});
});
unittest.group('obj-schema-RecurringTimeWindow', () {
unittest.test('to-json--from-json', () async {
final o = buildRecurringTimeWindow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RecurringTimeWindow.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRecurringTimeWindow(od);
});
});
unittest.group('obj-schema-ReleaseChannel', () {
unittest.test('to-json--from-json', () async {
final o = buildReleaseChannel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReleaseChannel.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReleaseChannel(od);
});
});
unittest.group('obj-schema-ReleaseChannelConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildReleaseChannelConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReleaseChannelConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReleaseChannelConfig(od);
});
});
unittest.group('obj-schema-ReservationAffinity', () {
unittest.test('to-json--from-json', () async {
final o = buildReservationAffinity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReservationAffinity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReservationAffinity(od);
});
});
unittest.group('obj-schema-ResourceLabels', () {
unittest.test('to-json--from-json', () async {
final o = buildResourceLabels();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ResourceLabels.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkResourceLabels(od);
});
});
unittest.group('obj-schema-ResourceLimit', () {
unittest.test('to-json--from-json', () async {
final o = buildResourceLimit();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ResourceLimit.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkResourceLimit(od);
});
});
unittest.group('obj-schema-ResourceUsageExportConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildResourceUsageExportConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ResourceUsageExportConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkResourceUsageExportConfig(od);
});
});
unittest.group('obj-schema-RollbackNodePoolUpgradeRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRollbackNodePoolUpgradeRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RollbackNodePoolUpgradeRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRollbackNodePoolUpgradeRequest(od);
});
});
unittest.group('obj-schema-SandboxConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildSandboxConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SandboxConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSandboxConfig(od);
});
});
unittest.group('obj-schema-SecurityPostureConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildSecurityPostureConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SecurityPostureConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSecurityPostureConfig(od);
});
});
unittest.group('obj-schema-ServerConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildServerConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ServerConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkServerConfig(od);
});
});
unittest.group('obj-schema-ServiceExternalIPsConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildServiceExternalIPsConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ServiceExternalIPsConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkServiceExternalIPsConfig(od);
});
});
unittest.group('obj-schema-SetAddonsConfigRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetAddonsConfigRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetAddonsConfigRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetAddonsConfigRequest(od);
});
});
unittest.group('obj-schema-SetLabelsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetLabelsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetLabelsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetLabelsRequest(od);
});
});
unittest.group('obj-schema-SetLegacyAbacRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetLegacyAbacRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetLegacyAbacRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetLegacyAbacRequest(od);
});
});
unittest.group('obj-schema-SetLocationsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetLocationsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetLocationsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetLocationsRequest(od);
});
});
unittest.group('obj-schema-SetLoggingServiceRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetLoggingServiceRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetLoggingServiceRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetLoggingServiceRequest(od);
});
});
unittest.group('obj-schema-SetMaintenancePolicyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetMaintenancePolicyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetMaintenancePolicyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetMaintenancePolicyRequest(od);
});
});
unittest.group('obj-schema-SetMasterAuthRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetMasterAuthRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetMasterAuthRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetMasterAuthRequest(od);
});
});
unittest.group('obj-schema-SetMonitoringServiceRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetMonitoringServiceRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetMonitoringServiceRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetMonitoringServiceRequest(od);
});
});
unittest.group('obj-schema-SetNetworkPolicyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetNetworkPolicyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetNetworkPolicyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetNetworkPolicyRequest(od);
});
});
unittest.group('obj-schema-SetNodePoolAutoscalingRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetNodePoolAutoscalingRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetNodePoolAutoscalingRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetNodePoolAutoscalingRequest(od);
});
});
unittest.group('obj-schema-SetNodePoolManagementRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetNodePoolManagementRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetNodePoolManagementRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetNodePoolManagementRequest(od);
});
});
unittest.group('obj-schema-SetNodePoolSizeRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetNodePoolSizeRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetNodePoolSizeRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetNodePoolSizeRequest(od);
});
});
unittest.group('obj-schema-ShieldedInstanceConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildShieldedInstanceConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ShieldedInstanceConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkShieldedInstanceConfig(od);
});
});
unittest.group('obj-schema-ShieldedNodes', () {
unittest.test('to-json--from-json', () async {
final o = buildShieldedNodes();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ShieldedNodes.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkShieldedNodes(od);
});
});
unittest.group('obj-schema-SoleTenantConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildSoleTenantConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SoleTenantConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSoleTenantConfig(od);
});
});
unittest.group('obj-schema-StandardRolloutPolicy', () {
unittest.test('to-json--from-json', () async {
final o = buildStandardRolloutPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.StandardRolloutPolicy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkStandardRolloutPolicy(od);
});
});
unittest.group('obj-schema-StartIPRotationRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildStartIPRotationRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.StartIPRotationRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkStartIPRotationRequest(od);
});
});
unittest.group('obj-schema-Status', () {
unittest.test('to-json--from-json', () async {
final o = buildStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Status.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkStatus(od);
});
});
unittest.group('obj-schema-StatusCondition', () {
unittest.test('to-json--from-json', () async {
final o = buildStatusCondition();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.StatusCondition.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkStatusCondition(od);
});
});
unittest.group('obj-schema-TimeWindow', () {
unittest.test('to-json--from-json', () async {
final o = buildTimeWindow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TimeWindow.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTimeWindow(od);
});
});
unittest.group('obj-schema-UpdateClusterRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateClusterRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateClusterRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateClusterRequest(od);
});
});
unittest.group('obj-schema-UpdateInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.UpdateInfo.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkUpdateInfo(od);
});
});
unittest.group('obj-schema-UpdateMasterRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateMasterRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateMasterRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateMasterRequest(od);
});
});
unittest.group('obj-schema-UpdateNodePoolRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateNodePoolRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateNodePoolRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateNodePoolRequest(od);
});
});
unittest.group('obj-schema-UpgradeSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildUpgradeSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpgradeSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpgradeSettings(od);
});
});
unittest.group('obj-schema-UsableSubnetwork', () {
unittest.test('to-json--from-json', () async {
final o = buildUsableSubnetwork();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UsableSubnetwork.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUsableSubnetwork(od);
});
});
unittest.group('obj-schema-UsableSubnetworkSecondaryRange', () {
unittest.test('to-json--from-json', () async {
final o = buildUsableSubnetworkSecondaryRange();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UsableSubnetworkSecondaryRange.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUsableSubnetworkSecondaryRange(od);
});
});
unittest.group('obj-schema-VerticalPodAutoscaling', () {
unittest.test('to-json--from-json', () async {
final o = buildVerticalPodAutoscaling();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VerticalPodAutoscaling.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVerticalPodAutoscaling(od);
});
});
unittest.group('obj-schema-VirtualNIC', () {
unittest.test('to-json--from-json', () async {
final o = buildVirtualNIC();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.VirtualNIC.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkVirtualNIC(od);
});
});
unittest.group('obj-schema-WindowsNodeConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildWindowsNodeConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WindowsNodeConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWindowsNodeConfig(od);
});
});
unittest.group('obj-schema-WorkloadIdentityConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildWorkloadIdentityConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WorkloadIdentityConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWorkloadIdentityConfig(od);
});
});
unittest.group('obj-schema-WorkloadMetadataConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildWorkloadMetadataConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WorkloadMetadataConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWorkloadMetadataConfig(od);
});
});
unittest.group('obj-schema-WorkloadPolicyConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildWorkloadPolicyConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WorkloadPolicyConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWorkloadPolicyConfig(od);
});
});
unittest.group('resource-ProjectsAggregatedUsableSubnetworksResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.aggregated.usableSubnetworks;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListUsableSubnetworksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListUsableSubnetworksResponse(
response as api.ListUsableSubnetworksResponse);
});
});
unittest.group('resource-ProjectsLocationsResource', () {
unittest.test('method--getServerConfig', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations;
final arg_name = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildServerConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getServerConfig(arg_name,
projectId: arg_projectId, zone: arg_zone, $fields: arg_$fields);
checkServerConfig(response as api.ServerConfig);
});
});
unittest.group('resource-ProjectsLocationsClustersResource', () {
unittest.test('method--checkAutopilotCompatibility', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildCheckAutopilotCompatibilityResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.checkAutopilotCompatibility(arg_name, $fields: arg_$fields);
checkCheckAutopilotCompatibilityResponse(
response as api.CheckAutopilotCompatibilityResponse);
});
unittest.test('method--completeIpRotation', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildCompleteIPRotationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CompleteIPRotationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCompleteIPRotationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.completeIpRotation(arg_request, arg_name,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildCreateClusterRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreateClusterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreateClusterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_name = 'foo';
final arg_clusterId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['clusterId']!.first,
unittest.equals(arg_clusterId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name,
clusterId: arg_clusterId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_name = 'foo';
final arg_clusterId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['clusterId']!.first,
unittest.equals(arg_clusterId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCluster());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name,
clusterId: arg_clusterId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkCluster(response as api.Cluster);
});
unittest.test('method--getJwks', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGetJSONWebKeysResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getJwks(arg_parent, $fields: arg_$fields);
checkGetJSONWebKeysResponse(response as api.GetJSONWebKeysResponse);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_parent = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListClustersResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
projectId: arg_projectId, zone: arg_zone, $fields: arg_$fields);
checkListClustersResponse(response as api.ListClustersResponse);
});
unittest.test('method--setAddons', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetAddonsConfigRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetAddonsConfigRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetAddonsConfigRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setAddons(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setLegacyAbac', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetLegacyAbacRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLegacyAbacRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLegacyAbacRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setLegacyAbac(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setLocations', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetLocationsRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLocationsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLocationsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setLocations(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setLogging', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetLoggingServiceRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLoggingServiceRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLoggingServiceRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setLogging(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setMaintenancePolicy', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetMaintenancePolicyRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMaintenancePolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMaintenancePolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setMaintenancePolicy(arg_request, arg_name,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setMasterAuth', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetMasterAuthRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMasterAuthRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMasterAuthRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setMasterAuth(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setMonitoring', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetMonitoringServiceRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMonitoringServiceRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMonitoringServiceRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setMonitoring(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setNetworkPolicy', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetNetworkPolicyRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNetworkPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNetworkPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setNetworkPolicy(arg_request, arg_name,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setResourceLabels', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildSetLabelsRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLabelsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLabelsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setResourceLabels(arg_request, arg_name,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--startIpRotation', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildStartIPRotationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.StartIPRotationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkStartIPRotationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.startIpRotation(arg_request, arg_name,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildUpdateClusterRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateClusterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateClusterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--updateMaster', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters;
final arg_request = buildUpdateMasterRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateMasterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateMasterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.updateMaster(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsLocationsClustersNodePoolsResource', () {
unittest.test('method--completeUpgrade', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildCompleteNodePoolUpgradeRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CompleteNodePoolUpgradeRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCompleteNodePoolUpgradeRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.completeUpgrade(arg_request, arg_name,
$fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildCreateNodePoolRequest();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreateNodePoolRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreateNodePoolRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_name = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['clusterId']!.first,
unittest.equals(arg_clusterId),
);
unittest.expect(
queryMap['nodePoolId']!.first,
unittest.equals(arg_nodePoolId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name,
clusterId: arg_clusterId,
nodePoolId: arg_nodePoolId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_name = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['clusterId']!.first,
unittest.equals(arg_clusterId),
);
unittest.expect(
queryMap['nodePoolId']!.first,
unittest.equals(arg_nodePoolId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildNodePool());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name,
clusterId: arg_clusterId,
nodePoolId: arg_nodePoolId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkNodePool(response as api.NodePool);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_parent = 'foo';
final arg_clusterId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['clusterId']!.first,
unittest.equals(arg_clusterId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListNodePoolsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
clusterId: arg_clusterId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkListNodePoolsResponse(response as api.ListNodePoolsResponse);
});
unittest.test('method--rollback', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildRollbackNodePoolUpgradeRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RollbackNodePoolUpgradeRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRollbackNodePoolUpgradeRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.rollback(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setAutoscaling', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildSetNodePoolAutoscalingRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolAutoscalingRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolAutoscalingRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setAutoscaling(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setManagement', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildSetNodePoolManagementRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolManagementRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolManagementRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setManagement(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setSize', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildSetNodePoolSizeRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolSizeRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolSizeRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.setSize(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.nodePools;
final arg_request = buildUpdateNodePoolRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateNodePoolRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateNodePoolRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsLocationsClustersWellKnownResource', () {
unittest.test('method--getOpenidConfiguration', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.clusters.wellKnown;
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGetOpenIDConfigResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getOpenidConfiguration(arg_parent, $fields: arg_$fields);
checkGetOpenIDConfigResponse(response as api.GetOpenIDConfigResponse);
});
});
unittest.group('resource-ProjectsLocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.operations;
final arg_name = 'foo';
final arg_operationId = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['operationId']!.first,
unittest.equals(arg_operationId),
);
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name,
operationId: arg_operationId,
projectId: arg_projectId,
zone: arg_zone,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.locations.operations;
final arg_parent = 'foo';
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['projectId']!.first,
unittest.equals(arg_projectId),
);
unittest.expect(
queryMap['zone']!.first,
unittest.equals(arg_zone),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
projectId: arg_projectId, zone: arg_zone, $fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-ProjectsZonesResource', () {
unittest.test('method--getServerconfig', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/serverconfig', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/serverconfig'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildServerConfig());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getServerconfig(arg_projectId, arg_zone,
name: arg_name, $fields: arg_$fields);
checkServerConfig(response as api.ServerConfig);
});
});
unittest.group('resource-ProjectsZonesClustersResource', () {
unittest.test('method--addons', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetAddonsConfigRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetAddonsConfigRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetAddonsConfigRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/addons', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/addons'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.addons(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--completeIpRotation', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildCompleteIPRotationRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CompleteIPRotationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCompleteIPRotationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf(':completeIpRotation', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 19),
unittest.equals(':completeIpRotation'),
);
pathOffset += 19;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.completeIpRotation(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildCreateClusterRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreateClusterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreateClusterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/clusters'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_projectId, arg_zone,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_projectId, arg_zone, arg_clusterId,
name: arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCluster());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_projectId, arg_zone, arg_clusterId,
name: arg_name, $fields: arg_$fields);
checkCluster(response as api.Cluster);
});
unittest.test('method--legacyAbac', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetLegacyAbacRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLegacyAbacRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLegacyAbacRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/legacyAbac', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/legacyAbac'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.legacyAbac(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/clusters'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['parent']!.first,
unittest.equals(arg_parent),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListClustersResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_projectId, arg_zone,
parent: arg_parent, $fields: arg_$fields);
checkListClustersResponse(response as api.ListClustersResponse);
});
unittest.test('method--locations', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetLocationsRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLocationsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLocationsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/locations', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/locations'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.locations(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--logging', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetLoggingServiceRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLoggingServiceRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLoggingServiceRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/logging', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/logging'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.logging(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--master', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildUpdateMasterRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateMasterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateMasterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/master', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/master'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.master(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--monitoring', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetMonitoringServiceRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMonitoringServiceRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMonitoringServiceRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/monitoring', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/monitoring'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.monitoring(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--resourceLabels', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetLabelsRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetLabelsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetLabelsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/resourceLabels', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 15),
unittest.equals('/resourceLabels'),
);
pathOffset += 15;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.resourceLabels(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setMaintenancePolicy', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetMaintenancePolicyRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMaintenancePolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMaintenancePolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf(':setMaintenancePolicy', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 21),
unittest.equals(':setMaintenancePolicy'),
);
pathOffset += 21;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setMaintenancePolicy(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setMasterAuth', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetMasterAuthRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetMasterAuthRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetMasterAuthRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf(':setMasterAuth', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 14),
unittest.equals(':setMasterAuth'),
);
pathOffset += 14;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setMasterAuth(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setNetworkPolicy', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildSetNetworkPolicyRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNetworkPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNetworkPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf(':setNetworkPolicy', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 17),
unittest.equals(':setNetworkPolicy'),
);
pathOffset += 17;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setNetworkPolicy(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--startIpRotation', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildStartIPRotationRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.StartIPRotationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkStartIPRotationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf(':startIpRotation', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals(':startIpRotation'),
);
pathOffset += 16;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.startIpRotation(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters;
final arg_request = buildUpdateClusterRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateClusterRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateClusterRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsZonesClustersNodePoolsResource', () {
unittest.test('method--autoscaling', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildSetNodePoolAutoscalingRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolAutoscalingRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolAutoscalingRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
index = path.indexOf('/autoscaling', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('/autoscaling'),
);
pathOffset += 12;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.autoscaling(
arg_request, arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildCreateNodePoolRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreateNodePoolRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreateNodePoolRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/nodePools'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(
arg_request, arg_projectId, arg_zone, arg_clusterId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(
arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
name: arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildNodePool());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(
arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
name: arg_name, $fields: arg_$fields);
checkNodePool(response as api.NodePool);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/nodePools'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['parent']!.first,
unittest.equals(arg_parent),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListNodePoolsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_projectId, arg_zone, arg_clusterId,
parent: arg_parent, $fields: arg_$fields);
checkListNodePoolsResponse(response as api.ListNodePoolsResponse);
});
unittest.test('method--rollback', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildRollbackNodePoolUpgradeRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RollbackNodePoolUpgradeRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRollbackNodePoolUpgradeRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
index = path.indexOf(':rollback', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals(':rollback'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.rollback(
arg_request, arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setManagement', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildSetNodePoolManagementRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolManagementRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolManagementRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
index = path.indexOf('/setManagement', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 14),
unittest.equals('/setManagement'),
);
pathOffset += 14;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setManagement(
arg_request, arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setSize', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildSetNodePoolSizeRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetNodePoolSizeRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetNodePoolSizeRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
index = path.indexOf('/setSize', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/setSize'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setSize(
arg_request, arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.clusters.nodePools;
final arg_request = buildUpdateNodePoolRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_clusterId = 'foo';
final arg_nodePoolId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UpdateNodePoolRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUpdateNodePoolRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/clusters/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/clusters/'),
);
pathOffset += 10;
index = path.indexOf('/nodePools/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_clusterId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/nodePools/'),
);
pathOffset += 11;
index = path.indexOf('/update', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_nodePoolId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/update'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_projectId, arg_zone, arg_clusterId, arg_nodePoolId,
$fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsZonesOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.operations;
final arg_request = buildCancelOperationRequest();
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_operationId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/operations/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('/operations/'),
);
pathOffset += 12;
index = path.indexOf(':cancel', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_operationId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals(':cancel'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.cancel(
arg_request, arg_projectId, arg_zone, arg_operationId,
$fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.operations;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_operationId = 'foo';
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/operations/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('/operations/'),
);
pathOffset += 12;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_operationId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_projectId, arg_zone, arg_operationId,
name: arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.ContainerApi(mock).projects.zones.operations;
final arg_projectId = 'foo';
final arg_zone = 'foo';
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('v1/projects/'),
);
pathOffset += 12;
index = path.indexOf('/zones/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_projectId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/zones/'),
);
pathOffset += 7;
index = path.indexOf('/operations', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_zone'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/operations'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['parent']!.first,
unittest.equals(arg_parent),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_projectId, arg_zone,
parent: arg_parent, $fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/container/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/container/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 172197}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/dfareporting/v4.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAccount = 0;
api.Account buildAccount() {
final o = api.Account();
buildCounterAccount++;
if (buildCounterAccount < 3) {
o.accountPermissionIds = buildUnnamed0();
o.accountProfile = 'foo';
o.active = true;
o.activeAdsLimitTier = 'foo';
o.activeViewOptOut = true;
o.availablePermissionIds = buildUnnamed1();
o.countryId = 'foo';
o.currencyId = 'foo';
o.defaultCreativeSizeId = 'foo';
o.description = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.locale = 'foo';
o.maximumImageSize = 'foo';
o.name = 'foo';
o.nielsenOcrEnabled = true;
o.reportsConfiguration = buildReportsConfiguration();
o.shareReportsWithTwitter = true;
o.teaserSizeLimit = 'foo';
}
buildCounterAccount--;
return o;
}
void checkAccount(api.Account o) {
buildCounterAccount++;
if (buildCounterAccount < 3) {
checkUnnamed0(o.accountPermissionIds!);
unittest.expect(
o.accountProfile!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.activeAdsLimitTier!,
unittest.equals('foo'),
);
unittest.expect(o.activeViewOptOut!, unittest.isTrue);
checkUnnamed1(o.availablePermissionIds!);
unittest.expect(
o.countryId!,
unittest.equals('foo'),
);
unittest.expect(
o.currencyId!,
unittest.equals('foo'),
);
unittest.expect(
o.defaultCreativeSizeId!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.locale!,
unittest.equals('foo'),
);
unittest.expect(
o.maximumImageSize!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(o.nielsenOcrEnabled!, unittest.isTrue);
checkReportsConfiguration(o.reportsConfiguration!);
unittest.expect(o.shareReportsWithTwitter!, unittest.isTrue);
unittest.expect(
o.teaserSizeLimit!,
unittest.equals('foo'),
);
}
buildCounterAccount--;
}
core.int buildCounterAccountActiveAdSummary = 0;
api.AccountActiveAdSummary buildAccountActiveAdSummary() {
final o = api.AccountActiveAdSummary();
buildCounterAccountActiveAdSummary++;
if (buildCounterAccountActiveAdSummary < 3) {
o.accountId = 'foo';
o.activeAds = 'foo';
o.activeAdsLimitTier = 'foo';
o.availableAds = 'foo';
o.kind = 'foo';
}
buildCounterAccountActiveAdSummary--;
return o;
}
void checkAccountActiveAdSummary(api.AccountActiveAdSummary o) {
buildCounterAccountActiveAdSummary++;
if (buildCounterAccountActiveAdSummary < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.activeAds!,
unittest.equals('foo'),
);
unittest.expect(
o.activeAdsLimitTier!,
unittest.equals('foo'),
);
unittest.expect(
o.availableAds!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterAccountActiveAdSummary--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAccountPermission = 0;
api.AccountPermission buildAccountPermission() {
final o = api.AccountPermission();
buildCounterAccountPermission++;
if (buildCounterAccountPermission < 3) {
o.accountProfiles = buildUnnamed2();
o.id = 'foo';
o.kind = 'foo';
o.level = 'foo';
o.name = 'foo';
o.permissionGroupId = 'foo';
}
buildCounterAccountPermission--;
return o;
}
void checkAccountPermission(api.AccountPermission o) {
buildCounterAccountPermission++;
if (buildCounterAccountPermission < 3) {
checkUnnamed2(o.accountProfiles!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.level!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.permissionGroupId!,
unittest.equals('foo'),
);
}
buildCounterAccountPermission--;
}
core.int buildCounterAccountPermissionGroup = 0;
api.AccountPermissionGroup buildAccountPermissionGroup() {
final o = api.AccountPermissionGroup();
buildCounterAccountPermissionGroup++;
if (buildCounterAccountPermissionGroup < 3) {
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterAccountPermissionGroup--;
return o;
}
void checkAccountPermissionGroup(api.AccountPermissionGroup o) {
buildCounterAccountPermissionGroup++;
if (buildCounterAccountPermissionGroup < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterAccountPermissionGroup--;
}
core.List<api.AccountPermissionGroup> buildUnnamed3() => [
buildAccountPermissionGroup(),
buildAccountPermissionGroup(),
];
void checkUnnamed3(core.List<api.AccountPermissionGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccountPermissionGroup(o[0]);
checkAccountPermissionGroup(o[1]);
}
core.int buildCounterAccountPermissionGroupsListResponse = 0;
api.AccountPermissionGroupsListResponse
buildAccountPermissionGroupsListResponse() {
final o = api.AccountPermissionGroupsListResponse();
buildCounterAccountPermissionGroupsListResponse++;
if (buildCounterAccountPermissionGroupsListResponse < 3) {
o.accountPermissionGroups = buildUnnamed3();
o.kind = 'foo';
}
buildCounterAccountPermissionGroupsListResponse--;
return o;
}
void checkAccountPermissionGroupsListResponse(
api.AccountPermissionGroupsListResponse o) {
buildCounterAccountPermissionGroupsListResponse++;
if (buildCounterAccountPermissionGroupsListResponse < 3) {
checkUnnamed3(o.accountPermissionGroups!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterAccountPermissionGroupsListResponse--;
}
core.List<api.AccountPermission> buildUnnamed4() => [
buildAccountPermission(),
buildAccountPermission(),
];
void checkUnnamed4(core.List<api.AccountPermission> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccountPermission(o[0]);
checkAccountPermission(o[1]);
}
core.int buildCounterAccountPermissionsListResponse = 0;
api.AccountPermissionsListResponse buildAccountPermissionsListResponse() {
final o = api.AccountPermissionsListResponse();
buildCounterAccountPermissionsListResponse++;
if (buildCounterAccountPermissionsListResponse < 3) {
o.accountPermissions = buildUnnamed4();
o.kind = 'foo';
}
buildCounterAccountPermissionsListResponse--;
return o;
}
void checkAccountPermissionsListResponse(api.AccountPermissionsListResponse o) {
buildCounterAccountPermissionsListResponse++;
if (buildCounterAccountPermissionsListResponse < 3) {
checkUnnamed4(o.accountPermissions!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterAccountPermissionsListResponse--;
}
core.int buildCounterAccountUserProfile = 0;
api.AccountUserProfile buildAccountUserProfile() {
final o = api.AccountUserProfile();
buildCounterAccountUserProfile++;
if (buildCounterAccountUserProfile < 3) {
o.accountId = 'foo';
o.active = true;
o.advertiserFilter = buildObjectFilter();
o.campaignFilter = buildObjectFilter();
o.comments = 'foo';
o.email = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.locale = 'foo';
o.name = 'foo';
o.siteFilter = buildObjectFilter();
o.subaccountId = 'foo';
o.traffickerType = 'foo';
o.userAccessType = 'foo';
o.userRoleFilter = buildObjectFilter();
o.userRoleId = 'foo';
}
buildCounterAccountUserProfile--;
return o;
}
void checkAccountUserProfile(api.AccountUserProfile o) {
buildCounterAccountUserProfile++;
if (buildCounterAccountUserProfile < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
checkObjectFilter(o.advertiserFilter!);
checkObjectFilter(o.campaignFilter!);
unittest.expect(
o.comments!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.locale!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkObjectFilter(o.siteFilter!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.traffickerType!,
unittest.equals('foo'),
);
unittest.expect(
o.userAccessType!,
unittest.equals('foo'),
);
checkObjectFilter(o.userRoleFilter!);
unittest.expect(
o.userRoleId!,
unittest.equals('foo'),
);
}
buildCounterAccountUserProfile--;
}
core.List<api.AccountUserProfile> buildUnnamed5() => [
buildAccountUserProfile(),
buildAccountUserProfile(),
];
void checkUnnamed5(core.List<api.AccountUserProfile> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccountUserProfile(o[0]);
checkAccountUserProfile(o[1]);
}
core.int buildCounterAccountUserProfilesListResponse = 0;
api.AccountUserProfilesListResponse buildAccountUserProfilesListResponse() {
final o = api.AccountUserProfilesListResponse();
buildCounterAccountUserProfilesListResponse++;
if (buildCounterAccountUserProfilesListResponse < 3) {
o.accountUserProfiles = buildUnnamed5();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAccountUserProfilesListResponse--;
return o;
}
void checkAccountUserProfilesListResponse(
api.AccountUserProfilesListResponse o) {
buildCounterAccountUserProfilesListResponse++;
if (buildCounterAccountUserProfilesListResponse < 3) {
checkUnnamed5(o.accountUserProfiles!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAccountUserProfilesListResponse--;
}
core.List<api.Account> buildUnnamed6() => [
buildAccount(),
buildAccount(),
];
void checkUnnamed6(core.List<api.Account> o) {
unittest.expect(o, unittest.hasLength(2));
checkAccount(o[0]);
checkAccount(o[1]);
}
core.int buildCounterAccountsListResponse = 0;
api.AccountsListResponse buildAccountsListResponse() {
final o = api.AccountsListResponse();
buildCounterAccountsListResponse++;
if (buildCounterAccountsListResponse < 3) {
o.accounts = buildUnnamed6();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAccountsListResponse--;
return o;
}
void checkAccountsListResponse(api.AccountsListResponse o) {
buildCounterAccountsListResponse++;
if (buildCounterAccountsListResponse < 3) {
checkUnnamed6(o.accounts!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAccountsListResponse--;
}
core.List<api.DimensionValue> buildUnnamed7() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed7(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<core.String> buildUnnamed8() => [
'foo',
'foo',
];
void checkUnnamed8(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterActivities = 0;
api.Activities buildActivities() {
final o = api.Activities();
buildCounterActivities++;
if (buildCounterActivities < 3) {
o.filters = buildUnnamed7();
o.kind = 'foo';
o.metricNames = buildUnnamed8();
}
buildCounterActivities--;
return o;
}
void checkActivities(api.Activities o) {
buildCounterActivities++;
if (buildCounterActivities < 3) {
checkUnnamed7(o.filters!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed8(o.metricNames!);
}
buildCounterActivities--;
}
core.List<api.CreativeGroupAssignment> buildUnnamed9() => [
buildCreativeGroupAssignment(),
buildCreativeGroupAssignment(),
];
void checkUnnamed9(core.List<api.CreativeGroupAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeGroupAssignment(o[0]);
checkCreativeGroupAssignment(o[1]);
}
core.List<api.EventTagOverride> buildUnnamed10() => [
buildEventTagOverride(),
buildEventTagOverride(),
];
void checkUnnamed10(core.List<api.EventTagOverride> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventTagOverride(o[0]);
checkEventTagOverride(o[1]);
}
core.List<api.PlacementAssignment> buildUnnamed11() => [
buildPlacementAssignment(),
buildPlacementAssignment(),
];
void checkUnnamed11(core.List<api.PlacementAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlacementAssignment(o[0]);
checkPlacementAssignment(o[1]);
}
core.int buildCounterAd = 0;
api.Ad buildAd() {
final o = api.Ad();
buildCounterAd++;
if (buildCounterAd < 3) {
o.accountId = 'foo';
o.active = true;
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.archived = true;
o.audienceSegmentId = 'foo';
o.campaignId = 'foo';
o.campaignIdDimensionValue = buildDimensionValue();
o.clickThroughUrl = buildClickThroughUrl();
o.clickThroughUrlSuffixProperties = buildClickThroughUrlSuffixProperties();
o.comments = 'foo';
o.compatibility = 'foo';
o.createInfo = buildLastModifiedInfo();
o.creativeGroupAssignments = buildUnnamed9();
o.creativeRotation = buildCreativeRotation();
o.dayPartTargeting = buildDayPartTargeting();
o.defaultClickThroughEventTagProperties =
buildDefaultClickThroughEventTagProperties();
o.deliverySchedule = buildDeliverySchedule();
o.dynamicClickTracker = true;
o.endTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.eventTagOverrides = buildUnnamed10();
o.geoTargeting = buildGeoTargeting();
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.keyValueTargetingExpression = buildKeyValueTargetingExpression();
o.kind = 'foo';
o.languageTargeting = buildLanguageTargeting();
o.lastModifiedInfo = buildLastModifiedInfo();
o.name = 'foo';
o.placementAssignments = buildUnnamed11();
o.remarketingListExpression = buildListTargetingExpression();
o.size = buildSize();
o.sslCompliant = true;
o.sslRequired = true;
o.startTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.subaccountId = 'foo';
o.targetingTemplateId = 'foo';
o.technologyTargeting = buildTechnologyTargeting();
o.type = 'foo';
}
buildCounterAd--;
return o;
}
void checkAd(api.Ad o) {
buildCounterAd++;
if (buildCounterAd < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(o.archived!, unittest.isTrue);
unittest.expect(
o.audienceSegmentId!,
unittest.equals('foo'),
);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
checkDimensionValue(o.campaignIdDimensionValue!);
checkClickThroughUrl(o.clickThroughUrl!);
checkClickThroughUrlSuffixProperties(o.clickThroughUrlSuffixProperties!);
unittest.expect(
o.comments!,
unittest.equals('foo'),
);
unittest.expect(
o.compatibility!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.createInfo!);
checkUnnamed9(o.creativeGroupAssignments!);
checkCreativeRotation(o.creativeRotation!);
checkDayPartTargeting(o.dayPartTargeting!);
checkDefaultClickThroughEventTagProperties(
o.defaultClickThroughEventTagProperties!);
checkDeliverySchedule(o.deliverySchedule!);
unittest.expect(o.dynamicClickTracker!, unittest.isTrue);
unittest.expect(
o.endTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkUnnamed10(o.eventTagOverrides!);
checkGeoTargeting(o.geoTargeting!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
checkKeyValueTargetingExpression(o.keyValueTargetingExpression!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLanguageTargeting(o.languageTargeting!);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed11(o.placementAssignments!);
checkListTargetingExpression(o.remarketingListExpression!);
checkSize(o.size!);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(o.sslRequired!, unittest.isTrue);
unittest.expect(
o.startTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.targetingTemplateId!,
unittest.equals('foo'),
);
checkTechnologyTargeting(o.technologyTargeting!);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterAd--;
}
core.int buildCounterAdBlockingConfiguration = 0;
api.AdBlockingConfiguration buildAdBlockingConfiguration() {
final o = api.AdBlockingConfiguration();
buildCounterAdBlockingConfiguration++;
if (buildCounterAdBlockingConfiguration < 3) {
o.enabled = true;
}
buildCounterAdBlockingConfiguration--;
return o;
}
void checkAdBlockingConfiguration(api.AdBlockingConfiguration o) {
buildCounterAdBlockingConfiguration++;
if (buildCounterAdBlockingConfiguration < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
}
buildCounterAdBlockingConfiguration--;
}
core.int buildCounterAdSlot = 0;
api.AdSlot buildAdSlot() {
final o = api.AdSlot();
buildCounterAdSlot++;
if (buildCounterAdSlot < 3) {
o.comment = 'foo';
o.compatibility = 'foo';
o.height = 'foo';
o.linkedPlacementId = 'foo';
o.name = 'foo';
o.paymentSourceType = 'foo';
o.primary = true;
o.width = 'foo';
}
buildCounterAdSlot--;
return o;
}
void checkAdSlot(api.AdSlot o) {
buildCounterAdSlot++;
if (buildCounterAdSlot < 3) {
unittest.expect(
o.comment!,
unittest.equals('foo'),
);
unittest.expect(
o.compatibility!,
unittest.equals('foo'),
);
unittest.expect(
o.height!,
unittest.equals('foo'),
);
unittest.expect(
o.linkedPlacementId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.paymentSourceType!,
unittest.equals('foo'),
);
unittest.expect(o.primary!, unittest.isTrue);
unittest.expect(
o.width!,
unittest.equals('foo'),
);
}
buildCounterAdSlot--;
}
core.List<api.Ad> buildUnnamed12() => [
buildAd(),
buildAd(),
];
void checkUnnamed12(core.List<api.Ad> o) {
unittest.expect(o, unittest.hasLength(2));
checkAd(o[0]);
checkAd(o[1]);
}
core.int buildCounterAdsListResponse = 0;
api.AdsListResponse buildAdsListResponse() {
final o = api.AdsListResponse();
buildCounterAdsListResponse++;
if (buildCounterAdsListResponse < 3) {
o.ads = buildUnnamed12();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAdsListResponse--;
return o;
}
void checkAdsListResponse(api.AdsListResponse o) {
buildCounterAdsListResponse++;
if (buildCounterAdsListResponse < 3) {
checkUnnamed12(o.ads!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAdsListResponse--;
}
core.int buildCounterAdvertiser = 0;
api.Advertiser buildAdvertiser() {
final o = api.Advertiser();
buildCounterAdvertiser++;
if (buildCounterAdvertiser < 3) {
o.accountId = 'foo';
o.advertiserGroupId = 'foo';
o.clickThroughUrlSuffix = 'foo';
o.defaultClickThroughEventTagId = 'foo';
o.defaultEmail = 'foo';
o.floodlightConfigurationId = 'foo';
o.floodlightConfigurationIdDimensionValue = buildDimensionValue();
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.measurementPartnerLink = buildMeasurementPartnerAdvertiserLink();
o.name = 'foo';
o.originalFloodlightConfigurationId = 'foo';
o.status = 'foo';
o.subaccountId = 'foo';
o.suspended = true;
}
buildCounterAdvertiser--;
return o;
}
void checkAdvertiser(api.Advertiser o) {
buildCounterAdvertiser++;
if (buildCounterAdvertiser < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserGroupId!,
unittest.equals('foo'),
);
unittest.expect(
o.clickThroughUrlSuffix!,
unittest.equals('foo'),
);
unittest.expect(
o.defaultClickThroughEventTagId!,
unittest.equals('foo'),
);
unittest.expect(
o.defaultEmail!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightConfigurationId!,
unittest.equals('foo'),
);
checkDimensionValue(o.floodlightConfigurationIdDimensionValue!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkMeasurementPartnerAdvertiserLink(o.measurementPartnerLink!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.originalFloodlightConfigurationId!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(o.suspended!, unittest.isTrue);
}
buildCounterAdvertiser--;
}
core.int buildCounterAdvertiserGroup = 0;
api.AdvertiserGroup buildAdvertiserGroup() {
final o = api.AdvertiserGroup();
buildCounterAdvertiserGroup++;
if (buildCounterAdvertiserGroup < 3) {
o.accountId = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterAdvertiserGroup--;
return o;
}
void checkAdvertiserGroup(api.AdvertiserGroup o) {
buildCounterAdvertiserGroup++;
if (buildCounterAdvertiserGroup < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterAdvertiserGroup--;
}
core.List<api.AdvertiserGroup> buildUnnamed13() => [
buildAdvertiserGroup(),
buildAdvertiserGroup(),
];
void checkUnnamed13(core.List<api.AdvertiserGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdvertiserGroup(o[0]);
checkAdvertiserGroup(o[1]);
}
core.int buildCounterAdvertiserGroupsListResponse = 0;
api.AdvertiserGroupsListResponse buildAdvertiserGroupsListResponse() {
final o = api.AdvertiserGroupsListResponse();
buildCounterAdvertiserGroupsListResponse++;
if (buildCounterAdvertiserGroupsListResponse < 3) {
o.advertiserGroups = buildUnnamed13();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAdvertiserGroupsListResponse--;
return o;
}
void checkAdvertiserGroupsListResponse(api.AdvertiserGroupsListResponse o) {
buildCounterAdvertiserGroupsListResponse++;
if (buildCounterAdvertiserGroupsListResponse < 3) {
checkUnnamed13(o.advertiserGroups!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAdvertiserGroupsListResponse--;
}
core.List<api.Invoice> buildUnnamed14() => [
buildInvoice(),
buildInvoice(),
];
void checkUnnamed14(core.List<api.Invoice> o) {
unittest.expect(o, unittest.hasLength(2));
checkInvoice(o[0]);
checkInvoice(o[1]);
}
core.int buildCounterAdvertiserInvoicesListResponse = 0;
api.AdvertiserInvoicesListResponse buildAdvertiserInvoicesListResponse() {
final o = api.AdvertiserInvoicesListResponse();
buildCounterAdvertiserInvoicesListResponse++;
if (buildCounterAdvertiserInvoicesListResponse < 3) {
o.invoices = buildUnnamed14();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAdvertiserInvoicesListResponse--;
return o;
}
void checkAdvertiserInvoicesListResponse(api.AdvertiserInvoicesListResponse o) {
buildCounterAdvertiserInvoicesListResponse++;
if (buildCounterAdvertiserInvoicesListResponse < 3) {
checkUnnamed14(o.invoices!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAdvertiserInvoicesListResponse--;
}
core.List<api.LandingPage> buildUnnamed15() => [
buildLandingPage(),
buildLandingPage(),
];
void checkUnnamed15(core.List<api.LandingPage> o) {
unittest.expect(o, unittest.hasLength(2));
checkLandingPage(o[0]);
checkLandingPage(o[1]);
}
core.int buildCounterAdvertiserLandingPagesListResponse = 0;
api.AdvertiserLandingPagesListResponse
buildAdvertiserLandingPagesListResponse() {
final o = api.AdvertiserLandingPagesListResponse();
buildCounterAdvertiserLandingPagesListResponse++;
if (buildCounterAdvertiserLandingPagesListResponse < 3) {
o.kind = 'foo';
o.landingPages = buildUnnamed15();
o.nextPageToken = 'foo';
}
buildCounterAdvertiserLandingPagesListResponse--;
return o;
}
void checkAdvertiserLandingPagesListResponse(
api.AdvertiserLandingPagesListResponse o) {
buildCounterAdvertiserLandingPagesListResponse++;
if (buildCounterAdvertiserLandingPagesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed15(o.landingPages!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAdvertiserLandingPagesListResponse--;
}
core.List<api.Advertiser> buildUnnamed16() => [
buildAdvertiser(),
buildAdvertiser(),
];
void checkUnnamed16(core.List<api.Advertiser> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdvertiser(o[0]);
checkAdvertiser(o[1]);
}
core.int buildCounterAdvertisersListResponse = 0;
api.AdvertisersListResponse buildAdvertisersListResponse() {
final o = api.AdvertisersListResponse();
buildCounterAdvertisersListResponse++;
if (buildCounterAdvertisersListResponse < 3) {
o.advertisers = buildUnnamed16();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterAdvertisersListResponse--;
return o;
}
void checkAdvertisersListResponse(api.AdvertisersListResponse o) {
buildCounterAdvertisersListResponse++;
if (buildCounterAdvertisersListResponse < 3) {
checkUnnamed16(o.advertisers!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterAdvertisersListResponse--;
}
core.int buildCounterAudienceSegment = 0;
api.AudienceSegment buildAudienceSegment() {
final o = api.AudienceSegment();
buildCounterAudienceSegment++;
if (buildCounterAudienceSegment < 3) {
o.allocation = 42;
o.id = 'foo';
o.name = 'foo';
}
buildCounterAudienceSegment--;
return o;
}
void checkAudienceSegment(api.AudienceSegment o) {
buildCounterAudienceSegment++;
if (buildCounterAudienceSegment < 3) {
unittest.expect(
o.allocation!,
unittest.equals(42),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterAudienceSegment--;
}
core.List<api.AudienceSegment> buildUnnamed17() => [
buildAudienceSegment(),
buildAudienceSegment(),
];
void checkUnnamed17(core.List<api.AudienceSegment> o) {
unittest.expect(o, unittest.hasLength(2));
checkAudienceSegment(o[0]);
checkAudienceSegment(o[1]);
}
core.int buildCounterAudienceSegmentGroup = 0;
api.AudienceSegmentGroup buildAudienceSegmentGroup() {
final o = api.AudienceSegmentGroup();
buildCounterAudienceSegmentGroup++;
if (buildCounterAudienceSegmentGroup < 3) {
o.audienceSegments = buildUnnamed17();
o.id = 'foo';
o.name = 'foo';
}
buildCounterAudienceSegmentGroup--;
return o;
}
void checkAudienceSegmentGroup(api.AudienceSegmentGroup o) {
buildCounterAudienceSegmentGroup++;
if (buildCounterAudienceSegmentGroup < 3) {
checkUnnamed17(o.audienceSegments!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterAudienceSegmentGroup--;
}
core.int buildCounterBillingAssignment = 0;
api.BillingAssignment buildBillingAssignment() {
final o = api.BillingAssignment();
buildCounterBillingAssignment++;
if (buildCounterBillingAssignment < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.campaignId = 'foo';
o.kind = 'foo';
o.subaccountId = 'foo';
}
buildCounterBillingAssignment--;
return o;
}
void checkBillingAssignment(api.BillingAssignment o) {
buildCounterBillingAssignment++;
if (buildCounterBillingAssignment < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterBillingAssignment--;
}
core.List<api.BillingAssignment> buildUnnamed18() => [
buildBillingAssignment(),
buildBillingAssignment(),
];
void checkUnnamed18(core.List<api.BillingAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkBillingAssignment(o[0]);
checkBillingAssignment(o[1]);
}
core.int buildCounterBillingAssignmentsListResponse = 0;
api.BillingAssignmentsListResponse buildBillingAssignmentsListResponse() {
final o = api.BillingAssignmentsListResponse();
buildCounterBillingAssignmentsListResponse++;
if (buildCounterBillingAssignmentsListResponse < 3) {
o.billingAssignments = buildUnnamed18();
o.kind = 'foo';
}
buildCounterBillingAssignmentsListResponse--;
return o;
}
void checkBillingAssignmentsListResponse(api.BillingAssignmentsListResponse o) {
buildCounterBillingAssignmentsListResponse++;
if (buildCounterBillingAssignmentsListResponse < 3) {
checkUnnamed18(o.billingAssignments!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterBillingAssignmentsListResponse--;
}
core.int buildCounterBillingProfile = 0;
api.BillingProfile buildBillingProfile() {
final o = api.BillingProfile();
buildCounterBillingProfile++;
if (buildCounterBillingProfile < 3) {
o.consolidatedInvoice = true;
o.countryCode = 'foo';
o.currencyCode = 'foo';
o.id = 'foo';
o.invoiceLevel = 'foo';
o.isDefault = true;
o.kind = 'foo';
o.name = 'foo';
o.paymentsAccountId = 'foo';
o.paymentsCustomerId = 'foo';
o.purchaseOrder = 'foo';
o.secondaryPaymentsCustomerId = 'foo';
o.status = 'foo';
}
buildCounterBillingProfile--;
return o;
}
void checkBillingProfile(api.BillingProfile o) {
buildCounterBillingProfile++;
if (buildCounterBillingProfile < 3) {
unittest.expect(o.consolidatedInvoice!, unittest.isTrue);
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.currencyCode!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.invoiceLevel!,
unittest.equals('foo'),
);
unittest.expect(o.isDefault!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.paymentsAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.paymentsCustomerId!,
unittest.equals('foo'),
);
unittest.expect(
o.purchaseOrder!,
unittest.equals('foo'),
);
unittest.expect(
o.secondaryPaymentsCustomerId!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
}
buildCounterBillingProfile--;
}
core.List<api.BillingProfile> buildUnnamed19() => [
buildBillingProfile(),
buildBillingProfile(),
];
void checkUnnamed19(core.List<api.BillingProfile> o) {
unittest.expect(o, unittest.hasLength(2));
checkBillingProfile(o[0]);
checkBillingProfile(o[1]);
}
core.int buildCounterBillingProfilesListResponse = 0;
api.BillingProfilesListResponse buildBillingProfilesListResponse() {
final o = api.BillingProfilesListResponse();
buildCounterBillingProfilesListResponse++;
if (buildCounterBillingProfilesListResponse < 3) {
o.billingProfiles = buildUnnamed19();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterBillingProfilesListResponse--;
return o;
}
void checkBillingProfilesListResponse(api.BillingProfilesListResponse o) {
buildCounterBillingProfilesListResponse++;
if (buildCounterBillingProfilesListResponse < 3) {
checkUnnamed19(o.billingProfiles!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterBillingProfilesListResponse--;
}
core.List<api.BillingRateTieredRate> buildUnnamed20() => [
buildBillingRateTieredRate(),
buildBillingRateTieredRate(),
];
void checkUnnamed20(core.List<api.BillingRateTieredRate> o) {
unittest.expect(o, unittest.hasLength(2));
checkBillingRateTieredRate(o[0]);
checkBillingRateTieredRate(o[1]);
}
core.int buildCounterBillingRate = 0;
api.BillingRate buildBillingRate() {
final o = api.BillingRate();
buildCounterBillingRate++;
if (buildCounterBillingRate < 3) {
o.currencyCode = 'foo';
o.endDate = 'foo';
o.id = 'foo';
o.name = 'foo';
o.rateInMicros = 'foo';
o.startDate = 'foo';
o.tieredRates = buildUnnamed20();
o.type = 'foo';
o.unitOfMeasure = 'foo';
}
buildCounterBillingRate--;
return o;
}
void checkBillingRate(api.BillingRate o) {
buildCounterBillingRate++;
if (buildCounterBillingRate < 3) {
unittest.expect(
o.currencyCode!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.rateInMicros!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals('foo'),
);
checkUnnamed20(o.tieredRates!);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.unitOfMeasure!,
unittest.equals('foo'),
);
}
buildCounterBillingRate--;
}
core.int buildCounterBillingRateTieredRate = 0;
api.BillingRateTieredRate buildBillingRateTieredRate() {
final o = api.BillingRateTieredRate();
buildCounterBillingRateTieredRate++;
if (buildCounterBillingRateTieredRate < 3) {
o.highValue = 'foo';
o.lowValue = 'foo';
o.rateInMicros = 'foo';
}
buildCounterBillingRateTieredRate--;
return o;
}
void checkBillingRateTieredRate(api.BillingRateTieredRate o) {
buildCounterBillingRateTieredRate++;
if (buildCounterBillingRateTieredRate < 3) {
unittest.expect(
o.highValue!,
unittest.equals('foo'),
);
unittest.expect(
o.lowValue!,
unittest.equals('foo'),
);
unittest.expect(
o.rateInMicros!,
unittest.equals('foo'),
);
}
buildCounterBillingRateTieredRate--;
}
core.List<api.BillingRate> buildUnnamed21() => [
buildBillingRate(),
buildBillingRate(),
];
void checkUnnamed21(core.List<api.BillingRate> o) {
unittest.expect(o, unittest.hasLength(2));
checkBillingRate(o[0]);
checkBillingRate(o[1]);
}
core.int buildCounterBillingRatesListResponse = 0;
api.BillingRatesListResponse buildBillingRatesListResponse() {
final o = api.BillingRatesListResponse();
buildCounterBillingRatesListResponse++;
if (buildCounterBillingRatesListResponse < 3) {
o.billingRates = buildUnnamed21();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterBillingRatesListResponse--;
return o;
}
void checkBillingRatesListResponse(api.BillingRatesListResponse o) {
buildCounterBillingRatesListResponse++;
if (buildCounterBillingRatesListResponse < 3) {
checkUnnamed21(o.billingRates!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterBillingRatesListResponse--;
}
core.int buildCounterBrowser = 0;
api.Browser buildBrowser() {
final o = api.Browser();
buildCounterBrowser++;
if (buildCounterBrowser < 3) {
o.browserVersionId = 'foo';
o.dartId = 'foo';
o.kind = 'foo';
o.majorVersion = 'foo';
o.minorVersion = 'foo';
o.name = 'foo';
}
buildCounterBrowser--;
return o;
}
void checkBrowser(api.Browser o) {
buildCounterBrowser++;
if (buildCounterBrowser < 3) {
unittest.expect(
o.browserVersionId!,
unittest.equals('foo'),
);
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.majorVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.minorVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterBrowser--;
}
core.List<api.Browser> buildUnnamed22() => [
buildBrowser(),
buildBrowser(),
];
void checkUnnamed22(core.List<api.Browser> o) {
unittest.expect(o, unittest.hasLength(2));
checkBrowser(o[0]);
checkBrowser(o[1]);
}
core.int buildCounterBrowsersListResponse = 0;
api.BrowsersListResponse buildBrowsersListResponse() {
final o = api.BrowsersListResponse();
buildCounterBrowsersListResponse++;
if (buildCounterBrowsersListResponse < 3) {
o.browsers = buildUnnamed22();
o.kind = 'foo';
}
buildCounterBrowsersListResponse--;
return o;
}
void checkBrowsersListResponse(api.BrowsersListResponse o) {
buildCounterBrowsersListResponse++;
if (buildCounterBrowsersListResponse < 3) {
checkUnnamed22(o.browsers!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterBrowsersListResponse--;
}
core.List<api.CreativeOptimizationConfiguration> buildUnnamed23() => [
buildCreativeOptimizationConfiguration(),
buildCreativeOptimizationConfiguration(),
];
void checkUnnamed23(core.List<api.CreativeOptimizationConfiguration> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeOptimizationConfiguration(o[0]);
checkCreativeOptimizationConfiguration(o[1]);
}
core.List<api.AudienceSegmentGroup> buildUnnamed24() => [
buildAudienceSegmentGroup(),
buildAudienceSegmentGroup(),
];
void checkUnnamed24(core.List<api.AudienceSegmentGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkAudienceSegmentGroup(o[0]);
checkAudienceSegmentGroup(o[1]);
}
core.List<core.String> buildUnnamed25() => [
'foo',
'foo',
];
void checkUnnamed25(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.EventTagOverride> buildUnnamed26() => [
buildEventTagOverride(),
buildEventTagOverride(),
];
void checkUnnamed26(core.List<api.EventTagOverride> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventTagOverride(o[0]);
checkEventTagOverride(o[1]);
}
core.int buildCounterCampaign = 0;
api.Campaign buildCampaign() {
final o = api.Campaign();
buildCounterCampaign++;
if (buildCounterCampaign < 3) {
o.accountId = 'foo';
o.adBlockingConfiguration = buildAdBlockingConfiguration();
o.additionalCreativeOptimizationConfigurations = buildUnnamed23();
o.advertiserGroupId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.archived = true;
o.audienceSegmentGroups = buildUnnamed24();
o.billingInvoiceCode = 'foo';
o.clickThroughUrlSuffixProperties = buildClickThroughUrlSuffixProperties();
o.comment = 'foo';
o.createInfo = buildLastModifiedInfo();
o.creativeGroupIds = buildUnnamed25();
o.creativeOptimizationConfiguration =
buildCreativeOptimizationConfiguration();
o.defaultClickThroughEventTagProperties =
buildDefaultClickThroughEventTagProperties();
o.defaultLandingPageId = 'foo';
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.eventTagOverrides = buildUnnamed26();
o.externalId = 'foo';
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.measurementPartnerLink = buildMeasurementPartnerCampaignLink();
o.name = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.subaccountId = 'foo';
}
buildCounterCampaign--;
return o;
}
void checkCampaign(api.Campaign o) {
buildCounterCampaign++;
if (buildCounterCampaign < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
checkAdBlockingConfiguration(o.adBlockingConfiguration!);
checkUnnamed23(o.additionalCreativeOptimizationConfigurations!);
unittest.expect(
o.advertiserGroupId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(o.archived!, unittest.isTrue);
checkUnnamed24(o.audienceSegmentGroups!);
unittest.expect(
o.billingInvoiceCode!,
unittest.equals('foo'),
);
checkClickThroughUrlSuffixProperties(o.clickThroughUrlSuffixProperties!);
unittest.expect(
o.comment!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.createInfo!);
checkUnnamed25(o.creativeGroupIds!);
checkCreativeOptimizationConfiguration(
o.creativeOptimizationConfiguration!);
checkDefaultClickThroughEventTagProperties(
o.defaultClickThroughEventTagProperties!);
unittest.expect(
o.defaultLandingPageId!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
checkUnnamed26(o.eventTagOverrides!);
unittest.expect(
o.externalId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
checkMeasurementPartnerCampaignLink(o.measurementPartnerLink!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterCampaign--;
}
core.int buildCounterCampaignCreativeAssociation = 0;
api.CampaignCreativeAssociation buildCampaignCreativeAssociation() {
final o = api.CampaignCreativeAssociation();
buildCounterCampaignCreativeAssociation++;
if (buildCounterCampaignCreativeAssociation < 3) {
o.creativeId = 'foo';
o.kind = 'foo';
}
buildCounterCampaignCreativeAssociation--;
return o;
}
void checkCampaignCreativeAssociation(api.CampaignCreativeAssociation o) {
buildCounterCampaignCreativeAssociation++;
if (buildCounterCampaignCreativeAssociation < 3) {
unittest.expect(
o.creativeId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterCampaignCreativeAssociation--;
}
core.List<api.CampaignCreativeAssociation> buildUnnamed27() => [
buildCampaignCreativeAssociation(),
buildCampaignCreativeAssociation(),
];
void checkUnnamed27(core.List<api.CampaignCreativeAssociation> o) {
unittest.expect(o, unittest.hasLength(2));
checkCampaignCreativeAssociation(o[0]);
checkCampaignCreativeAssociation(o[1]);
}
core.int buildCounterCampaignCreativeAssociationsListResponse = 0;
api.CampaignCreativeAssociationsListResponse
buildCampaignCreativeAssociationsListResponse() {
final o = api.CampaignCreativeAssociationsListResponse();
buildCounterCampaignCreativeAssociationsListResponse++;
if (buildCounterCampaignCreativeAssociationsListResponse < 3) {
o.campaignCreativeAssociations = buildUnnamed27();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCampaignCreativeAssociationsListResponse--;
return o;
}
void checkCampaignCreativeAssociationsListResponse(
api.CampaignCreativeAssociationsListResponse o) {
buildCounterCampaignCreativeAssociationsListResponse++;
if (buildCounterCampaignCreativeAssociationsListResponse < 3) {
checkUnnamed27(o.campaignCreativeAssociations!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCampaignCreativeAssociationsListResponse--;
}
core.int buildCounterCampaignSummary = 0;
api.CampaignSummary buildCampaignSummary() {
final o = api.CampaignSummary();
buildCounterCampaignSummary++;
if (buildCounterCampaignSummary < 3) {
o.billingInvoiceCode = 'foo';
o.campaignId = 'foo';
o.preTaxAmountMicros = 'foo';
o.taxAmountMicros = 'foo';
o.totalAmountMicros = 'foo';
}
buildCounterCampaignSummary--;
return o;
}
void checkCampaignSummary(api.CampaignSummary o) {
buildCounterCampaignSummary++;
if (buildCounterCampaignSummary < 3) {
unittest.expect(
o.billingInvoiceCode!,
unittest.equals('foo'),
);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
unittest.expect(
o.preTaxAmountMicros!,
unittest.equals('foo'),
);
unittest.expect(
o.taxAmountMicros!,
unittest.equals('foo'),
);
unittest.expect(
o.totalAmountMicros!,
unittest.equals('foo'),
);
}
buildCounterCampaignSummary--;
}
core.List<api.Campaign> buildUnnamed28() => [
buildCampaign(),
buildCampaign(),
];
void checkUnnamed28(core.List<api.Campaign> o) {
unittest.expect(o, unittest.hasLength(2));
checkCampaign(o[0]);
checkCampaign(o[1]);
}
core.int buildCounterCampaignsListResponse = 0;
api.CampaignsListResponse buildCampaignsListResponse() {
final o = api.CampaignsListResponse();
buildCounterCampaignsListResponse++;
if (buildCounterCampaignsListResponse < 3) {
o.campaigns = buildUnnamed28();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCampaignsListResponse--;
return o;
}
void checkCampaignsListResponse(api.CampaignsListResponse o) {
buildCounterCampaignsListResponse++;
if (buildCounterCampaignsListResponse < 3) {
checkUnnamed28(o.campaigns!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCampaignsListResponse--;
}
core.int buildCounterChangeLog = 0;
api.ChangeLog buildChangeLog() {
final o = api.ChangeLog();
buildCounterChangeLog++;
if (buildCounterChangeLog < 3) {
o.accountId = 'foo';
o.action = 'foo';
o.changeTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.fieldName = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.newValue = 'foo';
o.objectId = 'foo';
o.objectType = 'foo';
o.oldValue = 'foo';
o.subaccountId = 'foo';
o.transactionId = 'foo';
o.userProfileId = 'foo';
o.userProfileName = 'foo';
}
buildCounterChangeLog--;
return o;
}
void checkChangeLog(api.ChangeLog o) {
buildCounterChangeLog++;
if (buildCounterChangeLog < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.action!,
unittest.equals('foo'),
);
unittest.expect(
o.changeTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.fieldName!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.newValue!,
unittest.equals('foo'),
);
unittest.expect(
o.objectId!,
unittest.equals('foo'),
);
unittest.expect(
o.objectType!,
unittest.equals('foo'),
);
unittest.expect(
o.oldValue!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.transactionId!,
unittest.equals('foo'),
);
unittest.expect(
o.userProfileId!,
unittest.equals('foo'),
);
unittest.expect(
o.userProfileName!,
unittest.equals('foo'),
);
}
buildCounterChangeLog--;
}
core.List<api.ChangeLog> buildUnnamed29() => [
buildChangeLog(),
buildChangeLog(),
];
void checkUnnamed29(core.List<api.ChangeLog> o) {
unittest.expect(o, unittest.hasLength(2));
checkChangeLog(o[0]);
checkChangeLog(o[1]);
}
core.int buildCounterChangeLogsListResponse = 0;
api.ChangeLogsListResponse buildChangeLogsListResponse() {
final o = api.ChangeLogsListResponse();
buildCounterChangeLogsListResponse++;
if (buildCounterChangeLogsListResponse < 3) {
o.changeLogs = buildUnnamed29();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterChangeLogsListResponse--;
return o;
}
void checkChangeLogsListResponse(api.ChangeLogsListResponse o) {
buildCounterChangeLogsListResponse++;
if (buildCounterChangeLogsListResponse < 3) {
checkUnnamed29(o.changeLogs!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterChangeLogsListResponse--;
}
core.List<api.ChannelGroupingRule> buildUnnamed30() => [
buildChannelGroupingRule(),
buildChannelGroupingRule(),
];
void checkUnnamed30(core.List<api.ChannelGroupingRule> o) {
unittest.expect(o, unittest.hasLength(2));
checkChannelGroupingRule(o[0]);
checkChannelGroupingRule(o[1]);
}
core.int buildCounterChannelGrouping = 0;
api.ChannelGrouping buildChannelGrouping() {
final o = api.ChannelGrouping();
buildCounterChannelGrouping++;
if (buildCounterChannelGrouping < 3) {
o.fallbackName = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.rules = buildUnnamed30();
}
buildCounterChannelGrouping--;
return o;
}
void checkChannelGrouping(api.ChannelGrouping o) {
buildCounterChannelGrouping++;
if (buildCounterChannelGrouping < 3) {
unittest.expect(
o.fallbackName!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed30(o.rules!);
}
buildCounterChannelGrouping--;
}
core.List<api.DisjunctiveMatchStatement> buildUnnamed31() => [
buildDisjunctiveMatchStatement(),
buildDisjunctiveMatchStatement(),
];
void checkUnnamed31(core.List<api.DisjunctiveMatchStatement> o) {
unittest.expect(o, unittest.hasLength(2));
checkDisjunctiveMatchStatement(o[0]);
checkDisjunctiveMatchStatement(o[1]);
}
core.int buildCounterChannelGroupingRule = 0;
api.ChannelGroupingRule buildChannelGroupingRule() {
final o = api.ChannelGroupingRule();
buildCounterChannelGroupingRule++;
if (buildCounterChannelGroupingRule < 3) {
o.disjunctiveMatchStatements = buildUnnamed31();
o.kind = 'foo';
o.name = 'foo';
}
buildCounterChannelGroupingRule--;
return o;
}
void checkChannelGroupingRule(api.ChannelGroupingRule o) {
buildCounterChannelGroupingRule++;
if (buildCounterChannelGroupingRule < 3) {
checkUnnamed31(o.disjunctiveMatchStatements!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterChannelGroupingRule--;
}
core.List<api.City> buildUnnamed32() => [
buildCity(),
buildCity(),
];
void checkUnnamed32(core.List<api.City> o) {
unittest.expect(o, unittest.hasLength(2));
checkCity(o[0]);
checkCity(o[1]);
}
core.int buildCounterCitiesListResponse = 0;
api.CitiesListResponse buildCitiesListResponse() {
final o = api.CitiesListResponse();
buildCounterCitiesListResponse++;
if (buildCounterCitiesListResponse < 3) {
o.cities = buildUnnamed32();
o.kind = 'foo';
}
buildCounterCitiesListResponse--;
return o;
}
void checkCitiesListResponse(api.CitiesListResponse o) {
buildCounterCitiesListResponse++;
if (buildCounterCitiesListResponse < 3) {
checkUnnamed32(o.cities!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterCitiesListResponse--;
}
core.int buildCounterCity = 0;
api.City buildCity() {
final o = api.City();
buildCounterCity++;
if (buildCounterCity < 3) {
o.countryCode = 'foo';
o.countryDartId = 'foo';
o.dartId = 'foo';
o.kind = 'foo';
o.metroCode = 'foo';
o.metroDmaId = 'foo';
o.name = 'foo';
o.regionCode = 'foo';
o.regionDartId = 'foo';
}
buildCounterCity--;
return o;
}
void checkCity(api.City o) {
buildCounterCity++;
if (buildCounterCity < 3) {
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.countryDartId!,
unittest.equals('foo'),
);
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.metroCode!,
unittest.equals('foo'),
);
unittest.expect(
o.metroDmaId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.regionCode!,
unittest.equals('foo'),
);
unittest.expect(
o.regionDartId!,
unittest.equals('foo'),
);
}
buildCounterCity--;
}
core.int buildCounterClickTag = 0;
api.ClickTag buildClickTag() {
final o = api.ClickTag();
buildCounterClickTag++;
if (buildCounterClickTag < 3) {
o.clickThroughUrl = buildCreativeClickThroughUrl();
o.eventName = 'foo';
o.name = 'foo';
}
buildCounterClickTag--;
return o;
}
void checkClickTag(api.ClickTag o) {
buildCounterClickTag++;
if (buildCounterClickTag < 3) {
checkCreativeClickThroughUrl(o.clickThroughUrl!);
unittest.expect(
o.eventName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterClickTag--;
}
core.int buildCounterClickThroughUrl = 0;
api.ClickThroughUrl buildClickThroughUrl() {
final o = api.ClickThroughUrl();
buildCounterClickThroughUrl++;
if (buildCounterClickThroughUrl < 3) {
o.computedClickThroughUrl = 'foo';
o.customClickThroughUrl = 'foo';
o.defaultLandingPage = true;
o.landingPageId = 'foo';
}
buildCounterClickThroughUrl--;
return o;
}
void checkClickThroughUrl(api.ClickThroughUrl o) {
buildCounterClickThroughUrl++;
if (buildCounterClickThroughUrl < 3) {
unittest.expect(
o.computedClickThroughUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.customClickThroughUrl!,
unittest.equals('foo'),
);
unittest.expect(o.defaultLandingPage!, unittest.isTrue);
unittest.expect(
o.landingPageId!,
unittest.equals('foo'),
);
}
buildCounterClickThroughUrl--;
}
core.int buildCounterClickThroughUrlSuffixProperties = 0;
api.ClickThroughUrlSuffixProperties buildClickThroughUrlSuffixProperties() {
final o = api.ClickThroughUrlSuffixProperties();
buildCounterClickThroughUrlSuffixProperties++;
if (buildCounterClickThroughUrlSuffixProperties < 3) {
o.clickThroughUrlSuffix = 'foo';
o.overrideInheritedSuffix = true;
}
buildCounterClickThroughUrlSuffixProperties--;
return o;
}
void checkClickThroughUrlSuffixProperties(
api.ClickThroughUrlSuffixProperties o) {
buildCounterClickThroughUrlSuffixProperties++;
if (buildCounterClickThroughUrlSuffixProperties < 3) {
unittest.expect(
o.clickThroughUrlSuffix!,
unittest.equals('foo'),
);
unittest.expect(o.overrideInheritedSuffix!, unittest.isTrue);
}
buildCounterClickThroughUrlSuffixProperties--;
}
core.int buildCounterCompanionClickThroughOverride = 0;
api.CompanionClickThroughOverride buildCompanionClickThroughOverride() {
final o = api.CompanionClickThroughOverride();
buildCounterCompanionClickThroughOverride++;
if (buildCounterCompanionClickThroughOverride < 3) {
o.clickThroughUrl = buildClickThroughUrl();
o.creativeId = 'foo';
}
buildCounterCompanionClickThroughOverride--;
return o;
}
void checkCompanionClickThroughOverride(api.CompanionClickThroughOverride o) {
buildCounterCompanionClickThroughOverride++;
if (buildCounterCompanionClickThroughOverride < 3) {
checkClickThroughUrl(o.clickThroughUrl!);
unittest.expect(
o.creativeId!,
unittest.equals('foo'),
);
}
buildCounterCompanionClickThroughOverride--;
}
core.List<api.Size> buildUnnamed33() => [
buildSize(),
buildSize(),
];
void checkUnnamed33(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.int buildCounterCompanionSetting = 0;
api.CompanionSetting buildCompanionSetting() {
final o = api.CompanionSetting();
buildCounterCompanionSetting++;
if (buildCounterCompanionSetting < 3) {
o.companionsDisabled = true;
o.enabledSizes = buildUnnamed33();
o.imageOnly = true;
o.kind = 'foo';
}
buildCounterCompanionSetting--;
return o;
}
void checkCompanionSetting(api.CompanionSetting o) {
buildCounterCompanionSetting++;
if (buildCounterCompanionSetting < 3) {
unittest.expect(o.companionsDisabled!, unittest.isTrue);
checkUnnamed33(o.enabledSizes!);
unittest.expect(o.imageOnly!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterCompanionSetting--;
}
core.int buildCounterCompatibleFields = 0;
api.CompatibleFields buildCompatibleFields() {
final o = api.CompatibleFields();
buildCounterCompatibleFields++;
if (buildCounterCompatibleFields < 3) {
o.crossDimensionReachReportCompatibleFields =
buildCrossDimensionReachReportCompatibleFields();
o.floodlightReportCompatibleFields =
buildFloodlightReportCompatibleFields();
o.kind = 'foo';
o.pathAttributionReportCompatibleFields = buildPathReportCompatibleFields();
o.pathReportCompatibleFields = buildPathReportCompatibleFields();
o.pathToConversionReportCompatibleFields =
buildPathToConversionReportCompatibleFields();
o.reachReportCompatibleFields = buildReachReportCompatibleFields();
o.reportCompatibleFields = buildReportCompatibleFields();
}
buildCounterCompatibleFields--;
return o;
}
void checkCompatibleFields(api.CompatibleFields o) {
buildCounterCompatibleFields++;
if (buildCounterCompatibleFields < 3) {
checkCrossDimensionReachReportCompatibleFields(
o.crossDimensionReachReportCompatibleFields!);
checkFloodlightReportCompatibleFields(o.floodlightReportCompatibleFields!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkPathReportCompatibleFields(o.pathAttributionReportCompatibleFields!);
checkPathReportCompatibleFields(o.pathReportCompatibleFields!);
checkPathToConversionReportCompatibleFields(
o.pathToConversionReportCompatibleFields!);
checkReachReportCompatibleFields(o.reachReportCompatibleFields!);
checkReportCompatibleFields(o.reportCompatibleFields!);
}
buildCounterCompatibleFields--;
}
core.int buildCounterConnectionType = 0;
api.ConnectionType buildConnectionType() {
final o = api.ConnectionType();
buildCounterConnectionType++;
if (buildCounterConnectionType < 3) {
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterConnectionType--;
return o;
}
void checkConnectionType(api.ConnectionType o) {
buildCounterConnectionType++;
if (buildCounterConnectionType < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterConnectionType--;
}
core.List<api.ConnectionType> buildUnnamed34() => [
buildConnectionType(),
buildConnectionType(),
];
void checkUnnamed34(core.List<api.ConnectionType> o) {
unittest.expect(o, unittest.hasLength(2));
checkConnectionType(o[0]);
checkConnectionType(o[1]);
}
core.int buildCounterConnectionTypesListResponse = 0;
api.ConnectionTypesListResponse buildConnectionTypesListResponse() {
final o = api.ConnectionTypesListResponse();
buildCounterConnectionTypesListResponse++;
if (buildCounterConnectionTypesListResponse < 3) {
o.connectionTypes = buildUnnamed34();
o.kind = 'foo';
}
buildCounterConnectionTypesListResponse--;
return o;
}
void checkConnectionTypesListResponse(api.ConnectionTypesListResponse o) {
buildCounterConnectionTypesListResponse++;
if (buildCounterConnectionTypesListResponse < 3) {
checkUnnamed34(o.connectionTypes!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterConnectionTypesListResponse--;
}
core.List<api.ContentCategory> buildUnnamed35() => [
buildContentCategory(),
buildContentCategory(),
];
void checkUnnamed35(core.List<api.ContentCategory> o) {
unittest.expect(o, unittest.hasLength(2));
checkContentCategory(o[0]);
checkContentCategory(o[1]);
}
core.int buildCounterContentCategoriesListResponse = 0;
api.ContentCategoriesListResponse buildContentCategoriesListResponse() {
final o = api.ContentCategoriesListResponse();
buildCounterContentCategoriesListResponse++;
if (buildCounterContentCategoriesListResponse < 3) {
o.contentCategories = buildUnnamed35();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterContentCategoriesListResponse--;
return o;
}
void checkContentCategoriesListResponse(api.ContentCategoriesListResponse o) {
buildCounterContentCategoriesListResponse++;
if (buildCounterContentCategoriesListResponse < 3) {
checkUnnamed35(o.contentCategories!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterContentCategoriesListResponse--;
}
core.int buildCounterContentCategory = 0;
api.ContentCategory buildContentCategory() {
final o = api.ContentCategory();
buildCounterContentCategory++;
if (buildCounterContentCategory < 3) {
o.accountId = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterContentCategory--;
return o;
}
void checkContentCategory(api.ContentCategory o) {
buildCounterContentCategory++;
if (buildCounterContentCategory < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterContentCategory--;
}
core.List<api.CustomFloodlightVariable> buildUnnamed36() => [
buildCustomFloodlightVariable(),
buildCustomFloodlightVariable(),
];
void checkUnnamed36(core.List<api.CustomFloodlightVariable> o) {
unittest.expect(o, unittest.hasLength(2));
checkCustomFloodlightVariable(o[0]);
checkCustomFloodlightVariable(o[1]);
}
core.List<core.String> buildUnnamed37() => [
'foo',
'foo',
];
void checkUnnamed37(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.UserIdentifier> buildUnnamed38() => [
buildUserIdentifier(),
buildUserIdentifier(),
];
void checkUnnamed38(core.List<api.UserIdentifier> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserIdentifier(o[0]);
checkUserIdentifier(o[1]);
}
core.int buildCounterConversion = 0;
api.Conversion buildConversion() {
final o = api.Conversion();
buildCounterConversion++;
if (buildCounterConversion < 3) {
o.childDirectedTreatment = true;
o.customVariables = buildUnnamed36();
o.dclid = 'foo';
o.encryptedUserId = 'foo';
o.encryptedUserIdCandidates = buildUnnamed37();
o.floodlightActivityId = 'foo';
o.floodlightConfigurationId = 'foo';
o.gclid = 'foo';
o.impressionId = 'foo';
o.kind = 'foo';
o.limitAdTracking = true;
o.matchId = 'foo';
o.mobileDeviceId = 'foo';
o.nonPersonalizedAd = true;
o.ordinal = 'foo';
o.quantity = 'foo';
o.timestampMicros = 'foo';
o.treatmentForUnderage = true;
o.userIdentifiers = buildUnnamed38();
o.value = 42.0;
}
buildCounterConversion--;
return o;
}
void checkConversion(api.Conversion o) {
buildCounterConversion++;
if (buildCounterConversion < 3) {
unittest.expect(o.childDirectedTreatment!, unittest.isTrue);
checkUnnamed36(o.customVariables!);
unittest.expect(
o.dclid!,
unittest.equals('foo'),
);
unittest.expect(
o.encryptedUserId!,
unittest.equals('foo'),
);
checkUnnamed37(o.encryptedUserIdCandidates!);
unittest.expect(
o.floodlightActivityId!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightConfigurationId!,
unittest.equals('foo'),
);
unittest.expect(
o.gclid!,
unittest.equals('foo'),
);
unittest.expect(
o.impressionId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.limitAdTracking!, unittest.isTrue);
unittest.expect(
o.matchId!,
unittest.equals('foo'),
);
unittest.expect(
o.mobileDeviceId!,
unittest.equals('foo'),
);
unittest.expect(o.nonPersonalizedAd!, unittest.isTrue);
unittest.expect(
o.ordinal!,
unittest.equals('foo'),
);
unittest.expect(
o.quantity!,
unittest.equals('foo'),
);
unittest.expect(
o.timestampMicros!,
unittest.equals('foo'),
);
unittest.expect(o.treatmentForUnderage!, unittest.isTrue);
checkUnnamed38(o.userIdentifiers!);
unittest.expect(
o.value!,
unittest.equals(42.0),
);
}
buildCounterConversion--;
}
core.int buildCounterConversionError = 0;
api.ConversionError buildConversionError() {
final o = api.ConversionError();
buildCounterConversionError++;
if (buildCounterConversionError < 3) {
o.code = 'foo';
o.kind = 'foo';
o.message = 'foo';
}
buildCounterConversionError--;
return o;
}
void checkConversionError(api.ConversionError o) {
buildCounterConversionError++;
if (buildCounterConversionError < 3) {
unittest.expect(
o.code!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterConversionError--;
}
core.List<api.ConversionError> buildUnnamed39() => [
buildConversionError(),
buildConversionError(),
];
void checkUnnamed39(core.List<api.ConversionError> o) {
unittest.expect(o, unittest.hasLength(2));
checkConversionError(o[0]);
checkConversionError(o[1]);
}
core.int buildCounterConversionStatus = 0;
api.ConversionStatus buildConversionStatus() {
final o = api.ConversionStatus();
buildCounterConversionStatus++;
if (buildCounterConversionStatus < 3) {
o.conversion = buildConversion();
o.errors = buildUnnamed39();
o.kind = 'foo';
}
buildCounterConversionStatus--;
return o;
}
void checkConversionStatus(api.ConversionStatus o) {
buildCounterConversionStatus++;
if (buildCounterConversionStatus < 3) {
checkConversion(o.conversion!);
checkUnnamed39(o.errors!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterConversionStatus--;
}
core.List<api.Conversion> buildUnnamed40() => [
buildConversion(),
buildConversion(),
];
void checkUnnamed40(core.List<api.Conversion> o) {
unittest.expect(o, unittest.hasLength(2));
checkConversion(o[0]);
checkConversion(o[1]);
}
core.int buildCounterConversionsBatchInsertRequest = 0;
api.ConversionsBatchInsertRequest buildConversionsBatchInsertRequest() {
final o = api.ConversionsBatchInsertRequest();
buildCounterConversionsBatchInsertRequest++;
if (buildCounterConversionsBatchInsertRequest < 3) {
o.conversions = buildUnnamed40();
o.encryptionInfo = buildEncryptionInfo();
o.kind = 'foo';
}
buildCounterConversionsBatchInsertRequest--;
return o;
}
void checkConversionsBatchInsertRequest(api.ConversionsBatchInsertRequest o) {
buildCounterConversionsBatchInsertRequest++;
if (buildCounterConversionsBatchInsertRequest < 3) {
checkUnnamed40(o.conversions!);
checkEncryptionInfo(o.encryptionInfo!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterConversionsBatchInsertRequest--;
}
core.List<api.ConversionStatus> buildUnnamed41() => [
buildConversionStatus(),
buildConversionStatus(),
];
void checkUnnamed41(core.List<api.ConversionStatus> o) {
unittest.expect(o, unittest.hasLength(2));
checkConversionStatus(o[0]);
checkConversionStatus(o[1]);
}
core.int buildCounterConversionsBatchInsertResponse = 0;
api.ConversionsBatchInsertResponse buildConversionsBatchInsertResponse() {
final o = api.ConversionsBatchInsertResponse();
buildCounterConversionsBatchInsertResponse++;
if (buildCounterConversionsBatchInsertResponse < 3) {
o.hasFailures = true;
o.kind = 'foo';
o.status = buildUnnamed41();
}
buildCounterConversionsBatchInsertResponse--;
return o;
}
void checkConversionsBatchInsertResponse(api.ConversionsBatchInsertResponse o) {
buildCounterConversionsBatchInsertResponse++;
if (buildCounterConversionsBatchInsertResponse < 3) {
unittest.expect(o.hasFailures!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed41(o.status!);
}
buildCounterConversionsBatchInsertResponse--;
}
core.List<api.Conversion> buildUnnamed42() => [
buildConversion(),
buildConversion(),
];
void checkUnnamed42(core.List<api.Conversion> o) {
unittest.expect(o, unittest.hasLength(2));
checkConversion(o[0]);
checkConversion(o[1]);
}
core.int buildCounterConversionsBatchUpdateRequest = 0;
api.ConversionsBatchUpdateRequest buildConversionsBatchUpdateRequest() {
final o = api.ConversionsBatchUpdateRequest();
buildCounterConversionsBatchUpdateRequest++;
if (buildCounterConversionsBatchUpdateRequest < 3) {
o.conversions = buildUnnamed42();
o.encryptionInfo = buildEncryptionInfo();
o.kind = 'foo';
}
buildCounterConversionsBatchUpdateRequest--;
return o;
}
void checkConversionsBatchUpdateRequest(api.ConversionsBatchUpdateRequest o) {
buildCounterConversionsBatchUpdateRequest++;
if (buildCounterConversionsBatchUpdateRequest < 3) {
checkUnnamed42(o.conversions!);
checkEncryptionInfo(o.encryptionInfo!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterConversionsBatchUpdateRequest--;
}
core.List<api.ConversionStatus> buildUnnamed43() => [
buildConversionStatus(),
buildConversionStatus(),
];
void checkUnnamed43(core.List<api.ConversionStatus> o) {
unittest.expect(o, unittest.hasLength(2));
checkConversionStatus(o[0]);
checkConversionStatus(o[1]);
}
core.int buildCounterConversionsBatchUpdateResponse = 0;
api.ConversionsBatchUpdateResponse buildConversionsBatchUpdateResponse() {
final o = api.ConversionsBatchUpdateResponse();
buildCounterConversionsBatchUpdateResponse++;
if (buildCounterConversionsBatchUpdateResponse < 3) {
o.hasFailures = true;
o.kind = 'foo';
o.status = buildUnnamed43();
}
buildCounterConversionsBatchUpdateResponse--;
return o;
}
void checkConversionsBatchUpdateResponse(api.ConversionsBatchUpdateResponse o) {
buildCounterConversionsBatchUpdateResponse++;
if (buildCounterConversionsBatchUpdateResponse < 3) {
unittest.expect(o.hasFailures!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed43(o.status!);
}
buildCounterConversionsBatchUpdateResponse--;
}
core.List<api.Country> buildUnnamed44() => [
buildCountry(),
buildCountry(),
];
void checkUnnamed44(core.List<api.Country> o) {
unittest.expect(o, unittest.hasLength(2));
checkCountry(o[0]);
checkCountry(o[1]);
}
core.int buildCounterCountriesListResponse = 0;
api.CountriesListResponse buildCountriesListResponse() {
final o = api.CountriesListResponse();
buildCounterCountriesListResponse++;
if (buildCounterCountriesListResponse < 3) {
o.countries = buildUnnamed44();
o.kind = 'foo';
}
buildCounterCountriesListResponse--;
return o;
}
void checkCountriesListResponse(api.CountriesListResponse o) {
buildCounterCountriesListResponse++;
if (buildCounterCountriesListResponse < 3) {
checkUnnamed44(o.countries!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterCountriesListResponse--;
}
core.int buildCounterCountry = 0;
api.Country buildCountry() {
final o = api.Country();
buildCounterCountry++;
if (buildCounterCountry < 3) {
o.countryCode = 'foo';
o.dartId = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.sslEnabled = true;
}
buildCounterCountry--;
return o;
}
void checkCountry(api.Country o) {
buildCounterCountry++;
if (buildCounterCountry < 3) {
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(o.sslEnabled!, unittest.isTrue);
}
buildCounterCountry--;
}
core.List<core.String> buildUnnamed45() => [
'foo',
'foo',
];
void checkUnnamed45(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.Size> buildUnnamed46() => [
buildSize(),
buildSize(),
];
void checkUnnamed46(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.List<core.String> buildUnnamed47() => [
'foo',
'foo',
];
void checkUnnamed47(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.ClickTag> buildUnnamed48() => [
buildClickTag(),
buildClickTag(),
];
void checkUnnamed48(core.List<api.ClickTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkClickTag(o[0]);
checkClickTag(o[1]);
}
core.List<core.String> buildUnnamed49() => [
'foo',
'foo',
];
void checkUnnamed49(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed50() => [
'foo',
'foo',
];
void checkUnnamed50(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.CreativeCustomEvent> buildUnnamed51() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed51(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.List<api.CreativeAsset> buildUnnamed52() => [
buildCreativeAsset(),
buildCreativeAsset(),
];
void checkUnnamed52(core.List<api.CreativeAsset> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeAsset(o[0]);
checkCreativeAsset(o[1]);
}
core.List<api.CreativeFieldAssignment> buildUnnamed53() => [
buildCreativeFieldAssignment(),
buildCreativeFieldAssignment(),
];
void checkUnnamed53(core.List<api.CreativeFieldAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeFieldAssignment(o[0]);
checkCreativeFieldAssignment(o[1]);
}
core.List<core.String> buildUnnamed54() => [
'foo',
'foo',
];
void checkUnnamed54(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.CreativeCustomEvent> buildUnnamed55() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed55(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.List<api.ThirdPartyTrackingUrl> buildUnnamed56() => [
buildThirdPartyTrackingUrl(),
buildThirdPartyTrackingUrl(),
];
void checkUnnamed56(core.List<api.ThirdPartyTrackingUrl> o) {
unittest.expect(o, unittest.hasLength(2));
checkThirdPartyTrackingUrl(o[0]);
checkThirdPartyTrackingUrl(o[1]);
}
core.List<api.CreativeCustomEvent> buildUnnamed57() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed57(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.int buildCounterCreative = 0;
api.Creative buildCreative() {
final o = api.Creative();
buildCounterCreative++;
if (buildCounterCreative < 3) {
o.accountId = 'foo';
o.active = true;
o.adParameters = 'foo';
o.adTagKeys = buildUnnamed45();
o.additionalSizes = buildUnnamed46();
o.advertiserId = 'foo';
o.allowScriptAccess = true;
o.archived = true;
o.artworkType = 'foo';
o.authoringSource = 'foo';
o.authoringTool = 'foo';
o.autoAdvanceImages = true;
o.backgroundColor = 'foo';
o.backupImageClickThroughUrl = buildCreativeClickThroughUrl();
o.backupImageFeatures = buildUnnamed47();
o.backupImageReportingLabel = 'foo';
o.backupImageTargetWindow = buildTargetWindow();
o.clickTags = buildUnnamed48();
o.commercialId = 'foo';
o.companionCreatives = buildUnnamed49();
o.compatibility = buildUnnamed50();
o.convertFlashToHtml5 = true;
o.counterCustomEvents = buildUnnamed51();
o.creativeAssetSelection = buildCreativeAssetSelection();
o.creativeAssets = buildUnnamed52();
o.creativeFieldAssignments = buildUnnamed53();
o.customKeyValues = buildUnnamed54();
o.dynamicAssetSelection = true;
o.exitCustomEvents = buildUnnamed55();
o.fsCommand = buildFsCommand();
o.htmlCode = 'foo';
o.htmlCodeLocked = true;
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.latestTraffickedCreativeId = 'foo';
o.mediaDescription = 'foo';
o.mediaDuration = 42.0;
o.name = 'foo';
o.obaIcon = buildObaIcon();
o.overrideCss = 'foo';
o.progressOffset = buildVideoOffset();
o.redirectUrl = 'foo';
o.renderingId = 'foo';
o.renderingIdDimensionValue = buildDimensionValue();
o.requiredFlashPluginVersion = 'foo';
o.requiredFlashVersion = 42;
o.size = buildSize();
o.skipOffset = buildVideoOffset();
o.skippable = true;
o.sslCompliant = true;
o.sslOverride = true;
o.studioAdvertiserId = 'foo';
o.studioCreativeId = 'foo';
o.studioTraffickedCreativeId = 'foo';
o.subaccountId = 'foo';
o.thirdPartyBackupImageImpressionsUrl = 'foo';
o.thirdPartyRichMediaImpressionsUrl = 'foo';
o.thirdPartyUrls = buildUnnamed56();
o.timerCustomEvents = buildUnnamed57();
o.totalFileSize = 'foo';
o.type = 'foo';
o.universalAdId = buildUniversalAdId();
o.version = 42;
}
buildCounterCreative--;
return o;
}
void checkCreative(api.Creative o) {
buildCounterCreative++;
if (buildCounterCreative < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.adParameters!,
unittest.equals('foo'),
);
checkUnnamed45(o.adTagKeys!);
checkUnnamed46(o.additionalSizes!);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
unittest.expect(o.allowScriptAccess!, unittest.isTrue);
unittest.expect(o.archived!, unittest.isTrue);
unittest.expect(
o.artworkType!,
unittest.equals('foo'),
);
unittest.expect(
o.authoringSource!,
unittest.equals('foo'),
);
unittest.expect(
o.authoringTool!,
unittest.equals('foo'),
);
unittest.expect(o.autoAdvanceImages!, unittest.isTrue);
unittest.expect(
o.backgroundColor!,
unittest.equals('foo'),
);
checkCreativeClickThroughUrl(o.backupImageClickThroughUrl!);
checkUnnamed47(o.backupImageFeatures!);
unittest.expect(
o.backupImageReportingLabel!,
unittest.equals('foo'),
);
checkTargetWindow(o.backupImageTargetWindow!);
checkUnnamed48(o.clickTags!);
unittest.expect(
o.commercialId!,
unittest.equals('foo'),
);
checkUnnamed49(o.companionCreatives!);
checkUnnamed50(o.compatibility!);
unittest.expect(o.convertFlashToHtml5!, unittest.isTrue);
checkUnnamed51(o.counterCustomEvents!);
checkCreativeAssetSelection(o.creativeAssetSelection!);
checkUnnamed52(o.creativeAssets!);
checkUnnamed53(o.creativeFieldAssignments!);
checkUnnamed54(o.customKeyValues!);
unittest.expect(o.dynamicAssetSelection!, unittest.isTrue);
checkUnnamed55(o.exitCustomEvents!);
checkFsCommand(o.fsCommand!);
unittest.expect(
o.htmlCode!,
unittest.equals('foo'),
);
unittest.expect(o.htmlCodeLocked!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.latestTraffickedCreativeId!,
unittest.equals('foo'),
);
unittest.expect(
o.mediaDescription!,
unittest.equals('foo'),
);
unittest.expect(
o.mediaDuration!,
unittest.equals(42.0),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkObaIcon(o.obaIcon!);
unittest.expect(
o.overrideCss!,
unittest.equals('foo'),
);
checkVideoOffset(o.progressOffset!);
unittest.expect(
o.redirectUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.renderingId!,
unittest.equals('foo'),
);
checkDimensionValue(o.renderingIdDimensionValue!);
unittest.expect(
o.requiredFlashPluginVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.requiredFlashVersion!,
unittest.equals(42),
);
checkSize(o.size!);
checkVideoOffset(o.skipOffset!);
unittest.expect(o.skippable!, unittest.isTrue);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(o.sslOverride!, unittest.isTrue);
unittest.expect(
o.studioAdvertiserId!,
unittest.equals('foo'),
);
unittest.expect(
o.studioCreativeId!,
unittest.equals('foo'),
);
unittest.expect(
o.studioTraffickedCreativeId!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.thirdPartyBackupImageImpressionsUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.thirdPartyRichMediaImpressionsUrl!,
unittest.equals('foo'),
);
checkUnnamed56(o.thirdPartyUrls!);
checkUnnamed57(o.timerCustomEvents!);
unittest.expect(
o.totalFileSize!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
checkUniversalAdId(o.universalAdId!);
unittest.expect(
o.version!,
unittest.equals(42),
);
}
buildCounterCreative--;
}
core.List<api.Size> buildUnnamed58() => [
buildSize(),
buildSize(),
];
void checkUnnamed58(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.List<core.String> buildUnnamed59() => [
'foo',
'foo',
];
void checkUnnamed59(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed60() => [
'foo',
'foo',
];
void checkUnnamed60(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCreativeAsset = 0;
api.CreativeAsset buildCreativeAsset() {
final o = api.CreativeAsset();
buildCounterCreativeAsset++;
if (buildCounterCreativeAsset < 3) {
o.actionScript3 = true;
o.active = true;
o.additionalSizes = buildUnnamed58();
o.alignment = 'foo';
o.artworkType = 'foo';
o.assetIdentifier = buildCreativeAssetId();
o.audioBitRate = 42;
o.audioSampleRate = 42;
o.backupImageExit = buildCreativeCustomEvent();
o.bitRate = 42;
o.childAssetType = 'foo';
o.collapsedSize = buildSize();
o.companionCreativeIds = buildUnnamed59();
o.customStartTimeValue = 42;
o.detectedFeatures = buildUnnamed60();
o.displayType = 'foo';
o.duration = 42;
o.durationType = 'foo';
o.expandedDimension = buildSize();
o.fileSize = 'foo';
o.flashVersion = 42;
o.frameRate = 42.0;
o.hideFlashObjects = true;
o.hideSelectionBoxes = true;
o.horizontallyLocked = true;
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.mediaDuration = 42.0;
o.mimeType = 'foo';
o.offset = buildOffsetPosition();
o.orientation = 'foo';
o.originalBackup = true;
o.politeLoad = true;
o.position = buildOffsetPosition();
o.positionLeftUnit = 'foo';
o.positionTopUnit = 'foo';
o.progressiveServingUrl = 'foo';
o.pushdown = true;
o.pushdownDuration = 42.0;
o.role = 'foo';
o.size = buildSize();
o.sslCompliant = true;
o.startTimeType = 'foo';
o.streamingServingUrl = 'foo';
o.transparency = true;
o.verticallyLocked = true;
o.windowMode = 'foo';
o.zIndex = 42;
o.zipFilename = 'foo';
o.zipFilesize = 'foo';
}
buildCounterCreativeAsset--;
return o;
}
void checkCreativeAsset(api.CreativeAsset o) {
buildCounterCreativeAsset++;
if (buildCounterCreativeAsset < 3) {
unittest.expect(o.actionScript3!, unittest.isTrue);
unittest.expect(o.active!, unittest.isTrue);
checkUnnamed58(o.additionalSizes!);
unittest.expect(
o.alignment!,
unittest.equals('foo'),
);
unittest.expect(
o.artworkType!,
unittest.equals('foo'),
);
checkCreativeAssetId(o.assetIdentifier!);
unittest.expect(
o.audioBitRate!,
unittest.equals(42),
);
unittest.expect(
o.audioSampleRate!,
unittest.equals(42),
);
checkCreativeCustomEvent(o.backupImageExit!);
unittest.expect(
o.bitRate!,
unittest.equals(42),
);
unittest.expect(
o.childAssetType!,
unittest.equals('foo'),
);
checkSize(o.collapsedSize!);
checkUnnamed59(o.companionCreativeIds!);
unittest.expect(
o.customStartTimeValue!,
unittest.equals(42),
);
checkUnnamed60(o.detectedFeatures!);
unittest.expect(
o.displayType!,
unittest.equals('foo'),
);
unittest.expect(
o.duration!,
unittest.equals(42),
);
unittest.expect(
o.durationType!,
unittest.equals('foo'),
);
checkSize(o.expandedDimension!);
unittest.expect(
o.fileSize!,
unittest.equals('foo'),
);
unittest.expect(
o.flashVersion!,
unittest.equals(42),
);
unittest.expect(
o.frameRate!,
unittest.equals(42.0),
);
unittest.expect(o.hideFlashObjects!, unittest.isTrue);
unittest.expect(o.hideSelectionBoxes!, unittest.isTrue);
unittest.expect(o.horizontallyLocked!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.mediaDuration!,
unittest.equals(42.0),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
checkOffsetPosition(o.offset!);
unittest.expect(
o.orientation!,
unittest.equals('foo'),
);
unittest.expect(o.originalBackup!, unittest.isTrue);
unittest.expect(o.politeLoad!, unittest.isTrue);
checkOffsetPosition(o.position!);
unittest.expect(
o.positionLeftUnit!,
unittest.equals('foo'),
);
unittest.expect(
o.positionTopUnit!,
unittest.equals('foo'),
);
unittest.expect(
o.progressiveServingUrl!,
unittest.equals('foo'),
);
unittest.expect(o.pushdown!, unittest.isTrue);
unittest.expect(
o.pushdownDuration!,
unittest.equals(42.0),
);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
checkSize(o.size!);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(
o.startTimeType!,
unittest.equals('foo'),
);
unittest.expect(
o.streamingServingUrl!,
unittest.equals('foo'),
);
unittest.expect(o.transparency!, unittest.isTrue);
unittest.expect(o.verticallyLocked!, unittest.isTrue);
unittest.expect(
o.windowMode!,
unittest.equals('foo'),
);
unittest.expect(
o.zIndex!,
unittest.equals(42),
);
unittest.expect(
o.zipFilename!,
unittest.equals('foo'),
);
unittest.expect(
o.zipFilesize!,
unittest.equals('foo'),
);
}
buildCounterCreativeAsset--;
}
core.int buildCounterCreativeAssetId = 0;
api.CreativeAssetId buildCreativeAssetId() {
final o = api.CreativeAssetId();
buildCounterCreativeAssetId++;
if (buildCounterCreativeAssetId < 3) {
o.name = 'foo';
o.type = 'foo';
}
buildCounterCreativeAssetId--;
return o;
}
void checkCreativeAssetId(api.CreativeAssetId o) {
buildCounterCreativeAssetId++;
if (buildCounterCreativeAssetId < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterCreativeAssetId--;
}
core.List<api.ClickTag> buildUnnamed61() => [
buildClickTag(),
buildClickTag(),
];
void checkUnnamed61(core.List<api.ClickTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkClickTag(o[0]);
checkClickTag(o[1]);
}
core.List<api.CreativeCustomEvent> buildUnnamed62() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed62(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.List<core.String> buildUnnamed63() => [
'foo',
'foo',
];
void checkUnnamed63(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.CreativeCustomEvent> buildUnnamed64() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed64(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.List<api.CreativeCustomEvent> buildUnnamed65() => [
buildCreativeCustomEvent(),
buildCreativeCustomEvent(),
];
void checkUnnamed65(core.List<api.CreativeCustomEvent> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeCustomEvent(o[0]);
checkCreativeCustomEvent(o[1]);
}
core.List<core.String> buildUnnamed66() => [
'foo',
'foo',
];
void checkUnnamed66(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCreativeAssetMetadata = 0;
api.CreativeAssetMetadata buildCreativeAssetMetadata() {
final o = api.CreativeAssetMetadata();
buildCounterCreativeAssetMetadata++;
if (buildCounterCreativeAssetMetadata < 3) {
o.assetIdentifier = buildCreativeAssetId();
o.clickTags = buildUnnamed61();
o.counterCustomEvents = buildUnnamed62();
o.detectedFeatures = buildUnnamed63();
o.exitCustomEvents = buildUnnamed64();
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.richMedia = true;
o.timerCustomEvents = buildUnnamed65();
o.warnedValidationRules = buildUnnamed66();
}
buildCounterCreativeAssetMetadata--;
return o;
}
void checkCreativeAssetMetadata(api.CreativeAssetMetadata o) {
buildCounterCreativeAssetMetadata++;
if (buildCounterCreativeAssetMetadata < 3) {
checkCreativeAssetId(o.assetIdentifier!);
checkUnnamed61(o.clickTags!);
checkUnnamed62(o.counterCustomEvents!);
checkUnnamed63(o.detectedFeatures!);
checkUnnamed64(o.exitCustomEvents!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.richMedia!, unittest.isTrue);
checkUnnamed65(o.timerCustomEvents!);
checkUnnamed66(o.warnedValidationRules!);
}
buildCounterCreativeAssetMetadata--;
}
core.List<api.Rule> buildUnnamed67() => [
buildRule(),
buildRule(),
];
void checkUnnamed67(core.List<api.Rule> o) {
unittest.expect(o, unittest.hasLength(2));
checkRule(o[0]);
checkRule(o[1]);
}
core.int buildCounterCreativeAssetSelection = 0;
api.CreativeAssetSelection buildCreativeAssetSelection() {
final o = api.CreativeAssetSelection();
buildCounterCreativeAssetSelection++;
if (buildCounterCreativeAssetSelection < 3) {
o.defaultAssetId = 'foo';
o.rules = buildUnnamed67();
}
buildCounterCreativeAssetSelection--;
return o;
}
void checkCreativeAssetSelection(api.CreativeAssetSelection o) {
buildCounterCreativeAssetSelection++;
if (buildCounterCreativeAssetSelection < 3) {
unittest.expect(
o.defaultAssetId!,
unittest.equals('foo'),
);
checkUnnamed67(o.rules!);
}
buildCounterCreativeAssetSelection--;
}
core.List<api.CompanionClickThroughOverride> buildUnnamed68() => [
buildCompanionClickThroughOverride(),
buildCompanionClickThroughOverride(),
];
void checkUnnamed68(core.List<api.CompanionClickThroughOverride> o) {
unittest.expect(o, unittest.hasLength(2));
checkCompanionClickThroughOverride(o[0]);
checkCompanionClickThroughOverride(o[1]);
}
core.List<api.CreativeGroupAssignment> buildUnnamed69() => [
buildCreativeGroupAssignment(),
buildCreativeGroupAssignment(),
];
void checkUnnamed69(core.List<api.CreativeGroupAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeGroupAssignment(o[0]);
checkCreativeGroupAssignment(o[1]);
}
core.List<api.RichMediaExitOverride> buildUnnamed70() => [
buildRichMediaExitOverride(),
buildRichMediaExitOverride(),
];
void checkUnnamed70(core.List<api.RichMediaExitOverride> o) {
unittest.expect(o, unittest.hasLength(2));
checkRichMediaExitOverride(o[0]);
checkRichMediaExitOverride(o[1]);
}
core.int buildCounterCreativeAssignment = 0;
api.CreativeAssignment buildCreativeAssignment() {
final o = api.CreativeAssignment();
buildCounterCreativeAssignment++;
if (buildCounterCreativeAssignment < 3) {
o.active = true;
o.applyEventTags = true;
o.clickThroughUrl = buildClickThroughUrl();
o.companionCreativeOverrides = buildUnnamed68();
o.creativeGroupAssignments = buildUnnamed69();
o.creativeId = 'foo';
o.creativeIdDimensionValue = buildDimensionValue();
o.endTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.richMediaExitOverrides = buildUnnamed70();
o.sequence = 42;
o.sslCompliant = true;
o.startTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.weight = 42;
}
buildCounterCreativeAssignment--;
return o;
}
void checkCreativeAssignment(api.CreativeAssignment o) {
buildCounterCreativeAssignment++;
if (buildCounterCreativeAssignment < 3) {
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(o.applyEventTags!, unittest.isTrue);
checkClickThroughUrl(o.clickThroughUrl!);
checkUnnamed68(o.companionCreativeOverrides!);
checkUnnamed69(o.creativeGroupAssignments!);
unittest.expect(
o.creativeId!,
unittest.equals('foo'),
);
checkDimensionValue(o.creativeIdDimensionValue!);
unittest.expect(
o.endTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkUnnamed70(o.richMediaExitOverrides!);
unittest.expect(
o.sequence!,
unittest.equals(42),
);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(
o.startTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.weight!,
unittest.equals(42),
);
}
buildCounterCreativeAssignment--;
}
core.int buildCounterCreativeClickThroughUrl = 0;
api.CreativeClickThroughUrl buildCreativeClickThroughUrl() {
final o = api.CreativeClickThroughUrl();
buildCounterCreativeClickThroughUrl++;
if (buildCounterCreativeClickThroughUrl < 3) {
o.computedClickThroughUrl = 'foo';
o.customClickThroughUrl = 'foo';
o.landingPageId = 'foo';
}
buildCounterCreativeClickThroughUrl--;
return o;
}
void checkCreativeClickThroughUrl(api.CreativeClickThroughUrl o) {
buildCounterCreativeClickThroughUrl++;
if (buildCounterCreativeClickThroughUrl < 3) {
unittest.expect(
o.computedClickThroughUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.customClickThroughUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.landingPageId!,
unittest.equals('foo'),
);
}
buildCounterCreativeClickThroughUrl--;
}
core.int buildCounterCreativeCustomEvent = 0;
api.CreativeCustomEvent buildCreativeCustomEvent() {
final o = api.CreativeCustomEvent();
buildCounterCreativeCustomEvent++;
if (buildCounterCreativeCustomEvent < 3) {
o.advertiserCustomEventId = 'foo';
o.advertiserCustomEventName = 'foo';
o.advertiserCustomEventType = 'foo';
o.artworkLabel = 'foo';
o.artworkType = 'foo';
o.exitClickThroughUrl = buildCreativeClickThroughUrl();
o.id = 'foo';
o.popupWindowProperties = buildPopupWindowProperties();
o.targetType = 'foo';
o.videoReportingId = 'foo';
}
buildCounterCreativeCustomEvent--;
return o;
}
void checkCreativeCustomEvent(api.CreativeCustomEvent o) {
buildCounterCreativeCustomEvent++;
if (buildCounterCreativeCustomEvent < 3) {
unittest.expect(
o.advertiserCustomEventId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserCustomEventName!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserCustomEventType!,
unittest.equals('foo'),
);
unittest.expect(
o.artworkLabel!,
unittest.equals('foo'),
);
unittest.expect(
o.artworkType!,
unittest.equals('foo'),
);
checkCreativeClickThroughUrl(o.exitClickThroughUrl!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkPopupWindowProperties(o.popupWindowProperties!);
unittest.expect(
o.targetType!,
unittest.equals('foo'),
);
unittest.expect(
o.videoReportingId!,
unittest.equals('foo'),
);
}
buildCounterCreativeCustomEvent--;
}
core.int buildCounterCreativeField = 0;
api.CreativeField buildCreativeField() {
final o = api.CreativeField();
buildCounterCreativeField++;
if (buildCounterCreativeField < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.subaccountId = 'foo';
}
buildCounterCreativeField--;
return o;
}
void checkCreativeField(api.CreativeField o) {
buildCounterCreativeField++;
if (buildCounterCreativeField < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterCreativeField--;
}
core.int buildCounterCreativeFieldAssignment = 0;
api.CreativeFieldAssignment buildCreativeFieldAssignment() {
final o = api.CreativeFieldAssignment();
buildCounterCreativeFieldAssignment++;
if (buildCounterCreativeFieldAssignment < 3) {
o.creativeFieldId = 'foo';
o.creativeFieldValueId = 'foo';
}
buildCounterCreativeFieldAssignment--;
return o;
}
void checkCreativeFieldAssignment(api.CreativeFieldAssignment o) {
buildCounterCreativeFieldAssignment++;
if (buildCounterCreativeFieldAssignment < 3) {
unittest.expect(
o.creativeFieldId!,
unittest.equals('foo'),
);
unittest.expect(
o.creativeFieldValueId!,
unittest.equals('foo'),
);
}
buildCounterCreativeFieldAssignment--;
}
core.int buildCounterCreativeFieldValue = 0;
api.CreativeFieldValue buildCreativeFieldValue() {
final o = api.CreativeFieldValue();
buildCounterCreativeFieldValue++;
if (buildCounterCreativeFieldValue < 3) {
o.id = 'foo';
o.kind = 'foo';
o.value = 'foo';
}
buildCounterCreativeFieldValue--;
return o;
}
void checkCreativeFieldValue(api.CreativeFieldValue o) {
buildCounterCreativeFieldValue++;
if (buildCounterCreativeFieldValue < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterCreativeFieldValue--;
}
core.List<api.CreativeFieldValue> buildUnnamed71() => [
buildCreativeFieldValue(),
buildCreativeFieldValue(),
];
void checkUnnamed71(core.List<api.CreativeFieldValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeFieldValue(o[0]);
checkCreativeFieldValue(o[1]);
}
core.int buildCounterCreativeFieldValuesListResponse = 0;
api.CreativeFieldValuesListResponse buildCreativeFieldValuesListResponse() {
final o = api.CreativeFieldValuesListResponse();
buildCounterCreativeFieldValuesListResponse++;
if (buildCounterCreativeFieldValuesListResponse < 3) {
o.creativeFieldValues = buildUnnamed71();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCreativeFieldValuesListResponse--;
return o;
}
void checkCreativeFieldValuesListResponse(
api.CreativeFieldValuesListResponse o) {
buildCounterCreativeFieldValuesListResponse++;
if (buildCounterCreativeFieldValuesListResponse < 3) {
checkUnnamed71(o.creativeFieldValues!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCreativeFieldValuesListResponse--;
}
core.List<api.CreativeField> buildUnnamed72() => [
buildCreativeField(),
buildCreativeField(),
];
void checkUnnamed72(core.List<api.CreativeField> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeField(o[0]);
checkCreativeField(o[1]);
}
core.int buildCounterCreativeFieldsListResponse = 0;
api.CreativeFieldsListResponse buildCreativeFieldsListResponse() {
final o = api.CreativeFieldsListResponse();
buildCounterCreativeFieldsListResponse++;
if (buildCounterCreativeFieldsListResponse < 3) {
o.creativeFields = buildUnnamed72();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCreativeFieldsListResponse--;
return o;
}
void checkCreativeFieldsListResponse(api.CreativeFieldsListResponse o) {
buildCounterCreativeFieldsListResponse++;
if (buildCounterCreativeFieldsListResponse < 3) {
checkUnnamed72(o.creativeFields!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCreativeFieldsListResponse--;
}
core.int buildCounterCreativeGroup = 0;
api.CreativeGroup buildCreativeGroup() {
final o = api.CreativeGroup();
buildCounterCreativeGroup++;
if (buildCounterCreativeGroup < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.groupNumber = 42;
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.subaccountId = 'foo';
}
buildCounterCreativeGroup--;
return o;
}
void checkCreativeGroup(api.CreativeGroup o) {
buildCounterCreativeGroup++;
if (buildCounterCreativeGroup < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.groupNumber!,
unittest.equals(42),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterCreativeGroup--;
}
core.int buildCounterCreativeGroupAssignment = 0;
api.CreativeGroupAssignment buildCreativeGroupAssignment() {
final o = api.CreativeGroupAssignment();
buildCounterCreativeGroupAssignment++;
if (buildCounterCreativeGroupAssignment < 3) {
o.creativeGroupId = 'foo';
o.creativeGroupNumber = 'foo';
}
buildCounterCreativeGroupAssignment--;
return o;
}
void checkCreativeGroupAssignment(api.CreativeGroupAssignment o) {
buildCounterCreativeGroupAssignment++;
if (buildCounterCreativeGroupAssignment < 3) {
unittest.expect(
o.creativeGroupId!,
unittest.equals('foo'),
);
unittest.expect(
o.creativeGroupNumber!,
unittest.equals('foo'),
);
}
buildCounterCreativeGroupAssignment--;
}
core.List<api.CreativeGroup> buildUnnamed73() => [
buildCreativeGroup(),
buildCreativeGroup(),
];
void checkUnnamed73(core.List<api.CreativeGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeGroup(o[0]);
checkCreativeGroup(o[1]);
}
core.int buildCounterCreativeGroupsListResponse = 0;
api.CreativeGroupsListResponse buildCreativeGroupsListResponse() {
final o = api.CreativeGroupsListResponse();
buildCounterCreativeGroupsListResponse++;
if (buildCounterCreativeGroupsListResponse < 3) {
o.creativeGroups = buildUnnamed73();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCreativeGroupsListResponse--;
return o;
}
void checkCreativeGroupsListResponse(api.CreativeGroupsListResponse o) {
buildCounterCreativeGroupsListResponse++;
if (buildCounterCreativeGroupsListResponse < 3) {
checkUnnamed73(o.creativeGroups!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCreativeGroupsListResponse--;
}
core.List<api.OptimizationActivity> buildUnnamed74() => [
buildOptimizationActivity(),
buildOptimizationActivity(),
];
void checkUnnamed74(core.List<api.OptimizationActivity> o) {
unittest.expect(o, unittest.hasLength(2));
checkOptimizationActivity(o[0]);
checkOptimizationActivity(o[1]);
}
core.int buildCounterCreativeOptimizationConfiguration = 0;
api.CreativeOptimizationConfiguration buildCreativeOptimizationConfiguration() {
final o = api.CreativeOptimizationConfiguration();
buildCounterCreativeOptimizationConfiguration++;
if (buildCounterCreativeOptimizationConfiguration < 3) {
o.id = 'foo';
o.name = 'foo';
o.optimizationActivitys = buildUnnamed74();
o.optimizationModel = 'foo';
}
buildCounterCreativeOptimizationConfiguration--;
return o;
}
void checkCreativeOptimizationConfiguration(
api.CreativeOptimizationConfiguration o) {
buildCounterCreativeOptimizationConfiguration++;
if (buildCounterCreativeOptimizationConfiguration < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed74(o.optimizationActivitys!);
unittest.expect(
o.optimizationModel!,
unittest.equals('foo'),
);
}
buildCounterCreativeOptimizationConfiguration--;
}
core.List<api.CreativeAssignment> buildUnnamed75() => [
buildCreativeAssignment(),
buildCreativeAssignment(),
];
void checkUnnamed75(core.List<api.CreativeAssignment> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreativeAssignment(o[0]);
checkCreativeAssignment(o[1]);
}
core.int buildCounterCreativeRotation = 0;
api.CreativeRotation buildCreativeRotation() {
final o = api.CreativeRotation();
buildCounterCreativeRotation++;
if (buildCounterCreativeRotation < 3) {
o.creativeAssignments = buildUnnamed75();
o.creativeOptimizationConfigurationId = 'foo';
o.type = 'foo';
o.weightCalculationStrategy = 'foo';
}
buildCounterCreativeRotation--;
return o;
}
void checkCreativeRotation(api.CreativeRotation o) {
buildCounterCreativeRotation++;
if (buildCounterCreativeRotation < 3) {
checkUnnamed75(o.creativeAssignments!);
unittest.expect(
o.creativeOptimizationConfigurationId!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.weightCalculationStrategy!,
unittest.equals('foo'),
);
}
buildCounterCreativeRotation--;
}
core.List<api.Creative> buildUnnamed76() => [
buildCreative(),
buildCreative(),
];
void checkUnnamed76(core.List<api.Creative> o) {
unittest.expect(o, unittest.hasLength(2));
checkCreative(o[0]);
checkCreative(o[1]);
}
core.int buildCounterCreativesListResponse = 0;
api.CreativesListResponse buildCreativesListResponse() {
final o = api.CreativesListResponse();
buildCounterCreativesListResponse++;
if (buildCounterCreativesListResponse < 3) {
o.creatives = buildUnnamed76();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCreativesListResponse--;
return o;
}
void checkCreativesListResponse(api.CreativesListResponse o) {
buildCounterCreativesListResponse++;
if (buildCounterCreativesListResponse < 3) {
checkUnnamed76(o.creatives!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCreativesListResponse--;
}
core.List<api.Dimension> buildUnnamed77() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed77(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed78() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed78(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed79() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed79(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Metric> buildUnnamed80() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed80(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.int buildCounterCrossDimensionReachReportCompatibleFields = 0;
api.CrossDimensionReachReportCompatibleFields
buildCrossDimensionReachReportCompatibleFields() {
final o = api.CrossDimensionReachReportCompatibleFields();
buildCounterCrossDimensionReachReportCompatibleFields++;
if (buildCounterCrossDimensionReachReportCompatibleFields < 3) {
o.breakdown = buildUnnamed77();
o.dimensionFilters = buildUnnamed78();
o.kind = 'foo';
o.metrics = buildUnnamed79();
o.overlapMetrics = buildUnnamed80();
}
buildCounterCrossDimensionReachReportCompatibleFields--;
return o;
}
void checkCrossDimensionReachReportCompatibleFields(
api.CrossDimensionReachReportCompatibleFields o) {
buildCounterCrossDimensionReachReportCompatibleFields++;
if (buildCounterCrossDimensionReachReportCompatibleFields < 3) {
checkUnnamed77(o.breakdown!);
checkUnnamed78(o.dimensionFilters!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed79(o.metrics!);
checkUnnamed80(o.overlapMetrics!);
}
buildCounterCrossDimensionReachReportCompatibleFields--;
}
core.int buildCounterCustomFloodlightVariable = 0;
api.CustomFloodlightVariable buildCustomFloodlightVariable() {
final o = api.CustomFloodlightVariable();
buildCounterCustomFloodlightVariable++;
if (buildCounterCustomFloodlightVariable < 3) {
o.kind = 'foo';
o.type = 'foo';
o.value = 'foo';
}
buildCounterCustomFloodlightVariable--;
return o;
}
void checkCustomFloodlightVariable(api.CustomFloodlightVariable o) {
buildCounterCustomFloodlightVariable++;
if (buildCounterCustomFloodlightVariable < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterCustomFloodlightVariable--;
}
core.List<api.DimensionValue> buildUnnamed81() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed81(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.int buildCounterCustomRichMediaEvents = 0;
api.CustomRichMediaEvents buildCustomRichMediaEvents() {
final o = api.CustomRichMediaEvents();
buildCounterCustomRichMediaEvents++;
if (buildCounterCustomRichMediaEvents < 3) {
o.filteredEventIds = buildUnnamed81();
o.kind = 'foo';
}
buildCounterCustomRichMediaEvents--;
return o;
}
void checkCustomRichMediaEvents(api.CustomRichMediaEvents o) {
buildCounterCustomRichMediaEvents++;
if (buildCounterCustomRichMediaEvents < 3) {
checkUnnamed81(o.filteredEventIds!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterCustomRichMediaEvents--;
}
core.int buildCounterCustomViewabilityMetric = 0;
api.CustomViewabilityMetric buildCustomViewabilityMetric() {
final o = api.CustomViewabilityMetric();
buildCounterCustomViewabilityMetric++;
if (buildCounterCustomViewabilityMetric < 3) {
o.configuration = buildCustomViewabilityMetricConfiguration();
o.id = 'foo';
o.name = 'foo';
}
buildCounterCustomViewabilityMetric--;
return o;
}
void checkCustomViewabilityMetric(api.CustomViewabilityMetric o) {
buildCounterCustomViewabilityMetric++;
if (buildCounterCustomViewabilityMetric < 3) {
checkCustomViewabilityMetricConfiguration(o.configuration!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterCustomViewabilityMetric--;
}
core.int buildCounterCustomViewabilityMetricConfiguration = 0;
api.CustomViewabilityMetricConfiguration
buildCustomViewabilityMetricConfiguration() {
final o = api.CustomViewabilityMetricConfiguration();
buildCounterCustomViewabilityMetricConfiguration++;
if (buildCounterCustomViewabilityMetricConfiguration < 3) {
o.audible = true;
o.timeMillis = 42;
o.timePercent = 42;
o.viewabilityPercent = 42;
}
buildCounterCustomViewabilityMetricConfiguration--;
return o;
}
void checkCustomViewabilityMetricConfiguration(
api.CustomViewabilityMetricConfiguration o) {
buildCounterCustomViewabilityMetricConfiguration++;
if (buildCounterCustomViewabilityMetricConfiguration < 3) {
unittest.expect(o.audible!, unittest.isTrue);
unittest.expect(
o.timeMillis!,
unittest.equals(42),
);
unittest.expect(
o.timePercent!,
unittest.equals(42),
);
unittest.expect(
o.viewabilityPercent!,
unittest.equals(42),
);
}
buildCounterCustomViewabilityMetricConfiguration--;
}
core.int buildCounterDateRange = 0;
api.DateRange buildDateRange() {
final o = api.DateRange();
buildCounterDateRange++;
if (buildCounterDateRange < 3) {
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.kind = 'foo';
o.relativeDateRange = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterDateRange--;
return o;
}
void checkDateRange(api.DateRange o) {
buildCounterDateRange++;
if (buildCounterDateRange < 3) {
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.relativeDateRange!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
buildCounterDateRange--;
}
core.List<core.String> buildUnnamed82() => [
'foo',
'foo',
];
void checkUnnamed82(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.int> buildUnnamed83() => [
42,
42,
];
void checkUnnamed83(core.List<core.int> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(42),
);
unittest.expect(
o[1],
unittest.equals(42),
);
}
core.int buildCounterDayPartTargeting = 0;
api.DayPartTargeting buildDayPartTargeting() {
final o = api.DayPartTargeting();
buildCounterDayPartTargeting++;
if (buildCounterDayPartTargeting < 3) {
o.daysOfWeek = buildUnnamed82();
o.hoursOfDay = buildUnnamed83();
o.userLocalTime = true;
}
buildCounterDayPartTargeting--;
return o;
}
void checkDayPartTargeting(api.DayPartTargeting o) {
buildCounterDayPartTargeting++;
if (buildCounterDayPartTargeting < 3) {
checkUnnamed82(o.daysOfWeek!);
checkUnnamed83(o.hoursOfDay!);
unittest.expect(o.userLocalTime!, unittest.isTrue);
}
buildCounterDayPartTargeting--;
}
core.List<core.String> buildUnnamed84() => [
'foo',
'foo',
];
void checkUnnamed84(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterDeepLink = 0;
api.DeepLink buildDeepLink() {
final o = api.DeepLink();
buildCounterDeepLink++;
if (buildCounterDeepLink < 3) {
o.appUrl = 'foo';
o.fallbackUrl = 'foo';
o.kind = 'foo';
o.mobileApp = buildMobileApp();
o.remarketingListIds = buildUnnamed84();
}
buildCounterDeepLink--;
return o;
}
void checkDeepLink(api.DeepLink o) {
buildCounterDeepLink++;
if (buildCounterDeepLink < 3) {
unittest.expect(
o.appUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.fallbackUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkMobileApp(o.mobileApp!);
checkUnnamed84(o.remarketingListIds!);
}
buildCounterDeepLink--;
}
core.int buildCounterDefaultClickThroughEventTagProperties = 0;
api.DefaultClickThroughEventTagProperties
buildDefaultClickThroughEventTagProperties() {
final o = api.DefaultClickThroughEventTagProperties();
buildCounterDefaultClickThroughEventTagProperties++;
if (buildCounterDefaultClickThroughEventTagProperties < 3) {
o.defaultClickThroughEventTagId = 'foo';
o.overrideInheritedEventTag = true;
}
buildCounterDefaultClickThroughEventTagProperties--;
return o;
}
void checkDefaultClickThroughEventTagProperties(
api.DefaultClickThroughEventTagProperties o) {
buildCounterDefaultClickThroughEventTagProperties++;
if (buildCounterDefaultClickThroughEventTagProperties < 3) {
unittest.expect(
o.defaultClickThroughEventTagId!,
unittest.equals('foo'),
);
unittest.expect(o.overrideInheritedEventTag!, unittest.isTrue);
}
buildCounterDefaultClickThroughEventTagProperties--;
}
core.int buildCounterDeliverySchedule = 0;
api.DeliverySchedule buildDeliverySchedule() {
final o = api.DeliverySchedule();
buildCounterDeliverySchedule++;
if (buildCounterDeliverySchedule < 3) {
o.frequencyCap = buildFrequencyCap();
o.hardCutoff = true;
o.impressionRatio = 'foo';
o.priority = 'foo';
}
buildCounterDeliverySchedule--;
return o;
}
void checkDeliverySchedule(api.DeliverySchedule o) {
buildCounterDeliverySchedule++;
if (buildCounterDeliverySchedule < 3) {
checkFrequencyCap(o.frequencyCap!);
unittest.expect(o.hardCutoff!, unittest.isTrue);
unittest.expect(
o.impressionRatio!,
unittest.equals('foo'),
);
unittest.expect(
o.priority!,
unittest.equals('foo'),
);
}
buildCounterDeliverySchedule--;
}
core.int buildCounterDfpSettings = 0;
api.DfpSettings buildDfpSettings() {
final o = api.DfpSettings();
buildCounterDfpSettings++;
if (buildCounterDfpSettings < 3) {
o.dfpNetworkCode = 'foo';
o.dfpNetworkName = 'foo';
o.programmaticPlacementAccepted = true;
o.pubPaidPlacementAccepted = true;
o.publisherPortalOnly = true;
}
buildCounterDfpSettings--;
return o;
}
void checkDfpSettings(api.DfpSettings o) {
buildCounterDfpSettings++;
if (buildCounterDfpSettings < 3) {
unittest.expect(
o.dfpNetworkCode!,
unittest.equals('foo'),
);
unittest.expect(
o.dfpNetworkName!,
unittest.equals('foo'),
);
unittest.expect(o.programmaticPlacementAccepted!, unittest.isTrue);
unittest.expect(o.pubPaidPlacementAccepted!, unittest.isTrue);
unittest.expect(o.publisherPortalOnly!, unittest.isTrue);
}
buildCounterDfpSettings--;
}
core.int buildCounterDimension = 0;
api.Dimension buildDimension() {
final o = api.Dimension();
buildCounterDimension++;
if (buildCounterDimension < 3) {
o.kind = 'foo';
o.name = 'foo';
}
buildCounterDimension--;
return o;
}
void checkDimension(api.Dimension o) {
buildCounterDimension++;
if (buildCounterDimension < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterDimension--;
}
core.int buildCounterDimensionFilter = 0;
api.DimensionFilter buildDimensionFilter() {
final o = api.DimensionFilter();
buildCounterDimensionFilter++;
if (buildCounterDimensionFilter < 3) {
o.dimensionName = 'foo';
o.kind = 'foo';
o.value = 'foo';
}
buildCounterDimensionFilter--;
return o;
}
void checkDimensionFilter(api.DimensionFilter o) {
buildCounterDimensionFilter++;
if (buildCounterDimensionFilter < 3) {
unittest.expect(
o.dimensionName!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterDimensionFilter--;
}
core.int buildCounterDimensionValue = 0;
api.DimensionValue buildDimensionValue() {
final o = api.DimensionValue();
buildCounterDimensionValue++;
if (buildCounterDimensionValue < 3) {
o.dimensionName = 'foo';
o.etag = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.matchType = 'foo';
o.value = 'foo';
}
buildCounterDimensionValue--;
return o;
}
void checkDimensionValue(api.DimensionValue o) {
buildCounterDimensionValue++;
if (buildCounterDimensionValue < 3) {
unittest.expect(
o.dimensionName!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.matchType!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterDimensionValue--;
}
core.List<api.DimensionValue> buildUnnamed85() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed85(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.int buildCounterDimensionValueList = 0;
api.DimensionValueList buildDimensionValueList() {
final o = api.DimensionValueList();
buildCounterDimensionValueList++;
if (buildCounterDimensionValueList < 3) {
o.etag = 'foo';
o.items = buildUnnamed85();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterDimensionValueList--;
return o;
}
void checkDimensionValueList(api.DimensionValueList o) {
buildCounterDimensionValueList++;
if (buildCounterDimensionValueList < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed85(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterDimensionValueList--;
}
core.List<api.DimensionFilter> buildUnnamed86() => [
buildDimensionFilter(),
buildDimensionFilter(),
];
void checkUnnamed86(core.List<api.DimensionFilter> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionFilter(o[0]);
checkDimensionFilter(o[1]);
}
core.int buildCounterDimensionValueRequest = 0;
api.DimensionValueRequest buildDimensionValueRequest() {
final o = api.DimensionValueRequest();
buildCounterDimensionValueRequest++;
if (buildCounterDimensionValueRequest < 3) {
o.dimensionName = 'foo';
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.filters = buildUnnamed86();
o.kind = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterDimensionValueRequest--;
return o;
}
void checkDimensionValueRequest(api.DimensionValueRequest o) {
buildCounterDimensionValueRequest++;
if (buildCounterDimensionValueRequest < 3) {
unittest.expect(
o.dimensionName!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
checkUnnamed86(o.filters!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
buildCounterDimensionValueRequest--;
}
core.List<core.String> buildUnnamed87() => [
'foo',
'foo',
];
void checkUnnamed87(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed88() => [
'foo',
'foo',
];
void checkUnnamed88(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterDirectorySite = 0;
api.DirectorySite buildDirectorySite() {
final o = api.DirectorySite();
buildCounterDirectorySite++;
if (buildCounterDirectorySite < 3) {
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.inpageTagFormats = buildUnnamed87();
o.interstitialTagFormats = buildUnnamed88();
o.kind = 'foo';
o.name = 'foo';
o.settings = buildDirectorySiteSettings();
o.url = 'foo';
}
buildCounterDirectorySite--;
return o;
}
void checkDirectorySite(api.DirectorySite o) {
buildCounterDirectorySite++;
if (buildCounterDirectorySite < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
checkUnnamed87(o.inpageTagFormats!);
checkUnnamed88(o.interstitialTagFormats!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkDirectorySiteSettings(o.settings!);
unittest.expect(
o.url!,
unittest.equals('foo'),
);
}
buildCounterDirectorySite--;
}
core.int buildCounterDirectorySiteSettings = 0;
api.DirectorySiteSettings buildDirectorySiteSettings() {
final o = api.DirectorySiteSettings();
buildCounterDirectorySiteSettings++;
if (buildCounterDirectorySiteSettings < 3) {
o.activeViewOptOut = true;
o.dfpSettings = buildDfpSettings();
o.instreamVideoPlacementAccepted = true;
o.interstitialPlacementAccepted = true;
}
buildCounterDirectorySiteSettings--;
return o;
}
void checkDirectorySiteSettings(api.DirectorySiteSettings o) {
buildCounterDirectorySiteSettings++;
if (buildCounterDirectorySiteSettings < 3) {
unittest.expect(o.activeViewOptOut!, unittest.isTrue);
checkDfpSettings(o.dfpSettings!);
unittest.expect(o.instreamVideoPlacementAccepted!, unittest.isTrue);
unittest.expect(o.interstitialPlacementAccepted!, unittest.isTrue);
}
buildCounterDirectorySiteSettings--;
}
core.List<api.DirectorySite> buildUnnamed89() => [
buildDirectorySite(),
buildDirectorySite(),
];
void checkUnnamed89(core.List<api.DirectorySite> o) {
unittest.expect(o, unittest.hasLength(2));
checkDirectorySite(o[0]);
checkDirectorySite(o[1]);
}
core.int buildCounterDirectorySitesListResponse = 0;
api.DirectorySitesListResponse buildDirectorySitesListResponse() {
final o = api.DirectorySitesListResponse();
buildCounterDirectorySitesListResponse++;
if (buildCounterDirectorySitesListResponse < 3) {
o.directorySites = buildUnnamed89();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterDirectorySitesListResponse--;
return o;
}
void checkDirectorySitesListResponse(api.DirectorySitesListResponse o) {
buildCounterDirectorySitesListResponse++;
if (buildCounterDirectorySitesListResponse < 3) {
checkUnnamed89(o.directorySites!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterDirectorySitesListResponse--;
}
core.List<api.EventFilter> buildUnnamed90() => [
buildEventFilter(),
buildEventFilter(),
];
void checkUnnamed90(core.List<api.EventFilter> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventFilter(o[0]);
checkEventFilter(o[1]);
}
core.int buildCounterDisjunctiveMatchStatement = 0;
api.DisjunctiveMatchStatement buildDisjunctiveMatchStatement() {
final o = api.DisjunctiveMatchStatement();
buildCounterDisjunctiveMatchStatement++;
if (buildCounterDisjunctiveMatchStatement < 3) {
o.eventFilters = buildUnnamed90();
o.kind = 'foo';
}
buildCounterDisjunctiveMatchStatement--;
return o;
}
void checkDisjunctiveMatchStatement(api.DisjunctiveMatchStatement o) {
buildCounterDisjunctiveMatchStatement++;
if (buildCounterDisjunctiveMatchStatement < 3) {
checkUnnamed90(o.eventFilters!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterDisjunctiveMatchStatement--;
}
core.int buildCounterDynamicTargetingKey = 0;
api.DynamicTargetingKey buildDynamicTargetingKey() {
final o = api.DynamicTargetingKey();
buildCounterDynamicTargetingKey++;
if (buildCounterDynamicTargetingKey < 3) {
o.kind = 'foo';
o.name = 'foo';
o.objectId = 'foo';
o.objectType = 'foo';
}
buildCounterDynamicTargetingKey--;
return o;
}
void checkDynamicTargetingKey(api.DynamicTargetingKey o) {
buildCounterDynamicTargetingKey++;
if (buildCounterDynamicTargetingKey < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.objectId!,
unittest.equals('foo'),
);
unittest.expect(
o.objectType!,
unittest.equals('foo'),
);
}
buildCounterDynamicTargetingKey--;
}
core.List<api.DynamicTargetingKey> buildUnnamed91() => [
buildDynamicTargetingKey(),
buildDynamicTargetingKey(),
];
void checkUnnamed91(core.List<api.DynamicTargetingKey> o) {
unittest.expect(o, unittest.hasLength(2));
checkDynamicTargetingKey(o[0]);
checkDynamicTargetingKey(o[1]);
}
core.int buildCounterDynamicTargetingKeysListResponse = 0;
api.DynamicTargetingKeysListResponse buildDynamicTargetingKeysListResponse() {
final o = api.DynamicTargetingKeysListResponse();
buildCounterDynamicTargetingKeysListResponse++;
if (buildCounterDynamicTargetingKeysListResponse < 3) {
o.dynamicTargetingKeys = buildUnnamed91();
o.kind = 'foo';
}
buildCounterDynamicTargetingKeysListResponse--;
return o;
}
void checkDynamicTargetingKeysListResponse(
api.DynamicTargetingKeysListResponse o) {
buildCounterDynamicTargetingKeysListResponse++;
if (buildCounterDynamicTargetingKeysListResponse < 3) {
checkUnnamed91(o.dynamicTargetingKeys!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterDynamicTargetingKeysListResponse--;
}
core.int buildCounterEncryptionInfo = 0;
api.EncryptionInfo buildEncryptionInfo() {
final o = api.EncryptionInfo();
buildCounterEncryptionInfo++;
if (buildCounterEncryptionInfo < 3) {
o.encryptionEntityId = 'foo';
o.encryptionEntityType = 'foo';
o.encryptionSource = 'foo';
o.kind = 'foo';
}
buildCounterEncryptionInfo--;
return o;
}
void checkEncryptionInfo(api.EncryptionInfo o) {
buildCounterEncryptionInfo++;
if (buildCounterEncryptionInfo < 3) {
unittest.expect(
o.encryptionEntityId!,
unittest.equals('foo'),
);
unittest.expect(
o.encryptionEntityType!,
unittest.equals('foo'),
);
unittest.expect(
o.encryptionSource!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterEncryptionInfo--;
}
core.int buildCounterEventFilter = 0;
api.EventFilter buildEventFilter() {
final o = api.EventFilter();
buildCounterEventFilter++;
if (buildCounterEventFilter < 3) {
o.dimensionFilter = buildPathReportDimensionValue();
o.kind = 'foo';
o.uvarFilter = buildUvarFilter();
}
buildCounterEventFilter--;
return o;
}
void checkEventFilter(api.EventFilter o) {
buildCounterEventFilter++;
if (buildCounterEventFilter < 3) {
checkPathReportDimensionValue(o.dimensionFilter!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUvarFilter(o.uvarFilter!);
}
buildCounterEventFilter--;
}
core.List<core.String> buildUnnamed92() => [
'foo',
'foo',
];
void checkUnnamed92(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterEventTag = 0;
api.EventTag buildEventTag() {
final o = api.EventTag();
buildCounterEventTag++;
if (buildCounterEventTag < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.campaignId = 'foo';
o.campaignIdDimensionValue = buildDimensionValue();
o.enabledByDefault = true;
o.excludeFromAdxRequests = true;
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.siteFilterType = 'foo';
o.siteIds = buildUnnamed92();
o.sslCompliant = true;
o.status = 'foo';
o.subaccountId = 'foo';
o.type = 'foo';
o.url = 'foo';
o.urlEscapeLevels = 42;
}
buildCounterEventTag--;
return o;
}
void checkEventTag(api.EventTag o) {
buildCounterEventTag++;
if (buildCounterEventTag < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
checkDimensionValue(o.campaignIdDimensionValue!);
unittest.expect(o.enabledByDefault!, unittest.isTrue);
unittest.expect(o.excludeFromAdxRequests!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.siteFilterType!,
unittest.equals('foo'),
);
checkUnnamed92(o.siteIds!);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.url!,
unittest.equals('foo'),
);
unittest.expect(
o.urlEscapeLevels!,
unittest.equals(42),
);
}
buildCounterEventTag--;
}
core.int buildCounterEventTagOverride = 0;
api.EventTagOverride buildEventTagOverride() {
final o = api.EventTagOverride();
buildCounterEventTagOverride++;
if (buildCounterEventTagOverride < 3) {
o.enabled = true;
o.id = 'foo';
}
buildCounterEventTagOverride--;
return o;
}
void checkEventTagOverride(api.EventTagOverride o) {
buildCounterEventTagOverride++;
if (buildCounterEventTagOverride < 3) {
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
}
buildCounterEventTagOverride--;
}
core.List<api.EventTag> buildUnnamed93() => [
buildEventTag(),
buildEventTag(),
];
void checkUnnamed93(core.List<api.EventTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventTag(o[0]);
checkEventTag(o[1]);
}
core.int buildCounterEventTagsListResponse = 0;
api.EventTagsListResponse buildEventTagsListResponse() {
final o = api.EventTagsListResponse();
buildCounterEventTagsListResponse++;
if (buildCounterEventTagsListResponse < 3) {
o.eventTags = buildUnnamed93();
o.kind = 'foo';
}
buildCounterEventTagsListResponse--;
return o;
}
void checkEventTagsListResponse(api.EventTagsListResponse o) {
buildCounterEventTagsListResponse++;
if (buildCounterEventTagsListResponse < 3) {
checkUnnamed93(o.eventTags!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterEventTagsListResponse--;
}
core.int buildCounterFileUrls = 0;
api.FileUrls buildFileUrls() {
final o = api.FileUrls();
buildCounterFileUrls++;
if (buildCounterFileUrls < 3) {
o.apiUrl = 'foo';
o.browserUrl = 'foo';
}
buildCounterFileUrls--;
return o;
}
void checkFileUrls(api.FileUrls o) {
buildCounterFileUrls++;
if (buildCounterFileUrls < 3) {
unittest.expect(
o.apiUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.browserUrl!,
unittest.equals('foo'),
);
}
buildCounterFileUrls--;
}
core.int buildCounterFile = 0;
api.File buildFile() {
final o = api.File();
buildCounterFile++;
if (buildCounterFile < 3) {
o.dateRange = buildDateRange();
o.etag = 'foo';
o.fileName = 'foo';
o.format = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.lastModifiedTime = 'foo';
o.reportId = 'foo';
o.status = 'foo';
o.urls = buildFileUrls();
}
buildCounterFile--;
return o;
}
void checkFile(api.File o) {
buildCounterFile++;
if (buildCounterFile < 3) {
checkDateRange(o.dateRange!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.fileName!,
unittest.equals('foo'),
);
unittest.expect(
o.format!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.lastModifiedTime!,
unittest.equals('foo'),
);
unittest.expect(
o.reportId!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
checkFileUrls(o.urls!);
}
buildCounterFile--;
}
core.List<api.File> buildUnnamed94() => [
buildFile(),
buildFile(),
];
void checkUnnamed94(core.List<api.File> o) {
unittest.expect(o, unittest.hasLength(2));
checkFile(o[0]);
checkFile(o[1]);
}
core.int buildCounterFileList = 0;
api.FileList buildFileList() {
final o = api.FileList();
buildCounterFileList++;
if (buildCounterFileList < 3) {
o.etag = 'foo';
o.items = buildUnnamed94();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterFileList--;
return o;
}
void checkFileList(api.FileList o) {
buildCounterFileList++;
if (buildCounterFileList < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed94(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterFileList--;
}
core.int buildCounterFlight = 0;
api.Flight buildFlight() {
final o = api.Flight();
buildCounterFlight++;
if (buildCounterFlight < 3) {
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.rateOrCost = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.units = 'foo';
}
buildCounterFlight--;
return o;
}
void checkFlight(api.Flight o) {
buildCounterFlight++;
if (buildCounterFlight < 3) {
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.rateOrCost!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.units!,
unittest.equals('foo'),
);
}
buildCounterFlight--;
}
core.int buildCounterFloodlightActivitiesGenerateTagResponse = 0;
api.FloodlightActivitiesGenerateTagResponse
buildFloodlightActivitiesGenerateTagResponse() {
final o = api.FloodlightActivitiesGenerateTagResponse();
buildCounterFloodlightActivitiesGenerateTagResponse++;
if (buildCounterFloodlightActivitiesGenerateTagResponse < 3) {
o.floodlightActivityTag = 'foo';
o.globalSiteTagGlobalSnippet = 'foo';
o.kind = 'foo';
}
buildCounterFloodlightActivitiesGenerateTagResponse--;
return o;
}
void checkFloodlightActivitiesGenerateTagResponse(
api.FloodlightActivitiesGenerateTagResponse o) {
buildCounterFloodlightActivitiesGenerateTagResponse++;
if (buildCounterFloodlightActivitiesGenerateTagResponse < 3) {
unittest.expect(
o.floodlightActivityTag!,
unittest.equals('foo'),
);
unittest.expect(
o.globalSiteTagGlobalSnippet!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterFloodlightActivitiesGenerateTagResponse--;
}
core.List<api.FloodlightActivity> buildUnnamed95() => [
buildFloodlightActivity(),
buildFloodlightActivity(),
];
void checkUnnamed95(core.List<api.FloodlightActivity> o) {
unittest.expect(o, unittest.hasLength(2));
checkFloodlightActivity(o[0]);
checkFloodlightActivity(o[1]);
}
core.int buildCounterFloodlightActivitiesListResponse = 0;
api.FloodlightActivitiesListResponse buildFloodlightActivitiesListResponse() {
final o = api.FloodlightActivitiesListResponse();
buildCounterFloodlightActivitiesListResponse++;
if (buildCounterFloodlightActivitiesListResponse < 3) {
o.floodlightActivities = buildUnnamed95();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterFloodlightActivitiesListResponse--;
return o;
}
void checkFloodlightActivitiesListResponse(
api.FloodlightActivitiesListResponse o) {
buildCounterFloodlightActivitiesListResponse++;
if (buildCounterFloodlightActivitiesListResponse < 3) {
checkUnnamed95(o.floodlightActivities!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterFloodlightActivitiesListResponse--;
}
core.List<api.FloodlightActivityDynamicTag> buildUnnamed96() => [
buildFloodlightActivityDynamicTag(),
buildFloodlightActivityDynamicTag(),
];
void checkUnnamed96(core.List<api.FloodlightActivityDynamicTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkFloodlightActivityDynamicTag(o[0]);
checkFloodlightActivityDynamicTag(o[1]);
}
core.List<api.FloodlightActivityPublisherDynamicTag> buildUnnamed97() => [
buildFloodlightActivityPublisherDynamicTag(),
buildFloodlightActivityPublisherDynamicTag(),
];
void checkUnnamed97(core.List<api.FloodlightActivityPublisherDynamicTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkFloodlightActivityPublisherDynamicTag(o[0]);
checkFloodlightActivityPublisherDynamicTag(o[1]);
}
core.List<core.String> buildUnnamed98() => [
'foo',
'foo',
];
void checkUnnamed98(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterFloodlightActivity = 0;
api.FloodlightActivity buildFloodlightActivity() {
final o = api.FloodlightActivity();
buildCounterFloodlightActivity++;
if (buildCounterFloodlightActivity < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.attributionEnabled = true;
o.cacheBustingType = 'foo';
o.countingMethod = 'foo';
o.defaultTags = buildUnnamed96();
o.expectedUrl = 'foo';
o.floodlightActivityGroupId = 'foo';
o.floodlightActivityGroupName = 'foo';
o.floodlightActivityGroupTagString = 'foo';
o.floodlightActivityGroupType = 'foo';
o.floodlightConfigurationId = 'foo';
o.floodlightConfigurationIdDimensionValue = buildDimensionValue();
o.floodlightTagType = 'foo';
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.name = 'foo';
o.notes = 'foo';
o.publisherTags = buildUnnamed97();
o.secure = true;
o.sslCompliant = true;
o.sslRequired = true;
o.status = 'foo';
o.subaccountId = 'foo';
o.tagFormat = 'foo';
o.tagString = 'foo';
o.userDefinedVariableTypes = buildUnnamed98();
}
buildCounterFloodlightActivity--;
return o;
}
void checkFloodlightActivity(api.FloodlightActivity o) {
buildCounterFloodlightActivity++;
if (buildCounterFloodlightActivity < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(o.attributionEnabled!, unittest.isTrue);
unittest.expect(
o.cacheBustingType!,
unittest.equals('foo'),
);
unittest.expect(
o.countingMethod!,
unittest.equals('foo'),
);
checkUnnamed96(o.defaultTags!);
unittest.expect(
o.expectedUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightActivityGroupId!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightActivityGroupName!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightActivityGroupTagString!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightActivityGroupType!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightConfigurationId!,
unittest.equals('foo'),
);
checkDimensionValue(o.floodlightConfigurationIdDimensionValue!);
unittest.expect(
o.floodlightTagType!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.notes!,
unittest.equals('foo'),
);
checkUnnamed97(o.publisherTags!);
unittest.expect(o.secure!, unittest.isTrue);
unittest.expect(o.sslCompliant!, unittest.isTrue);
unittest.expect(o.sslRequired!, unittest.isTrue);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.tagFormat!,
unittest.equals('foo'),
);
unittest.expect(
o.tagString!,
unittest.equals('foo'),
);
checkUnnamed98(o.userDefinedVariableTypes!);
}
buildCounterFloodlightActivity--;
}
core.int buildCounterFloodlightActivityDynamicTag = 0;
api.FloodlightActivityDynamicTag buildFloodlightActivityDynamicTag() {
final o = api.FloodlightActivityDynamicTag();
buildCounterFloodlightActivityDynamicTag++;
if (buildCounterFloodlightActivityDynamicTag < 3) {
o.id = 'foo';
o.name = 'foo';
o.tag = 'foo';
}
buildCounterFloodlightActivityDynamicTag--;
return o;
}
void checkFloodlightActivityDynamicTag(api.FloodlightActivityDynamicTag o) {
buildCounterFloodlightActivityDynamicTag++;
if (buildCounterFloodlightActivityDynamicTag < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.tag!,
unittest.equals('foo'),
);
}
buildCounterFloodlightActivityDynamicTag--;
}
core.int buildCounterFloodlightActivityGroup = 0;
api.FloodlightActivityGroup buildFloodlightActivityGroup() {
final o = api.FloodlightActivityGroup();
buildCounterFloodlightActivityGroup++;
if (buildCounterFloodlightActivityGroup < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.floodlightConfigurationId = 'foo';
o.floodlightConfigurationIdDimensionValue = buildDimensionValue();
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.name = 'foo';
o.subaccountId = 'foo';
o.tagString = 'foo';
o.type = 'foo';
}
buildCounterFloodlightActivityGroup--;
return o;
}
void checkFloodlightActivityGroup(api.FloodlightActivityGroup o) {
buildCounterFloodlightActivityGroup++;
if (buildCounterFloodlightActivityGroup < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.floodlightConfigurationId!,
unittest.equals('foo'),
);
checkDimensionValue(o.floodlightConfigurationIdDimensionValue!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.tagString!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterFloodlightActivityGroup--;
}
core.List<api.FloodlightActivityGroup> buildUnnamed99() => [
buildFloodlightActivityGroup(),
buildFloodlightActivityGroup(),
];
void checkUnnamed99(core.List<api.FloodlightActivityGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkFloodlightActivityGroup(o[0]);
checkFloodlightActivityGroup(o[1]);
}
core.int buildCounterFloodlightActivityGroupsListResponse = 0;
api.FloodlightActivityGroupsListResponse
buildFloodlightActivityGroupsListResponse() {
final o = api.FloodlightActivityGroupsListResponse();
buildCounterFloodlightActivityGroupsListResponse++;
if (buildCounterFloodlightActivityGroupsListResponse < 3) {
o.floodlightActivityGroups = buildUnnamed99();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterFloodlightActivityGroupsListResponse--;
return o;
}
void checkFloodlightActivityGroupsListResponse(
api.FloodlightActivityGroupsListResponse o) {
buildCounterFloodlightActivityGroupsListResponse++;
if (buildCounterFloodlightActivityGroupsListResponse < 3) {
checkUnnamed99(o.floodlightActivityGroups!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterFloodlightActivityGroupsListResponse--;
}
core.int buildCounterFloodlightActivityPublisherDynamicTag = 0;
api.FloodlightActivityPublisherDynamicTag
buildFloodlightActivityPublisherDynamicTag() {
final o = api.FloodlightActivityPublisherDynamicTag();
buildCounterFloodlightActivityPublisherDynamicTag++;
if (buildCounterFloodlightActivityPublisherDynamicTag < 3) {
o.clickThrough = true;
o.directorySiteId = 'foo';
o.dynamicTag = buildFloodlightActivityDynamicTag();
o.siteId = 'foo';
o.siteIdDimensionValue = buildDimensionValue();
o.viewThrough = true;
}
buildCounterFloodlightActivityPublisherDynamicTag--;
return o;
}
void checkFloodlightActivityPublisherDynamicTag(
api.FloodlightActivityPublisherDynamicTag o) {
buildCounterFloodlightActivityPublisherDynamicTag++;
if (buildCounterFloodlightActivityPublisherDynamicTag < 3) {
unittest.expect(o.clickThrough!, unittest.isTrue);
unittest.expect(
o.directorySiteId!,
unittest.equals('foo'),
);
checkFloodlightActivityDynamicTag(o.dynamicTag!);
unittest.expect(
o.siteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.siteIdDimensionValue!);
unittest.expect(o.viewThrough!, unittest.isTrue);
}
buildCounterFloodlightActivityPublisherDynamicTag--;
}
core.List<api.ThirdPartyAuthenticationToken> buildUnnamed100() => [
buildThirdPartyAuthenticationToken(),
buildThirdPartyAuthenticationToken(),
];
void checkUnnamed100(core.List<api.ThirdPartyAuthenticationToken> o) {
unittest.expect(o, unittest.hasLength(2));
checkThirdPartyAuthenticationToken(o[0]);
checkThirdPartyAuthenticationToken(o[1]);
}
core.List<api.UserDefinedVariableConfiguration> buildUnnamed101() => [
buildUserDefinedVariableConfiguration(),
buildUserDefinedVariableConfiguration(),
];
void checkUnnamed101(core.List<api.UserDefinedVariableConfiguration> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserDefinedVariableConfiguration(o[0]);
checkUserDefinedVariableConfiguration(o[1]);
}
core.int buildCounterFloodlightConfiguration = 0;
api.FloodlightConfiguration buildFloodlightConfiguration() {
final o = api.FloodlightConfiguration();
buildCounterFloodlightConfiguration++;
if (buildCounterFloodlightConfiguration < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.analyticsDataSharingEnabled = true;
o.customViewabilityMetric = buildCustomViewabilityMetric();
o.exposureToConversionEnabled = true;
o.firstDayOfWeek = 'foo';
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.inAppAttributionTrackingEnabled = true;
o.kind = 'foo';
o.lookbackConfiguration = buildLookbackConfiguration();
o.naturalSearchConversionAttributionOption = 'foo';
o.omnitureSettings = buildOmnitureSettings();
o.subaccountId = 'foo';
o.tagSettings = buildTagSettings();
o.thirdPartyAuthenticationTokens = buildUnnamed100();
o.userDefinedVariableConfigurations = buildUnnamed101();
}
buildCounterFloodlightConfiguration--;
return o;
}
void checkFloodlightConfiguration(api.FloodlightConfiguration o) {
buildCounterFloodlightConfiguration++;
if (buildCounterFloodlightConfiguration < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(o.analyticsDataSharingEnabled!, unittest.isTrue);
checkCustomViewabilityMetric(o.customViewabilityMetric!);
unittest.expect(o.exposureToConversionEnabled!, unittest.isTrue);
unittest.expect(
o.firstDayOfWeek!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(o.inAppAttributionTrackingEnabled!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLookbackConfiguration(o.lookbackConfiguration!);
unittest.expect(
o.naturalSearchConversionAttributionOption!,
unittest.equals('foo'),
);
checkOmnitureSettings(o.omnitureSettings!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
checkTagSettings(o.tagSettings!);
checkUnnamed100(o.thirdPartyAuthenticationTokens!);
checkUnnamed101(o.userDefinedVariableConfigurations!);
}
buildCounterFloodlightConfiguration--;
}
core.List<api.FloodlightConfiguration> buildUnnamed102() => [
buildFloodlightConfiguration(),
buildFloodlightConfiguration(),
];
void checkUnnamed102(core.List<api.FloodlightConfiguration> o) {
unittest.expect(o, unittest.hasLength(2));
checkFloodlightConfiguration(o[0]);
checkFloodlightConfiguration(o[1]);
}
core.int buildCounterFloodlightConfigurationsListResponse = 0;
api.FloodlightConfigurationsListResponse
buildFloodlightConfigurationsListResponse() {
final o = api.FloodlightConfigurationsListResponse();
buildCounterFloodlightConfigurationsListResponse++;
if (buildCounterFloodlightConfigurationsListResponse < 3) {
o.floodlightConfigurations = buildUnnamed102();
o.kind = 'foo';
}
buildCounterFloodlightConfigurationsListResponse--;
return o;
}
void checkFloodlightConfigurationsListResponse(
api.FloodlightConfigurationsListResponse o) {
buildCounterFloodlightConfigurationsListResponse++;
if (buildCounterFloodlightConfigurationsListResponse < 3) {
checkUnnamed102(o.floodlightConfigurations!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterFloodlightConfigurationsListResponse--;
}
core.List<api.Dimension> buildUnnamed103() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed103(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed104() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed104(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed105() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed105(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.int buildCounterFloodlightReportCompatibleFields = 0;
api.FloodlightReportCompatibleFields buildFloodlightReportCompatibleFields() {
final o = api.FloodlightReportCompatibleFields();
buildCounterFloodlightReportCompatibleFields++;
if (buildCounterFloodlightReportCompatibleFields < 3) {
o.dimensionFilters = buildUnnamed103();
o.dimensions = buildUnnamed104();
o.kind = 'foo';
o.metrics = buildUnnamed105();
}
buildCounterFloodlightReportCompatibleFields--;
return o;
}
void checkFloodlightReportCompatibleFields(
api.FloodlightReportCompatibleFields o) {
buildCounterFloodlightReportCompatibleFields++;
if (buildCounterFloodlightReportCompatibleFields < 3) {
checkUnnamed103(o.dimensionFilters!);
checkUnnamed104(o.dimensions!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed105(o.metrics!);
}
buildCounterFloodlightReportCompatibleFields--;
}
core.int buildCounterFrequencyCap = 0;
api.FrequencyCap buildFrequencyCap() {
final o = api.FrequencyCap();
buildCounterFrequencyCap++;
if (buildCounterFrequencyCap < 3) {
o.duration = 'foo';
o.impressions = 'foo';
}
buildCounterFrequencyCap--;
return o;
}
void checkFrequencyCap(api.FrequencyCap o) {
buildCounterFrequencyCap++;
if (buildCounterFrequencyCap < 3) {
unittest.expect(
o.duration!,
unittest.equals('foo'),
);
unittest.expect(
o.impressions!,
unittest.equals('foo'),
);
}
buildCounterFrequencyCap--;
}
core.int buildCounterFsCommand = 0;
api.FsCommand buildFsCommand() {
final o = api.FsCommand();
buildCounterFsCommand++;
if (buildCounterFsCommand < 3) {
o.left = 42;
o.positionOption = 'foo';
o.top = 42;
o.windowHeight = 42;
o.windowWidth = 42;
}
buildCounterFsCommand--;
return o;
}
void checkFsCommand(api.FsCommand o) {
buildCounterFsCommand++;
if (buildCounterFsCommand < 3) {
unittest.expect(
o.left!,
unittest.equals(42),
);
unittest.expect(
o.positionOption!,
unittest.equals('foo'),
);
unittest.expect(
o.top!,
unittest.equals(42),
);
unittest.expect(
o.windowHeight!,
unittest.equals(42),
);
unittest.expect(
o.windowWidth!,
unittest.equals(42),
);
}
buildCounterFsCommand--;
}
core.List<api.City> buildUnnamed106() => [
buildCity(),
buildCity(),
];
void checkUnnamed106(core.List<api.City> o) {
unittest.expect(o, unittest.hasLength(2));
checkCity(o[0]);
checkCity(o[1]);
}
core.List<api.Country> buildUnnamed107() => [
buildCountry(),
buildCountry(),
];
void checkUnnamed107(core.List<api.Country> o) {
unittest.expect(o, unittest.hasLength(2));
checkCountry(o[0]);
checkCountry(o[1]);
}
core.List<api.Metro> buildUnnamed108() => [
buildMetro(),
buildMetro(),
];
void checkUnnamed108(core.List<api.Metro> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetro(o[0]);
checkMetro(o[1]);
}
core.List<api.PostalCode> buildUnnamed109() => [
buildPostalCode(),
buildPostalCode(),
];
void checkUnnamed109(core.List<api.PostalCode> o) {
unittest.expect(o, unittest.hasLength(2));
checkPostalCode(o[0]);
checkPostalCode(o[1]);
}
core.List<api.Region> buildUnnamed110() => [
buildRegion(),
buildRegion(),
];
void checkUnnamed110(core.List<api.Region> o) {
unittest.expect(o, unittest.hasLength(2));
checkRegion(o[0]);
checkRegion(o[1]);
}
core.int buildCounterGeoTargeting = 0;
api.GeoTargeting buildGeoTargeting() {
final o = api.GeoTargeting();
buildCounterGeoTargeting++;
if (buildCounterGeoTargeting < 3) {
o.cities = buildUnnamed106();
o.countries = buildUnnamed107();
o.excludeCountries = true;
o.metros = buildUnnamed108();
o.postalCodes = buildUnnamed109();
o.regions = buildUnnamed110();
}
buildCounterGeoTargeting--;
return o;
}
void checkGeoTargeting(api.GeoTargeting o) {
buildCounterGeoTargeting++;
if (buildCounterGeoTargeting < 3) {
checkUnnamed106(o.cities!);
checkUnnamed107(o.countries!);
unittest.expect(o.excludeCountries!, unittest.isTrue);
checkUnnamed108(o.metros!);
checkUnnamed109(o.postalCodes!);
checkUnnamed110(o.regions!);
}
buildCounterGeoTargeting--;
}
core.List<api.AdSlot> buildUnnamed111() => [
buildAdSlot(),
buildAdSlot(),
];
void checkUnnamed111(core.List<api.AdSlot> o) {
unittest.expect(o, unittest.hasLength(2));
checkAdSlot(o[0]);
checkAdSlot(o[1]);
}
core.int buildCounterInventoryItem = 0;
api.InventoryItem buildInventoryItem() {
final o = api.InventoryItem();
buildCounterInventoryItem++;
if (buildCounterInventoryItem < 3) {
o.accountId = 'foo';
o.adSlots = buildUnnamed111();
o.advertiserId = 'foo';
o.contentCategoryId = 'foo';
o.estimatedClickThroughRate = 'foo';
o.estimatedConversionRate = 'foo';
o.id = 'foo';
o.inPlan = true;
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.name = 'foo';
o.negotiationChannelId = 'foo';
o.orderId = 'foo';
o.placementStrategyId = 'foo';
o.pricing = buildPricing();
o.projectId = 'foo';
o.rfpId = 'foo';
o.siteId = 'foo';
o.subaccountId = 'foo';
o.type = 'foo';
}
buildCounterInventoryItem--;
return o;
}
void checkInventoryItem(api.InventoryItem o) {
buildCounterInventoryItem++;
if (buildCounterInventoryItem < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
checkUnnamed111(o.adSlots!);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
unittest.expect(
o.contentCategoryId!,
unittest.equals('foo'),
);
unittest.expect(
o.estimatedClickThroughRate!,
unittest.equals('foo'),
);
unittest.expect(
o.estimatedConversionRate!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.inPlan!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.negotiationChannelId!,
unittest.equals('foo'),
);
unittest.expect(
o.orderId!,
unittest.equals('foo'),
);
unittest.expect(
o.placementStrategyId!,
unittest.equals('foo'),
);
checkPricing(o.pricing!);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.rfpId!,
unittest.equals('foo'),
);
unittest.expect(
o.siteId!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterInventoryItem--;
}
core.List<api.InventoryItem> buildUnnamed112() => [
buildInventoryItem(),
buildInventoryItem(),
];
void checkUnnamed112(core.List<api.InventoryItem> o) {
unittest.expect(o, unittest.hasLength(2));
checkInventoryItem(o[0]);
checkInventoryItem(o[1]);
}
core.int buildCounterInventoryItemsListResponse = 0;
api.InventoryItemsListResponse buildInventoryItemsListResponse() {
final o = api.InventoryItemsListResponse();
buildCounterInventoryItemsListResponse++;
if (buildCounterInventoryItemsListResponse < 3) {
o.inventoryItems = buildUnnamed112();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterInventoryItemsListResponse--;
return o;
}
void checkInventoryItemsListResponse(api.InventoryItemsListResponse o) {
buildCounterInventoryItemsListResponse++;
if (buildCounterInventoryItemsListResponse < 3) {
checkUnnamed112(o.inventoryItems!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterInventoryItemsListResponse--;
}
core.List<api.CampaignSummary> buildUnnamed113() => [
buildCampaignSummary(),
buildCampaignSummary(),
];
void checkUnnamed113(core.List<api.CampaignSummary> o) {
unittest.expect(o, unittest.hasLength(2));
checkCampaignSummary(o[0]);
checkCampaignSummary(o[1]);
}
core.List<core.String> buildUnnamed114() => [
'foo',
'foo',
];
void checkUnnamed114(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterInvoice = 0;
api.Invoice buildInvoice() {
final o = api.Invoice();
buildCounterInvoice++;
if (buildCounterInvoice < 3) {
o.campaignSummaries = buildUnnamed113();
o.correctedInvoiceId = 'foo';
o.currencyCode = 'foo';
o.dueDate = 'foo';
o.id = 'foo';
o.invoiceType = 'foo';
o.issueDate = 'foo';
o.kind = 'foo';
o.paymentsAccountId = 'foo';
o.paymentsProfileId = 'foo';
o.pdfUrl = 'foo';
o.purchaseOrderNumber = 'foo';
o.replacedInvoiceIds = buildUnnamed114();
o.serviceEndDate = 'foo';
o.serviceStartDate = 'foo';
o.subtotalAmountMicros = 'foo';
o.totalAmountMicros = 'foo';
o.totalTaxAmountMicros = 'foo';
}
buildCounterInvoice--;
return o;
}
void checkInvoice(api.Invoice o) {
buildCounterInvoice++;
if (buildCounterInvoice < 3) {
checkUnnamed113(o.campaignSummaries!);
unittest.expect(
o.correctedInvoiceId!,
unittest.equals('foo'),
);
unittest.expect(
o.currencyCode!,
unittest.equals('foo'),
);
unittest.expect(
o.dueDate!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.invoiceType!,
unittest.equals('foo'),
);
unittest.expect(
o.issueDate!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.paymentsAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.paymentsProfileId!,
unittest.equals('foo'),
);
unittest.expect(
o.pdfUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.purchaseOrderNumber!,
unittest.equals('foo'),
);
checkUnnamed114(o.replacedInvoiceIds!);
unittest.expect(
o.serviceEndDate!,
unittest.equals('foo'),
);
unittest.expect(
o.serviceStartDate!,
unittest.equals('foo'),
);
unittest.expect(
o.subtotalAmountMicros!,
unittest.equals('foo'),
);
unittest.expect(
o.totalAmountMicros!,
unittest.equals('foo'),
);
unittest.expect(
o.totalTaxAmountMicros!,
unittest.equals('foo'),
);
}
buildCounterInvoice--;
}
core.int buildCounterKeyValueTargetingExpression = 0;
api.KeyValueTargetingExpression buildKeyValueTargetingExpression() {
final o = api.KeyValueTargetingExpression();
buildCounterKeyValueTargetingExpression++;
if (buildCounterKeyValueTargetingExpression < 3) {
o.expression = 'foo';
}
buildCounterKeyValueTargetingExpression--;
return o;
}
void checkKeyValueTargetingExpression(api.KeyValueTargetingExpression o) {
buildCounterKeyValueTargetingExpression++;
if (buildCounterKeyValueTargetingExpression < 3) {
unittest.expect(
o.expression!,
unittest.equals('foo'),
);
}
buildCounterKeyValueTargetingExpression--;
}
core.List<api.DeepLink> buildUnnamed115() => [
buildDeepLink(),
buildDeepLink(),
];
void checkUnnamed115(core.List<api.DeepLink> o) {
unittest.expect(o, unittest.hasLength(2));
checkDeepLink(o[0]);
checkDeepLink(o[1]);
}
core.int buildCounterLandingPage = 0;
api.LandingPage buildLandingPage() {
final o = api.LandingPage();
buildCounterLandingPage++;
if (buildCounterLandingPage < 3) {
o.advertiserId = 'foo';
o.archived = true;
o.deepLinks = buildUnnamed115();
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.url = 'foo';
}
buildCounterLandingPage--;
return o;
}
void checkLandingPage(api.LandingPage o) {
buildCounterLandingPage++;
if (buildCounterLandingPage < 3) {
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
unittest.expect(o.archived!, unittest.isTrue);
checkUnnamed115(o.deepLinks!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.url!,
unittest.equals('foo'),
);
}
buildCounterLandingPage--;
}
core.int buildCounterLanguage = 0;
api.Language buildLanguage() {
final o = api.Language();
buildCounterLanguage++;
if (buildCounterLanguage < 3) {
o.id = 'foo';
o.kind = 'foo';
o.languageCode = 'foo';
o.name = 'foo';
}
buildCounterLanguage--;
return o;
}
void checkLanguage(api.Language o) {
buildCounterLanguage++;
if (buildCounterLanguage < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.languageCode!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLanguage--;
}
core.List<api.Language> buildUnnamed116() => [
buildLanguage(),
buildLanguage(),
];
void checkUnnamed116(core.List<api.Language> o) {
unittest.expect(o, unittest.hasLength(2));
checkLanguage(o[0]);
checkLanguage(o[1]);
}
core.int buildCounterLanguageTargeting = 0;
api.LanguageTargeting buildLanguageTargeting() {
final o = api.LanguageTargeting();
buildCounterLanguageTargeting++;
if (buildCounterLanguageTargeting < 3) {
o.languages = buildUnnamed116();
}
buildCounterLanguageTargeting--;
return o;
}
void checkLanguageTargeting(api.LanguageTargeting o) {
buildCounterLanguageTargeting++;
if (buildCounterLanguageTargeting < 3) {
checkUnnamed116(o.languages!);
}
buildCounterLanguageTargeting--;
}
core.List<api.Language> buildUnnamed117() => [
buildLanguage(),
buildLanguage(),
];
void checkUnnamed117(core.List<api.Language> o) {
unittest.expect(o, unittest.hasLength(2));
checkLanguage(o[0]);
checkLanguage(o[1]);
}
core.int buildCounterLanguagesListResponse = 0;
api.LanguagesListResponse buildLanguagesListResponse() {
final o = api.LanguagesListResponse();
buildCounterLanguagesListResponse++;
if (buildCounterLanguagesListResponse < 3) {
o.kind = 'foo';
o.languages = buildUnnamed117();
}
buildCounterLanguagesListResponse--;
return o;
}
void checkLanguagesListResponse(api.LanguagesListResponse o) {
buildCounterLanguagesListResponse++;
if (buildCounterLanguagesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed117(o.languages!);
}
buildCounterLanguagesListResponse--;
}
core.int buildCounterLastModifiedInfo = 0;
api.LastModifiedInfo buildLastModifiedInfo() {
final o = api.LastModifiedInfo();
buildCounterLastModifiedInfo++;
if (buildCounterLastModifiedInfo < 3) {
o.time = 'foo';
}
buildCounterLastModifiedInfo--;
return o;
}
void checkLastModifiedInfo(api.LastModifiedInfo o) {
buildCounterLastModifiedInfo++;
if (buildCounterLastModifiedInfo < 3) {
unittest.expect(
o.time!,
unittest.equals('foo'),
);
}
buildCounterLastModifiedInfo--;
}
core.List<api.ListPopulationTerm> buildUnnamed118() => [
buildListPopulationTerm(),
buildListPopulationTerm(),
];
void checkUnnamed118(core.List<api.ListPopulationTerm> o) {
unittest.expect(o, unittest.hasLength(2));
checkListPopulationTerm(o[0]);
checkListPopulationTerm(o[1]);
}
core.int buildCounterListPopulationClause = 0;
api.ListPopulationClause buildListPopulationClause() {
final o = api.ListPopulationClause();
buildCounterListPopulationClause++;
if (buildCounterListPopulationClause < 3) {
o.terms = buildUnnamed118();
}
buildCounterListPopulationClause--;
return o;
}
void checkListPopulationClause(api.ListPopulationClause o) {
buildCounterListPopulationClause++;
if (buildCounterListPopulationClause < 3) {
checkUnnamed118(o.terms!);
}
buildCounterListPopulationClause--;
}
core.List<api.ListPopulationClause> buildUnnamed119() => [
buildListPopulationClause(),
buildListPopulationClause(),
];
void checkUnnamed119(core.List<api.ListPopulationClause> o) {
unittest.expect(o, unittest.hasLength(2));
checkListPopulationClause(o[0]);
checkListPopulationClause(o[1]);
}
core.int buildCounterListPopulationRule = 0;
api.ListPopulationRule buildListPopulationRule() {
final o = api.ListPopulationRule();
buildCounterListPopulationRule++;
if (buildCounterListPopulationRule < 3) {
o.floodlightActivityId = 'foo';
o.floodlightActivityName = 'foo';
o.listPopulationClauses = buildUnnamed119();
}
buildCounterListPopulationRule--;
return o;
}
void checkListPopulationRule(api.ListPopulationRule o) {
buildCounterListPopulationRule++;
if (buildCounterListPopulationRule < 3) {
unittest.expect(
o.floodlightActivityId!,
unittest.equals('foo'),
);
unittest.expect(
o.floodlightActivityName!,
unittest.equals('foo'),
);
checkUnnamed119(o.listPopulationClauses!);
}
buildCounterListPopulationRule--;
}
core.int buildCounterListPopulationTerm = 0;
api.ListPopulationTerm buildListPopulationTerm() {
final o = api.ListPopulationTerm();
buildCounterListPopulationTerm++;
if (buildCounterListPopulationTerm < 3) {
o.contains = true;
o.negation = true;
o.operator = 'foo';
o.remarketingListId = 'foo';
o.type = 'foo';
o.value = 'foo';
o.variableFriendlyName = 'foo';
o.variableName = 'foo';
}
buildCounterListPopulationTerm--;
return o;
}
void checkListPopulationTerm(api.ListPopulationTerm o) {
buildCounterListPopulationTerm++;
if (buildCounterListPopulationTerm < 3) {
unittest.expect(o.contains!, unittest.isTrue);
unittest.expect(o.negation!, unittest.isTrue);
unittest.expect(
o.operator!,
unittest.equals('foo'),
);
unittest.expect(
o.remarketingListId!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
unittest.expect(
o.variableFriendlyName!,
unittest.equals('foo'),
);
unittest.expect(
o.variableName!,
unittest.equals('foo'),
);
}
buildCounterListPopulationTerm--;
}
core.int buildCounterListTargetingExpression = 0;
api.ListTargetingExpression buildListTargetingExpression() {
final o = api.ListTargetingExpression();
buildCounterListTargetingExpression++;
if (buildCounterListTargetingExpression < 3) {
o.expression = 'foo';
}
buildCounterListTargetingExpression--;
return o;
}
void checkListTargetingExpression(api.ListTargetingExpression o) {
buildCounterListTargetingExpression++;
if (buildCounterListTargetingExpression < 3) {
unittest.expect(
o.expression!,
unittest.equals('foo'),
);
}
buildCounterListTargetingExpression--;
}
core.int buildCounterLookbackConfiguration = 0;
api.LookbackConfiguration buildLookbackConfiguration() {
final o = api.LookbackConfiguration();
buildCounterLookbackConfiguration++;
if (buildCounterLookbackConfiguration < 3) {
o.clickDuration = 42;
o.postImpressionActivitiesDuration = 42;
}
buildCounterLookbackConfiguration--;
return o;
}
void checkLookbackConfiguration(api.LookbackConfiguration o) {
buildCounterLookbackConfiguration++;
if (buildCounterLookbackConfiguration < 3) {
unittest.expect(
o.clickDuration!,
unittest.equals(42),
);
unittest.expect(
o.postImpressionActivitiesDuration!,
unittest.equals(42),
);
}
buildCounterLookbackConfiguration--;
}
core.int buildCounterMeasurementPartnerAdvertiserLink = 0;
api.MeasurementPartnerAdvertiserLink buildMeasurementPartnerAdvertiserLink() {
final o = api.MeasurementPartnerAdvertiserLink();
buildCounterMeasurementPartnerAdvertiserLink++;
if (buildCounterMeasurementPartnerAdvertiserLink < 3) {
o.linkStatus = 'foo';
o.measurementPartner = 'foo';
o.partnerAdvertiserId = 'foo';
}
buildCounterMeasurementPartnerAdvertiserLink--;
return o;
}
void checkMeasurementPartnerAdvertiserLink(
api.MeasurementPartnerAdvertiserLink o) {
buildCounterMeasurementPartnerAdvertiserLink++;
if (buildCounterMeasurementPartnerAdvertiserLink < 3) {
unittest.expect(
o.linkStatus!,
unittest.equals('foo'),
);
unittest.expect(
o.measurementPartner!,
unittest.equals('foo'),
);
unittest.expect(
o.partnerAdvertiserId!,
unittest.equals('foo'),
);
}
buildCounterMeasurementPartnerAdvertiserLink--;
}
core.int buildCounterMeasurementPartnerCampaignLink = 0;
api.MeasurementPartnerCampaignLink buildMeasurementPartnerCampaignLink() {
final o = api.MeasurementPartnerCampaignLink();
buildCounterMeasurementPartnerCampaignLink++;
if (buildCounterMeasurementPartnerCampaignLink < 3) {
o.linkStatus = 'foo';
o.measurementPartner = 'foo';
o.partnerCampaignId = 'foo';
}
buildCounterMeasurementPartnerCampaignLink--;
return o;
}
void checkMeasurementPartnerCampaignLink(api.MeasurementPartnerCampaignLink o) {
buildCounterMeasurementPartnerCampaignLink++;
if (buildCounterMeasurementPartnerCampaignLink < 3) {
unittest.expect(
o.linkStatus!,
unittest.equals('foo'),
);
unittest.expect(
o.measurementPartner!,
unittest.equals('foo'),
);
unittest.expect(
o.partnerCampaignId!,
unittest.equals('foo'),
);
}
buildCounterMeasurementPartnerCampaignLink--;
}
core.int buildCounterMeasurementPartnerWrappingData = 0;
api.MeasurementPartnerWrappingData buildMeasurementPartnerWrappingData() {
final o = api.MeasurementPartnerWrappingData();
buildCounterMeasurementPartnerWrappingData++;
if (buildCounterMeasurementPartnerWrappingData < 3) {
o.linkStatus = 'foo';
o.measurementPartner = 'foo';
o.tagWrappingMode = 'foo';
o.wrappedTag = 'foo';
}
buildCounterMeasurementPartnerWrappingData--;
return o;
}
void checkMeasurementPartnerWrappingData(api.MeasurementPartnerWrappingData o) {
buildCounterMeasurementPartnerWrappingData++;
if (buildCounterMeasurementPartnerWrappingData < 3) {
unittest.expect(
o.linkStatus!,
unittest.equals('foo'),
);
unittest.expect(
o.measurementPartner!,
unittest.equals('foo'),
);
unittest.expect(
o.tagWrappingMode!,
unittest.equals('foo'),
);
unittest.expect(
o.wrappedTag!,
unittest.equals('foo'),
);
}
buildCounterMeasurementPartnerWrappingData--;
}
core.int buildCounterMetric = 0;
api.Metric buildMetric() {
final o = api.Metric();
buildCounterMetric++;
if (buildCounterMetric < 3) {
o.kind = 'foo';
o.name = 'foo';
}
buildCounterMetric--;
return o;
}
void checkMetric(api.Metric o) {
buildCounterMetric++;
if (buildCounterMetric < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterMetric--;
}
core.int buildCounterMetro = 0;
api.Metro buildMetro() {
final o = api.Metro();
buildCounterMetro++;
if (buildCounterMetro < 3) {
o.countryCode = 'foo';
o.countryDartId = 'foo';
o.dartId = 'foo';
o.dmaId = 'foo';
o.kind = 'foo';
o.metroCode = 'foo';
o.name = 'foo';
}
buildCounterMetro--;
return o;
}
void checkMetro(api.Metro o) {
buildCounterMetro++;
if (buildCounterMetro < 3) {
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.countryDartId!,
unittest.equals('foo'),
);
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(
o.dmaId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.metroCode!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterMetro--;
}
core.List<api.Metro> buildUnnamed120() => [
buildMetro(),
buildMetro(),
];
void checkUnnamed120(core.List<api.Metro> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetro(o[0]);
checkMetro(o[1]);
}
core.int buildCounterMetrosListResponse = 0;
api.MetrosListResponse buildMetrosListResponse() {
final o = api.MetrosListResponse();
buildCounterMetrosListResponse++;
if (buildCounterMetrosListResponse < 3) {
o.kind = 'foo';
o.metros = buildUnnamed120();
}
buildCounterMetrosListResponse--;
return o;
}
void checkMetrosListResponse(api.MetrosListResponse o) {
buildCounterMetrosListResponse++;
if (buildCounterMetrosListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed120(o.metros!);
}
buildCounterMetrosListResponse--;
}
core.int buildCounterMobileApp = 0;
api.MobileApp buildMobileApp() {
final o = api.MobileApp();
buildCounterMobileApp++;
if (buildCounterMobileApp < 3) {
o.directory = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.publisherName = 'foo';
o.title = 'foo';
}
buildCounterMobileApp--;
return o;
}
void checkMobileApp(api.MobileApp o) {
buildCounterMobileApp++;
if (buildCounterMobileApp < 3) {
unittest.expect(
o.directory!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.publisherName!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterMobileApp--;
}
core.List<api.MobileApp> buildUnnamed121() => [
buildMobileApp(),
buildMobileApp(),
];
void checkUnnamed121(core.List<api.MobileApp> o) {
unittest.expect(o, unittest.hasLength(2));
checkMobileApp(o[0]);
checkMobileApp(o[1]);
}
core.int buildCounterMobileAppsListResponse = 0;
api.MobileAppsListResponse buildMobileAppsListResponse() {
final o = api.MobileAppsListResponse();
buildCounterMobileAppsListResponse++;
if (buildCounterMobileAppsListResponse < 3) {
o.kind = 'foo';
o.mobileApps = buildUnnamed121();
o.nextPageToken = 'foo';
}
buildCounterMobileAppsListResponse--;
return o;
}
void checkMobileAppsListResponse(api.MobileAppsListResponse o) {
buildCounterMobileAppsListResponse++;
if (buildCounterMobileAppsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed121(o.mobileApps!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterMobileAppsListResponse--;
}
core.int buildCounterMobileCarrier = 0;
api.MobileCarrier buildMobileCarrier() {
final o = api.MobileCarrier();
buildCounterMobileCarrier++;
if (buildCounterMobileCarrier < 3) {
o.countryCode = 'foo';
o.countryDartId = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterMobileCarrier--;
return o;
}
void checkMobileCarrier(api.MobileCarrier o) {
buildCounterMobileCarrier++;
if (buildCounterMobileCarrier < 3) {
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.countryDartId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterMobileCarrier--;
}
core.List<api.MobileCarrier> buildUnnamed122() => [
buildMobileCarrier(),
buildMobileCarrier(),
];
void checkUnnamed122(core.List<api.MobileCarrier> o) {
unittest.expect(o, unittest.hasLength(2));
checkMobileCarrier(o[0]);
checkMobileCarrier(o[1]);
}
core.int buildCounterMobileCarriersListResponse = 0;
api.MobileCarriersListResponse buildMobileCarriersListResponse() {
final o = api.MobileCarriersListResponse();
buildCounterMobileCarriersListResponse++;
if (buildCounterMobileCarriersListResponse < 3) {
o.kind = 'foo';
o.mobileCarriers = buildUnnamed122();
}
buildCounterMobileCarriersListResponse--;
return o;
}
void checkMobileCarriersListResponse(api.MobileCarriersListResponse o) {
buildCounterMobileCarriersListResponse++;
if (buildCounterMobileCarriersListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed122(o.mobileCarriers!);
}
buildCounterMobileCarriersListResponse--;
}
core.int buildCounterObaIcon = 0;
api.ObaIcon buildObaIcon() {
final o = api.ObaIcon();
buildCounterObaIcon++;
if (buildCounterObaIcon < 3) {
o.iconClickThroughUrl = 'foo';
o.iconClickTrackingUrl = 'foo';
o.iconViewTrackingUrl = 'foo';
o.program = 'foo';
o.resourceUrl = 'foo';
o.size = buildSize();
o.xPosition = 'foo';
o.yPosition = 'foo';
}
buildCounterObaIcon--;
return o;
}
void checkObaIcon(api.ObaIcon o) {
buildCounterObaIcon++;
if (buildCounterObaIcon < 3) {
unittest.expect(
o.iconClickThroughUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.iconClickTrackingUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.iconViewTrackingUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.program!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceUrl!,
unittest.equals('foo'),
);
checkSize(o.size!);
unittest.expect(
o.xPosition!,
unittest.equals('foo'),
);
unittest.expect(
o.yPosition!,
unittest.equals('foo'),
);
}
buildCounterObaIcon--;
}
core.List<core.String> buildUnnamed123() => [
'foo',
'foo',
];
void checkUnnamed123(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterObjectFilter = 0;
api.ObjectFilter buildObjectFilter() {
final o = api.ObjectFilter();
buildCounterObjectFilter++;
if (buildCounterObjectFilter < 3) {
o.kind = 'foo';
o.objectIds = buildUnnamed123();
o.status = 'foo';
}
buildCounterObjectFilter--;
return o;
}
void checkObjectFilter(api.ObjectFilter o) {
buildCounterObjectFilter++;
if (buildCounterObjectFilter < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed123(o.objectIds!);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
}
buildCounterObjectFilter--;
}
core.int buildCounterOfflineUserAddressInfo = 0;
api.OfflineUserAddressInfo buildOfflineUserAddressInfo() {
final o = api.OfflineUserAddressInfo();
buildCounterOfflineUserAddressInfo++;
if (buildCounterOfflineUserAddressInfo < 3) {
o.city = 'foo';
o.countryCode = 'foo';
o.hashedFirstName = 'foo';
o.hashedLastName = 'foo';
o.hashedStreetAddress = 'foo';
o.postalCode = 'foo';
o.state = 'foo';
}
buildCounterOfflineUserAddressInfo--;
return o;
}
void checkOfflineUserAddressInfo(api.OfflineUserAddressInfo o) {
buildCounterOfflineUserAddressInfo++;
if (buildCounterOfflineUserAddressInfo < 3) {
unittest.expect(
o.city!,
unittest.equals('foo'),
);
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.hashedFirstName!,
unittest.equals('foo'),
);
unittest.expect(
o.hashedLastName!,
unittest.equals('foo'),
);
unittest.expect(
o.hashedStreetAddress!,
unittest.equals('foo'),
);
unittest.expect(
o.postalCode!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
}
buildCounterOfflineUserAddressInfo--;
}
core.int buildCounterOffsetPosition = 0;
api.OffsetPosition buildOffsetPosition() {
final o = api.OffsetPosition();
buildCounterOffsetPosition++;
if (buildCounterOffsetPosition < 3) {
o.left = 42;
o.top = 42;
}
buildCounterOffsetPosition--;
return o;
}
void checkOffsetPosition(api.OffsetPosition o) {
buildCounterOffsetPosition++;
if (buildCounterOffsetPosition < 3) {
unittest.expect(
o.left!,
unittest.equals(42),
);
unittest.expect(
o.top!,
unittest.equals(42),
);
}
buildCounterOffsetPosition--;
}
core.int buildCounterOmnitureSettings = 0;
api.OmnitureSettings buildOmnitureSettings() {
final o = api.OmnitureSettings();
buildCounterOmnitureSettings++;
if (buildCounterOmnitureSettings < 3) {
o.omnitureCostDataEnabled = true;
o.omnitureIntegrationEnabled = true;
}
buildCounterOmnitureSettings--;
return o;
}
void checkOmnitureSettings(api.OmnitureSettings o) {
buildCounterOmnitureSettings++;
if (buildCounterOmnitureSettings < 3) {
unittest.expect(o.omnitureCostDataEnabled!, unittest.isTrue);
unittest.expect(o.omnitureIntegrationEnabled!, unittest.isTrue);
}
buildCounterOmnitureSettings--;
}
core.int buildCounterOperatingSystem = 0;
api.OperatingSystem buildOperatingSystem() {
final o = api.OperatingSystem();
buildCounterOperatingSystem++;
if (buildCounterOperatingSystem < 3) {
o.dartId = 'foo';
o.desktop = true;
o.kind = 'foo';
o.mobile = true;
o.name = 'foo';
}
buildCounterOperatingSystem--;
return o;
}
void checkOperatingSystem(api.OperatingSystem o) {
buildCounterOperatingSystem++;
if (buildCounterOperatingSystem < 3) {
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(o.desktop!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.mobile!, unittest.isTrue);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterOperatingSystem--;
}
core.int buildCounterOperatingSystemVersion = 0;
api.OperatingSystemVersion buildOperatingSystemVersion() {
final o = api.OperatingSystemVersion();
buildCounterOperatingSystemVersion++;
if (buildCounterOperatingSystemVersion < 3) {
o.id = 'foo';
o.kind = 'foo';
o.majorVersion = 'foo';
o.minorVersion = 'foo';
o.name = 'foo';
o.operatingSystem = buildOperatingSystem();
}
buildCounterOperatingSystemVersion--;
return o;
}
void checkOperatingSystemVersion(api.OperatingSystemVersion o) {
buildCounterOperatingSystemVersion++;
if (buildCounterOperatingSystemVersion < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.majorVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.minorVersion!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkOperatingSystem(o.operatingSystem!);
}
buildCounterOperatingSystemVersion--;
}
core.List<api.OperatingSystemVersion> buildUnnamed124() => [
buildOperatingSystemVersion(),
buildOperatingSystemVersion(),
];
void checkUnnamed124(core.List<api.OperatingSystemVersion> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperatingSystemVersion(o[0]);
checkOperatingSystemVersion(o[1]);
}
core.int buildCounterOperatingSystemVersionsListResponse = 0;
api.OperatingSystemVersionsListResponse
buildOperatingSystemVersionsListResponse() {
final o = api.OperatingSystemVersionsListResponse();
buildCounterOperatingSystemVersionsListResponse++;
if (buildCounterOperatingSystemVersionsListResponse < 3) {
o.kind = 'foo';
o.operatingSystemVersions = buildUnnamed124();
}
buildCounterOperatingSystemVersionsListResponse--;
return o;
}
void checkOperatingSystemVersionsListResponse(
api.OperatingSystemVersionsListResponse o) {
buildCounterOperatingSystemVersionsListResponse++;
if (buildCounterOperatingSystemVersionsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed124(o.operatingSystemVersions!);
}
buildCounterOperatingSystemVersionsListResponse--;
}
core.List<api.OperatingSystem> buildUnnamed125() => [
buildOperatingSystem(),
buildOperatingSystem(),
];
void checkUnnamed125(core.List<api.OperatingSystem> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperatingSystem(o[0]);
checkOperatingSystem(o[1]);
}
core.int buildCounterOperatingSystemsListResponse = 0;
api.OperatingSystemsListResponse buildOperatingSystemsListResponse() {
final o = api.OperatingSystemsListResponse();
buildCounterOperatingSystemsListResponse++;
if (buildCounterOperatingSystemsListResponse < 3) {
o.kind = 'foo';
o.operatingSystems = buildUnnamed125();
}
buildCounterOperatingSystemsListResponse--;
return o;
}
void checkOperatingSystemsListResponse(api.OperatingSystemsListResponse o) {
buildCounterOperatingSystemsListResponse++;
if (buildCounterOperatingSystemsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed125(o.operatingSystems!);
}
buildCounterOperatingSystemsListResponse--;
}
core.int buildCounterOptimizationActivity = 0;
api.OptimizationActivity buildOptimizationActivity() {
final o = api.OptimizationActivity();
buildCounterOptimizationActivity++;
if (buildCounterOptimizationActivity < 3) {
o.floodlightActivityId = 'foo';
o.floodlightActivityIdDimensionValue = buildDimensionValue();
o.weight = 42;
}
buildCounterOptimizationActivity--;
return o;
}
void checkOptimizationActivity(api.OptimizationActivity o) {
buildCounterOptimizationActivity++;
if (buildCounterOptimizationActivity < 3) {
unittest.expect(
o.floodlightActivityId!,
unittest.equals('foo'),
);
checkDimensionValue(o.floodlightActivityIdDimensionValue!);
unittest.expect(
o.weight!,
unittest.equals(42),
);
}
buildCounterOptimizationActivity--;
}
core.List<core.String> buildUnnamed126() => [
'foo',
'foo',
];
void checkUnnamed126(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.OrderContact> buildUnnamed127() => [
buildOrderContact(),
buildOrderContact(),
];
void checkUnnamed127(core.List<api.OrderContact> o) {
unittest.expect(o, unittest.hasLength(2));
checkOrderContact(o[0]);
checkOrderContact(o[1]);
}
core.List<core.String> buildUnnamed128() => [
'foo',
'foo',
];
void checkUnnamed128(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed129() => [
'foo',
'foo',
];
void checkUnnamed129(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterOrder = 0;
api.Order buildOrder() {
final o = api.Order();
buildCounterOrder++;
if (buildCounterOrder < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.approverUserProfileIds = buildUnnamed126();
o.buyerInvoiceId = 'foo';
o.buyerOrganizationName = 'foo';
o.comments = 'foo';
o.contacts = buildUnnamed127();
o.id = 'foo';
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.name = 'foo';
o.notes = 'foo';
o.planningTermId = 'foo';
o.projectId = 'foo';
o.sellerOrderId = 'foo';
o.sellerOrganizationName = 'foo';
o.siteId = buildUnnamed128();
o.siteNames = buildUnnamed129();
o.subaccountId = 'foo';
o.termsAndConditions = 'foo';
}
buildCounterOrder--;
return o;
}
void checkOrder(api.Order o) {
buildCounterOrder++;
if (buildCounterOrder < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkUnnamed126(o.approverUserProfileIds!);
unittest.expect(
o.buyerInvoiceId!,
unittest.equals('foo'),
);
unittest.expect(
o.buyerOrganizationName!,
unittest.equals('foo'),
);
unittest.expect(
o.comments!,
unittest.equals('foo'),
);
checkUnnamed127(o.contacts!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.notes!,
unittest.equals('foo'),
);
unittest.expect(
o.planningTermId!,
unittest.equals('foo'),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
unittest.expect(
o.sellerOrderId!,
unittest.equals('foo'),
);
unittest.expect(
o.sellerOrganizationName!,
unittest.equals('foo'),
);
checkUnnamed128(o.siteId!);
checkUnnamed129(o.siteNames!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.termsAndConditions!,
unittest.equals('foo'),
);
}
buildCounterOrder--;
}
core.int buildCounterOrderContact = 0;
api.OrderContact buildOrderContact() {
final o = api.OrderContact();
buildCounterOrderContact++;
if (buildCounterOrderContact < 3) {
o.contactInfo = 'foo';
o.contactName = 'foo';
o.contactTitle = 'foo';
o.contactType = 'foo';
o.signatureUserProfileId = 'foo';
}
buildCounterOrderContact--;
return o;
}
void checkOrderContact(api.OrderContact o) {
buildCounterOrderContact++;
if (buildCounterOrderContact < 3) {
unittest.expect(
o.contactInfo!,
unittest.equals('foo'),
);
unittest.expect(
o.contactName!,
unittest.equals('foo'),
);
unittest.expect(
o.contactTitle!,
unittest.equals('foo'),
);
unittest.expect(
o.contactType!,
unittest.equals('foo'),
);
unittest.expect(
o.signatureUserProfileId!,
unittest.equals('foo'),
);
}
buildCounterOrderContact--;
}
core.List<api.Order> buildUnnamed130() => [
buildOrder(),
buildOrder(),
];
void checkUnnamed130(core.List<api.Order> o) {
unittest.expect(o, unittest.hasLength(2));
checkOrder(o[0]);
checkOrder(o[1]);
}
core.int buildCounterOrdersListResponse = 0;
api.OrdersListResponse buildOrdersListResponse() {
final o = api.OrdersListResponse();
buildCounterOrdersListResponse++;
if (buildCounterOrdersListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.orders = buildUnnamed130();
}
buildCounterOrdersListResponse--;
return o;
}
void checkOrdersListResponse(api.OrdersListResponse o) {
buildCounterOrdersListResponse++;
if (buildCounterOrdersListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed130(o.orders!);
}
buildCounterOrdersListResponse--;
}
core.List<api.EventFilter> buildUnnamed131() => [
buildEventFilter(),
buildEventFilter(),
];
void checkUnnamed131(core.List<api.EventFilter> o) {
unittest.expect(o, unittest.hasLength(2));
checkEventFilter(o[0]);
checkEventFilter(o[1]);
}
core.int buildCounterPathFilter = 0;
api.PathFilter buildPathFilter() {
final o = api.PathFilter();
buildCounterPathFilter++;
if (buildCounterPathFilter < 3) {
o.eventFilters = buildUnnamed131();
o.kind = 'foo';
o.pathMatchPosition = 'foo';
}
buildCounterPathFilter--;
return o;
}
void checkPathFilter(api.PathFilter o) {
buildCounterPathFilter++;
if (buildCounterPathFilter < 3) {
checkUnnamed131(o.eventFilters!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.pathMatchPosition!,
unittest.equals('foo'),
);
}
buildCounterPathFilter--;
}
core.List<api.Dimension> buildUnnamed132() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed132(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed133() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed133(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed134() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed134(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Dimension> buildUnnamed135() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed135(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.int buildCounterPathReportCompatibleFields = 0;
api.PathReportCompatibleFields buildPathReportCompatibleFields() {
final o = api.PathReportCompatibleFields();
buildCounterPathReportCompatibleFields++;
if (buildCounterPathReportCompatibleFields < 3) {
o.channelGroupings = buildUnnamed132();
o.dimensions = buildUnnamed133();
o.kind = 'foo';
o.metrics = buildUnnamed134();
o.pathFilters = buildUnnamed135();
}
buildCounterPathReportCompatibleFields--;
return o;
}
void checkPathReportCompatibleFields(api.PathReportCompatibleFields o) {
buildCounterPathReportCompatibleFields++;
if (buildCounterPathReportCompatibleFields < 3) {
checkUnnamed132(o.channelGroupings!);
checkUnnamed133(o.dimensions!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed134(o.metrics!);
checkUnnamed135(o.pathFilters!);
}
buildCounterPathReportCompatibleFields--;
}
core.List<core.String> buildUnnamed136() => [
'foo',
'foo',
];
void checkUnnamed136(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed137() => [
'foo',
'foo',
];
void checkUnnamed137(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterPathReportDimensionValue = 0;
api.PathReportDimensionValue buildPathReportDimensionValue() {
final o = api.PathReportDimensionValue();
buildCounterPathReportDimensionValue++;
if (buildCounterPathReportDimensionValue < 3) {
o.dimensionName = 'foo';
o.ids = buildUnnamed136();
o.kind = 'foo';
o.matchType = 'foo';
o.values = buildUnnamed137();
}
buildCounterPathReportDimensionValue--;
return o;
}
void checkPathReportDimensionValue(api.PathReportDimensionValue o) {
buildCounterPathReportDimensionValue++;
if (buildCounterPathReportDimensionValue < 3) {
unittest.expect(
o.dimensionName!,
unittest.equals('foo'),
);
checkUnnamed136(o.ids!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.matchType!,
unittest.equals('foo'),
);
checkUnnamed137(o.values!);
}
buildCounterPathReportDimensionValue--;
}
core.List<api.Dimension> buildUnnamed138() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed138(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed139() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed139(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed140() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed140(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Dimension> buildUnnamed141() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed141(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.int buildCounterPathToConversionReportCompatibleFields = 0;
api.PathToConversionReportCompatibleFields
buildPathToConversionReportCompatibleFields() {
final o = api.PathToConversionReportCompatibleFields();
buildCounterPathToConversionReportCompatibleFields++;
if (buildCounterPathToConversionReportCompatibleFields < 3) {
o.conversionDimensions = buildUnnamed138();
o.customFloodlightVariables = buildUnnamed139();
o.kind = 'foo';
o.metrics = buildUnnamed140();
o.perInteractionDimensions = buildUnnamed141();
}
buildCounterPathToConversionReportCompatibleFields--;
return o;
}
void checkPathToConversionReportCompatibleFields(
api.PathToConversionReportCompatibleFields o) {
buildCounterPathToConversionReportCompatibleFields++;
if (buildCounterPathToConversionReportCompatibleFields < 3) {
checkUnnamed138(o.conversionDimensions!);
checkUnnamed139(o.customFloodlightVariables!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed140(o.metrics!);
checkUnnamed141(o.perInteractionDimensions!);
}
buildCounterPathToConversionReportCompatibleFields--;
}
core.List<api.Size> buildUnnamed142() => [
buildSize(),
buildSize(),
];
void checkUnnamed142(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.List<core.String> buildUnnamed143() => [
'foo',
'foo',
];
void checkUnnamed143(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterPlacement = 0;
api.Placement buildPlacement() {
final o = api.Placement();
buildCounterPlacement++;
if (buildCounterPlacement < 3) {
o.accountId = 'foo';
o.activeStatus = 'foo';
o.adBlockingOptOut = true;
o.additionalSizes = buildUnnamed142();
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.campaignId = 'foo';
o.campaignIdDimensionValue = buildDimensionValue();
o.comment = 'foo';
o.compatibility = 'foo';
o.contentCategoryId = 'foo';
o.createInfo = buildLastModifiedInfo();
o.directorySiteId = 'foo';
o.directorySiteIdDimensionValue = buildDimensionValue();
o.externalId = 'foo';
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.keyName = 'foo';
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.lookbackConfiguration = buildLookbackConfiguration();
o.name = 'foo';
o.partnerWrappingData = buildMeasurementPartnerWrappingData();
o.paymentApproved = true;
o.paymentSource = 'foo';
o.placementGroupId = 'foo';
o.placementGroupIdDimensionValue = buildDimensionValue();
o.placementStrategyId = 'foo';
o.pricingSchedule = buildPricingSchedule();
o.primary = true;
o.publisherUpdateInfo = buildLastModifiedInfo();
o.siteId = 'foo';
o.siteIdDimensionValue = buildDimensionValue();
o.size = buildSize();
o.sslRequired = true;
o.status = 'foo';
o.subaccountId = 'foo';
o.tagFormats = buildUnnamed143();
o.tagSetting = buildTagSetting();
o.videoActiveViewOptOut = true;
o.videoSettings = buildVideoSettings();
o.vpaidAdapterChoice = 'foo';
o.wrappingOptOut = true;
}
buildCounterPlacement--;
return o;
}
void checkPlacement(api.Placement o) {
buildCounterPlacement++;
if (buildCounterPlacement < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.activeStatus!,
unittest.equals('foo'),
);
unittest.expect(o.adBlockingOptOut!, unittest.isTrue);
checkUnnamed142(o.additionalSizes!);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
checkDimensionValue(o.campaignIdDimensionValue!);
unittest.expect(
o.comment!,
unittest.equals('foo'),
);
unittest.expect(
o.compatibility!,
unittest.equals('foo'),
);
unittest.expect(
o.contentCategoryId!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.createInfo!);
unittest.expect(
o.directorySiteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.directorySiteIdDimensionValue!);
unittest.expect(
o.externalId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.keyName!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
checkLookbackConfiguration(o.lookbackConfiguration!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkMeasurementPartnerWrappingData(o.partnerWrappingData!);
unittest.expect(o.paymentApproved!, unittest.isTrue);
unittest.expect(
o.paymentSource!,
unittest.equals('foo'),
);
unittest.expect(
o.placementGroupId!,
unittest.equals('foo'),
);
checkDimensionValue(o.placementGroupIdDimensionValue!);
unittest.expect(
o.placementStrategyId!,
unittest.equals('foo'),
);
checkPricingSchedule(o.pricingSchedule!);
unittest.expect(o.primary!, unittest.isTrue);
checkLastModifiedInfo(o.publisherUpdateInfo!);
unittest.expect(
o.siteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.siteIdDimensionValue!);
checkSize(o.size!);
unittest.expect(o.sslRequired!, unittest.isTrue);
unittest.expect(
o.status!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
checkUnnamed143(o.tagFormats!);
checkTagSetting(o.tagSetting!);
unittest.expect(o.videoActiveViewOptOut!, unittest.isTrue);
checkVideoSettings(o.videoSettings!);
unittest.expect(
o.vpaidAdapterChoice!,
unittest.equals('foo'),
);
unittest.expect(o.wrappingOptOut!, unittest.isTrue);
}
buildCounterPlacement--;
}
core.int buildCounterPlacementAssignment = 0;
api.PlacementAssignment buildPlacementAssignment() {
final o = api.PlacementAssignment();
buildCounterPlacementAssignment++;
if (buildCounterPlacementAssignment < 3) {
o.active = true;
o.placementId = 'foo';
o.placementIdDimensionValue = buildDimensionValue();
o.sslRequired = true;
}
buildCounterPlacementAssignment--;
return o;
}
void checkPlacementAssignment(api.PlacementAssignment o) {
buildCounterPlacementAssignment++;
if (buildCounterPlacementAssignment < 3) {
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.placementId!,
unittest.equals('foo'),
);
checkDimensionValue(o.placementIdDimensionValue!);
unittest.expect(o.sslRequired!, unittest.isTrue);
}
buildCounterPlacementAssignment--;
}
core.List<core.String> buildUnnamed144() => [
'foo',
'foo',
];
void checkUnnamed144(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterPlacementGroup = 0;
api.PlacementGroup buildPlacementGroup() {
final o = api.PlacementGroup();
buildCounterPlacementGroup++;
if (buildCounterPlacementGroup < 3) {
o.accountId = 'foo';
o.activeStatus = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.campaignId = 'foo';
o.campaignIdDimensionValue = buildDimensionValue();
o.childPlacementIds = buildUnnamed144();
o.comment = 'foo';
o.contentCategoryId = 'foo';
o.createInfo = buildLastModifiedInfo();
o.directorySiteId = 'foo';
o.directorySiteIdDimensionValue = buildDimensionValue();
o.externalId = 'foo';
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.name = 'foo';
o.placementGroupType = 'foo';
o.placementStrategyId = 'foo';
o.pricingSchedule = buildPricingSchedule();
o.primaryPlacementId = 'foo';
o.primaryPlacementIdDimensionValue = buildDimensionValue();
o.siteId = 'foo';
o.siteIdDimensionValue = buildDimensionValue();
o.subaccountId = 'foo';
}
buildCounterPlacementGroup--;
return o;
}
void checkPlacementGroup(api.PlacementGroup o) {
buildCounterPlacementGroup++;
if (buildCounterPlacementGroup < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.activeStatus!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.campaignId!,
unittest.equals('foo'),
);
checkDimensionValue(o.campaignIdDimensionValue!);
checkUnnamed144(o.childPlacementIds!);
unittest.expect(
o.comment!,
unittest.equals('foo'),
);
unittest.expect(
o.contentCategoryId!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.createInfo!);
unittest.expect(
o.directorySiteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.directorySiteIdDimensionValue!);
unittest.expect(
o.externalId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.placementGroupType!,
unittest.equals('foo'),
);
unittest.expect(
o.placementStrategyId!,
unittest.equals('foo'),
);
checkPricingSchedule(o.pricingSchedule!);
unittest.expect(
o.primaryPlacementId!,
unittest.equals('foo'),
);
checkDimensionValue(o.primaryPlacementIdDimensionValue!);
unittest.expect(
o.siteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.siteIdDimensionValue!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterPlacementGroup--;
}
core.List<api.PlacementGroup> buildUnnamed145() => [
buildPlacementGroup(),
buildPlacementGroup(),
];
void checkUnnamed145(core.List<api.PlacementGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlacementGroup(o[0]);
checkPlacementGroup(o[1]);
}
core.int buildCounterPlacementGroupsListResponse = 0;
api.PlacementGroupsListResponse buildPlacementGroupsListResponse() {
final o = api.PlacementGroupsListResponse();
buildCounterPlacementGroupsListResponse++;
if (buildCounterPlacementGroupsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.placementGroups = buildUnnamed145();
}
buildCounterPlacementGroupsListResponse--;
return o;
}
void checkPlacementGroupsListResponse(api.PlacementGroupsListResponse o) {
buildCounterPlacementGroupsListResponse++;
if (buildCounterPlacementGroupsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed145(o.placementGroups!);
}
buildCounterPlacementGroupsListResponse--;
}
core.List<api.PlacementStrategy> buildUnnamed146() => [
buildPlacementStrategy(),
buildPlacementStrategy(),
];
void checkUnnamed146(core.List<api.PlacementStrategy> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlacementStrategy(o[0]);
checkPlacementStrategy(o[1]);
}
core.int buildCounterPlacementStrategiesListResponse = 0;
api.PlacementStrategiesListResponse buildPlacementStrategiesListResponse() {
final o = api.PlacementStrategiesListResponse();
buildCounterPlacementStrategiesListResponse++;
if (buildCounterPlacementStrategiesListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.placementStrategies = buildUnnamed146();
}
buildCounterPlacementStrategiesListResponse--;
return o;
}
void checkPlacementStrategiesListResponse(
api.PlacementStrategiesListResponse o) {
buildCounterPlacementStrategiesListResponse++;
if (buildCounterPlacementStrategiesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed146(o.placementStrategies!);
}
buildCounterPlacementStrategiesListResponse--;
}
core.int buildCounterPlacementStrategy = 0;
api.PlacementStrategy buildPlacementStrategy() {
final o = api.PlacementStrategy();
buildCounterPlacementStrategy++;
if (buildCounterPlacementStrategy < 3) {
o.accountId = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterPlacementStrategy--;
return o;
}
void checkPlacementStrategy(api.PlacementStrategy o) {
buildCounterPlacementStrategy++;
if (buildCounterPlacementStrategy < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterPlacementStrategy--;
}
core.List<api.TagData> buildUnnamed147() => [
buildTagData(),
buildTagData(),
];
void checkUnnamed147(core.List<api.TagData> o) {
unittest.expect(o, unittest.hasLength(2));
checkTagData(o[0]);
checkTagData(o[1]);
}
core.int buildCounterPlacementTag = 0;
api.PlacementTag buildPlacementTag() {
final o = api.PlacementTag();
buildCounterPlacementTag++;
if (buildCounterPlacementTag < 3) {
o.placementId = 'foo';
o.tagDatas = buildUnnamed147();
}
buildCounterPlacementTag--;
return o;
}
void checkPlacementTag(api.PlacementTag o) {
buildCounterPlacementTag++;
if (buildCounterPlacementTag < 3) {
unittest.expect(
o.placementId!,
unittest.equals('foo'),
);
checkUnnamed147(o.tagDatas!);
}
buildCounterPlacementTag--;
}
core.List<api.PlacementTag> buildUnnamed148() => [
buildPlacementTag(),
buildPlacementTag(),
];
void checkUnnamed148(core.List<api.PlacementTag> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlacementTag(o[0]);
checkPlacementTag(o[1]);
}
core.int buildCounterPlacementsGenerateTagsResponse = 0;
api.PlacementsGenerateTagsResponse buildPlacementsGenerateTagsResponse() {
final o = api.PlacementsGenerateTagsResponse();
buildCounterPlacementsGenerateTagsResponse++;
if (buildCounterPlacementsGenerateTagsResponse < 3) {
o.kind = 'foo';
o.placementTags = buildUnnamed148();
}
buildCounterPlacementsGenerateTagsResponse--;
return o;
}
void checkPlacementsGenerateTagsResponse(api.PlacementsGenerateTagsResponse o) {
buildCounterPlacementsGenerateTagsResponse++;
if (buildCounterPlacementsGenerateTagsResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed148(o.placementTags!);
}
buildCounterPlacementsGenerateTagsResponse--;
}
core.List<api.Placement> buildUnnamed149() => [
buildPlacement(),
buildPlacement(),
];
void checkUnnamed149(core.List<api.Placement> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlacement(o[0]);
checkPlacement(o[1]);
}
core.int buildCounterPlacementsListResponse = 0;
api.PlacementsListResponse buildPlacementsListResponse() {
final o = api.PlacementsListResponse();
buildCounterPlacementsListResponse++;
if (buildCounterPlacementsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.placements = buildUnnamed149();
}
buildCounterPlacementsListResponse--;
return o;
}
void checkPlacementsListResponse(api.PlacementsListResponse o) {
buildCounterPlacementsListResponse++;
if (buildCounterPlacementsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed149(o.placements!);
}
buildCounterPlacementsListResponse--;
}
core.int buildCounterPlatformType = 0;
api.PlatformType buildPlatformType() {
final o = api.PlatformType();
buildCounterPlatformType++;
if (buildCounterPlatformType < 3) {
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterPlatformType--;
return o;
}
void checkPlatformType(api.PlatformType o) {
buildCounterPlatformType++;
if (buildCounterPlatformType < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterPlatformType--;
}
core.List<api.PlatformType> buildUnnamed150() => [
buildPlatformType(),
buildPlatformType(),
];
void checkUnnamed150(core.List<api.PlatformType> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlatformType(o[0]);
checkPlatformType(o[1]);
}
core.int buildCounterPlatformTypesListResponse = 0;
api.PlatformTypesListResponse buildPlatformTypesListResponse() {
final o = api.PlatformTypesListResponse();
buildCounterPlatformTypesListResponse++;
if (buildCounterPlatformTypesListResponse < 3) {
o.kind = 'foo';
o.platformTypes = buildUnnamed150();
}
buildCounterPlatformTypesListResponse--;
return o;
}
void checkPlatformTypesListResponse(api.PlatformTypesListResponse o) {
buildCounterPlatformTypesListResponse++;
if (buildCounterPlatformTypesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed150(o.platformTypes!);
}
buildCounterPlatformTypesListResponse--;
}
core.int buildCounterPopupWindowProperties = 0;
api.PopupWindowProperties buildPopupWindowProperties() {
final o = api.PopupWindowProperties();
buildCounterPopupWindowProperties++;
if (buildCounterPopupWindowProperties < 3) {
o.dimension = buildSize();
o.offset = buildOffsetPosition();
o.positionType = 'foo';
o.showAddressBar = true;
o.showMenuBar = true;
o.showScrollBar = true;
o.showStatusBar = true;
o.showToolBar = true;
o.title = 'foo';
}
buildCounterPopupWindowProperties--;
return o;
}
void checkPopupWindowProperties(api.PopupWindowProperties o) {
buildCounterPopupWindowProperties++;
if (buildCounterPopupWindowProperties < 3) {
checkSize(o.dimension!);
checkOffsetPosition(o.offset!);
unittest.expect(
o.positionType!,
unittest.equals('foo'),
);
unittest.expect(o.showAddressBar!, unittest.isTrue);
unittest.expect(o.showMenuBar!, unittest.isTrue);
unittest.expect(o.showScrollBar!, unittest.isTrue);
unittest.expect(o.showStatusBar!, unittest.isTrue);
unittest.expect(o.showToolBar!, unittest.isTrue);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterPopupWindowProperties--;
}
core.int buildCounterPostalCode = 0;
api.PostalCode buildPostalCode() {
final o = api.PostalCode();
buildCounterPostalCode++;
if (buildCounterPostalCode < 3) {
o.code = 'foo';
o.countryCode = 'foo';
o.countryDartId = 'foo';
o.id = 'foo';
o.kind = 'foo';
}
buildCounterPostalCode--;
return o;
}
void checkPostalCode(api.PostalCode o) {
buildCounterPostalCode++;
if (buildCounterPostalCode < 3) {
unittest.expect(
o.code!,
unittest.equals('foo'),
);
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.countryDartId!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterPostalCode--;
}
core.List<api.PostalCode> buildUnnamed151() => [
buildPostalCode(),
buildPostalCode(),
];
void checkUnnamed151(core.List<api.PostalCode> o) {
unittest.expect(o, unittest.hasLength(2));
checkPostalCode(o[0]);
checkPostalCode(o[1]);
}
core.int buildCounterPostalCodesListResponse = 0;
api.PostalCodesListResponse buildPostalCodesListResponse() {
final o = api.PostalCodesListResponse();
buildCounterPostalCodesListResponse++;
if (buildCounterPostalCodesListResponse < 3) {
o.kind = 'foo';
o.postalCodes = buildUnnamed151();
}
buildCounterPostalCodesListResponse--;
return o;
}
void checkPostalCodesListResponse(api.PostalCodesListResponse o) {
buildCounterPostalCodesListResponse++;
if (buildCounterPostalCodesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed151(o.postalCodes!);
}
buildCounterPostalCodesListResponse--;
}
core.List<api.Flight> buildUnnamed152() => [
buildFlight(),
buildFlight(),
];
void checkUnnamed152(core.List<api.Flight> o) {
unittest.expect(o, unittest.hasLength(2));
checkFlight(o[0]);
checkFlight(o[1]);
}
core.int buildCounterPricing = 0;
api.Pricing buildPricing() {
final o = api.Pricing();
buildCounterPricing++;
if (buildCounterPricing < 3) {
o.capCostType = 'foo';
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.flights = buildUnnamed152();
o.groupType = 'foo';
o.pricingType = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterPricing--;
return o;
}
void checkPricing(api.Pricing o) {
buildCounterPricing++;
if (buildCounterPricing < 3) {
unittest.expect(
o.capCostType!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
checkUnnamed152(o.flights!);
unittest.expect(
o.groupType!,
unittest.equals('foo'),
);
unittest.expect(
o.pricingType!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
buildCounterPricing--;
}
core.List<api.PricingSchedulePricingPeriod> buildUnnamed153() => [
buildPricingSchedulePricingPeriod(),
buildPricingSchedulePricingPeriod(),
];
void checkUnnamed153(core.List<api.PricingSchedulePricingPeriod> o) {
unittest.expect(o, unittest.hasLength(2));
checkPricingSchedulePricingPeriod(o[0]);
checkPricingSchedulePricingPeriod(o[1]);
}
core.int buildCounterPricingSchedule = 0;
api.PricingSchedule buildPricingSchedule() {
final o = api.PricingSchedule();
buildCounterPricingSchedule++;
if (buildCounterPricingSchedule < 3) {
o.capCostOption = 'foo';
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.flighted = true;
o.floodlightActivityId = 'foo';
o.pricingPeriods = buildUnnamed153();
o.pricingType = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.testingStartDate = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterPricingSchedule--;
return o;
}
void checkPricingSchedule(api.PricingSchedule o) {
buildCounterPricingSchedule++;
if (buildCounterPricingSchedule < 3) {
unittest.expect(
o.capCostOption!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(o.flighted!, unittest.isTrue);
unittest.expect(
o.floodlightActivityId!,
unittest.equals('foo'),
);
checkUnnamed153(o.pricingPeriods!);
unittest.expect(
o.pricingType!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.testingStartDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
buildCounterPricingSchedule--;
}
core.int buildCounterPricingSchedulePricingPeriod = 0;
api.PricingSchedulePricingPeriod buildPricingSchedulePricingPeriod() {
final o = api.PricingSchedulePricingPeriod();
buildCounterPricingSchedulePricingPeriod++;
if (buildCounterPricingSchedulePricingPeriod < 3) {
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.pricingComment = 'foo';
o.rateOrCostNanos = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.units = 'foo';
}
buildCounterPricingSchedulePricingPeriod--;
return o;
}
void checkPricingSchedulePricingPeriod(api.PricingSchedulePricingPeriod o) {
buildCounterPricingSchedulePricingPeriod++;
if (buildCounterPricingSchedulePricingPeriod < 3) {
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.pricingComment!,
unittest.equals('foo'),
);
unittest.expect(
o.rateOrCostNanos!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.units!,
unittest.equals('foo'),
);
}
buildCounterPricingSchedulePricingPeriod--;
}
core.int buildCounterProject = 0;
api.Project buildProject() {
final o = api.Project();
buildCounterProject++;
if (buildCounterProject < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.audienceAgeGroup = 'foo';
o.audienceGender = 'foo';
o.budget = 'foo';
o.clientBillingCode = 'foo';
o.clientName = 'foo';
o.endDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.id = 'foo';
o.kind = 'foo';
o.lastModifiedInfo = buildLastModifiedInfo();
o.name = 'foo';
o.overview = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.subaccountId = 'foo';
o.targetClicks = 'foo';
o.targetConversions = 'foo';
o.targetCpaNanos = 'foo';
o.targetCpcNanos = 'foo';
o.targetCpmActiveViewNanos = 'foo';
o.targetCpmNanos = 'foo';
o.targetImpressions = 'foo';
}
buildCounterProject--;
return o;
}
void checkProject(api.Project o) {
buildCounterProject++;
if (buildCounterProject < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
unittest.expect(
o.audienceAgeGroup!,
unittest.equals('foo'),
);
unittest.expect(
o.audienceGender!,
unittest.equals('foo'),
);
unittest.expect(
o.budget!,
unittest.equals('foo'),
);
unittest.expect(
o.clientBillingCode!,
unittest.equals('foo'),
);
unittest.expect(
o.clientName!,
unittest.equals('foo'),
);
unittest.expect(
o.endDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLastModifiedInfo(o.lastModifiedInfo!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.overview!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.targetClicks!,
unittest.equals('foo'),
);
unittest.expect(
o.targetConversions!,
unittest.equals('foo'),
);
unittest.expect(
o.targetCpaNanos!,
unittest.equals('foo'),
);
unittest.expect(
o.targetCpcNanos!,
unittest.equals('foo'),
);
unittest.expect(
o.targetCpmActiveViewNanos!,
unittest.equals('foo'),
);
unittest.expect(
o.targetCpmNanos!,
unittest.equals('foo'),
);
unittest.expect(
o.targetImpressions!,
unittest.equals('foo'),
);
}
buildCounterProject--;
}
core.List<api.Project> buildUnnamed154() => [
buildProject(),
buildProject(),
];
void checkUnnamed154(core.List<api.Project> o) {
unittest.expect(o, unittest.hasLength(2));
checkProject(o[0]);
checkProject(o[1]);
}
core.int buildCounterProjectsListResponse = 0;
api.ProjectsListResponse buildProjectsListResponse() {
final o = api.ProjectsListResponse();
buildCounterProjectsListResponse++;
if (buildCounterProjectsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.projects = buildUnnamed154();
}
buildCounterProjectsListResponse--;
return o;
}
void checkProjectsListResponse(api.ProjectsListResponse o) {
buildCounterProjectsListResponse++;
if (buildCounterProjectsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed154(o.projects!);
}
buildCounterProjectsListResponse--;
}
core.List<api.Dimension> buildUnnamed155() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed155(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed156() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed156(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed157() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed157(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Metric> buildUnnamed158() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed158(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Metric> buildUnnamed159() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed159(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.int buildCounterReachReportCompatibleFields = 0;
api.ReachReportCompatibleFields buildReachReportCompatibleFields() {
final o = api.ReachReportCompatibleFields();
buildCounterReachReportCompatibleFields++;
if (buildCounterReachReportCompatibleFields < 3) {
o.dimensionFilters = buildUnnamed155();
o.dimensions = buildUnnamed156();
o.kind = 'foo';
o.metrics = buildUnnamed157();
o.pivotedActivityMetrics = buildUnnamed158();
o.reachByFrequencyMetrics = buildUnnamed159();
}
buildCounterReachReportCompatibleFields--;
return o;
}
void checkReachReportCompatibleFields(api.ReachReportCompatibleFields o) {
buildCounterReachReportCompatibleFields++;
if (buildCounterReachReportCompatibleFields < 3) {
checkUnnamed155(o.dimensionFilters!);
checkUnnamed156(o.dimensions!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed157(o.metrics!);
checkUnnamed158(o.pivotedActivityMetrics!);
checkUnnamed159(o.reachByFrequencyMetrics!);
}
buildCounterReachReportCompatibleFields--;
}
core.int buildCounterRecipient = 0;
api.Recipient buildRecipient() {
final o = api.Recipient();
buildCounterRecipient++;
if (buildCounterRecipient < 3) {
o.deliveryType = 'foo';
o.email = 'foo';
o.kind = 'foo';
}
buildCounterRecipient--;
return o;
}
void checkRecipient(api.Recipient o) {
buildCounterRecipient++;
if (buildCounterRecipient < 3) {
unittest.expect(
o.deliveryType!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterRecipient--;
}
core.int buildCounterRegion = 0;
api.Region buildRegion() {
final o = api.Region();
buildCounterRegion++;
if (buildCounterRegion < 3) {
o.countryCode = 'foo';
o.countryDartId = 'foo';
o.dartId = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.regionCode = 'foo';
}
buildCounterRegion--;
return o;
}
void checkRegion(api.Region o) {
buildCounterRegion++;
if (buildCounterRegion < 3) {
unittest.expect(
o.countryCode!,
unittest.equals('foo'),
);
unittest.expect(
o.countryDartId!,
unittest.equals('foo'),
);
unittest.expect(
o.dartId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.regionCode!,
unittest.equals('foo'),
);
}
buildCounterRegion--;
}
core.List<api.Region> buildUnnamed160() => [
buildRegion(),
buildRegion(),
];
void checkUnnamed160(core.List<api.Region> o) {
unittest.expect(o, unittest.hasLength(2));
checkRegion(o[0]);
checkRegion(o[1]);
}
core.int buildCounterRegionsListResponse = 0;
api.RegionsListResponse buildRegionsListResponse() {
final o = api.RegionsListResponse();
buildCounterRegionsListResponse++;
if (buildCounterRegionsListResponse < 3) {
o.kind = 'foo';
o.regions = buildUnnamed160();
}
buildCounterRegionsListResponse--;
return o;
}
void checkRegionsListResponse(api.RegionsListResponse o) {
buildCounterRegionsListResponse++;
if (buildCounterRegionsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed160(o.regions!);
}
buildCounterRegionsListResponse--;
}
core.int buildCounterRemarketingList = 0;
api.RemarketingList buildRemarketingList() {
final o = api.RemarketingList();
buildCounterRemarketingList++;
if (buildCounterRemarketingList < 3) {
o.accountId = 'foo';
o.active = true;
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.description = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.lifeSpan = 'foo';
o.listPopulationRule = buildListPopulationRule();
o.listSize = 'foo';
o.listSource = 'foo';
o.name = 'foo';
o.subaccountId = 'foo';
}
buildCounterRemarketingList--;
return o;
}
void checkRemarketingList(api.RemarketingList o) {
buildCounterRemarketingList++;
if (buildCounterRemarketingList < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.lifeSpan!,
unittest.equals('foo'),
);
checkListPopulationRule(o.listPopulationRule!);
unittest.expect(
o.listSize!,
unittest.equals('foo'),
);
unittest.expect(
o.listSource!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterRemarketingList--;
}
core.List<core.String> buildUnnamed161() => [
'foo',
'foo',
];
void checkUnnamed161(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed162() => [
'foo',
'foo',
];
void checkUnnamed162(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterRemarketingListShare = 0;
api.RemarketingListShare buildRemarketingListShare() {
final o = api.RemarketingListShare();
buildCounterRemarketingListShare++;
if (buildCounterRemarketingListShare < 3) {
o.kind = 'foo';
o.remarketingListId = 'foo';
o.sharedAccountIds = buildUnnamed161();
o.sharedAdvertiserIds = buildUnnamed162();
}
buildCounterRemarketingListShare--;
return o;
}
void checkRemarketingListShare(api.RemarketingListShare o) {
buildCounterRemarketingListShare++;
if (buildCounterRemarketingListShare < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.remarketingListId!,
unittest.equals('foo'),
);
checkUnnamed161(o.sharedAccountIds!);
checkUnnamed162(o.sharedAdvertiserIds!);
}
buildCounterRemarketingListShare--;
}
core.List<api.RemarketingList> buildUnnamed163() => [
buildRemarketingList(),
buildRemarketingList(),
];
void checkUnnamed163(core.List<api.RemarketingList> o) {
unittest.expect(o, unittest.hasLength(2));
checkRemarketingList(o[0]);
checkRemarketingList(o[1]);
}
core.int buildCounterRemarketingListsListResponse = 0;
api.RemarketingListsListResponse buildRemarketingListsListResponse() {
final o = api.RemarketingListsListResponse();
buildCounterRemarketingListsListResponse++;
if (buildCounterRemarketingListsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.remarketingLists = buildUnnamed163();
}
buildCounterRemarketingListsListResponse--;
return o;
}
void checkRemarketingListsListResponse(api.RemarketingListsListResponse o) {
buildCounterRemarketingListsListResponse++;
if (buildCounterRemarketingListsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed163(o.remarketingLists!);
}
buildCounterRemarketingListsListResponse--;
}
core.List<api.DimensionValue> buildUnnamed164() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed164(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed165() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed165(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<core.String> buildUnnamed166() => [
'foo',
'foo',
];
void checkUnnamed166(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportCriteria = 0;
api.ReportCriteria buildReportCriteria() {
final o = api.ReportCriteria();
buildCounterReportCriteria++;
if (buildCounterReportCriteria < 3) {
o.activities = buildActivities();
o.customRichMediaEvents = buildCustomRichMediaEvents();
o.dateRange = buildDateRange();
o.dimensionFilters = buildUnnamed164();
o.dimensions = buildUnnamed165();
o.metricNames = buildUnnamed166();
}
buildCounterReportCriteria--;
return o;
}
void checkReportCriteria(api.ReportCriteria o) {
buildCounterReportCriteria++;
if (buildCounterReportCriteria < 3) {
checkActivities(o.activities!);
checkCustomRichMediaEvents(o.customRichMediaEvents!);
checkDateRange(o.dateRange!);
checkUnnamed164(o.dimensionFilters!);
checkUnnamed165(o.dimensions!);
checkUnnamed166(o.metricNames!);
}
buildCounterReportCriteria--;
}
core.List<api.SortedDimension> buildUnnamed167() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed167(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<api.DimensionValue> buildUnnamed168() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed168(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<core.String> buildUnnamed169() => [
'foo',
'foo',
];
void checkUnnamed169(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed170() => [
'foo',
'foo',
];
void checkUnnamed170(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportCrossDimensionReachCriteria = 0;
api.ReportCrossDimensionReachCriteria buildReportCrossDimensionReachCriteria() {
final o = api.ReportCrossDimensionReachCriteria();
buildCounterReportCrossDimensionReachCriteria++;
if (buildCounterReportCrossDimensionReachCriteria < 3) {
o.breakdown = buildUnnamed167();
o.dateRange = buildDateRange();
o.dimension = 'foo';
o.dimensionFilters = buildUnnamed168();
o.metricNames = buildUnnamed169();
o.overlapMetricNames = buildUnnamed170();
o.pivoted = true;
}
buildCounterReportCrossDimensionReachCriteria--;
return o;
}
void checkReportCrossDimensionReachCriteria(
api.ReportCrossDimensionReachCriteria o) {
buildCounterReportCrossDimensionReachCriteria++;
if (buildCounterReportCrossDimensionReachCriteria < 3) {
checkUnnamed167(o.breakdown!);
checkDateRange(o.dateRange!);
unittest.expect(
o.dimension!,
unittest.equals('foo'),
);
checkUnnamed168(o.dimensionFilters!);
checkUnnamed169(o.metricNames!);
checkUnnamed170(o.overlapMetricNames!);
unittest.expect(o.pivoted!, unittest.isTrue);
}
buildCounterReportCrossDimensionReachCriteria--;
}
core.List<api.Recipient> buildUnnamed171() => [
buildRecipient(),
buildRecipient(),
];
void checkUnnamed171(core.List<api.Recipient> o) {
unittest.expect(o, unittest.hasLength(2));
checkRecipient(o[0]);
checkRecipient(o[1]);
}
core.int buildCounterReportDelivery = 0;
api.ReportDelivery buildReportDelivery() {
final o = api.ReportDelivery();
buildCounterReportDelivery++;
if (buildCounterReportDelivery < 3) {
o.emailOwner = true;
o.emailOwnerDeliveryType = 'foo';
o.message = 'foo';
o.recipients = buildUnnamed171();
}
buildCounterReportDelivery--;
return o;
}
void checkReportDelivery(api.ReportDelivery o) {
buildCounterReportDelivery++;
if (buildCounterReportDelivery < 3) {
unittest.expect(o.emailOwner!, unittest.isTrue);
unittest.expect(
o.emailOwnerDeliveryType!,
unittest.equals('foo'),
);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
checkUnnamed171(o.recipients!);
}
buildCounterReportDelivery--;
}
core.List<api.DimensionValue> buildUnnamed172() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed172(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.DimensionValue> buildUnnamed173() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed173(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed174() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed174(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<core.String> buildUnnamed175() => [
'foo',
'foo',
];
void checkUnnamed175(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportFloodlightCriteriaReportProperties = 0;
api.ReportFloodlightCriteriaReportProperties
buildReportFloodlightCriteriaReportProperties() {
final o = api.ReportFloodlightCriteriaReportProperties();
buildCounterReportFloodlightCriteriaReportProperties++;
if (buildCounterReportFloodlightCriteriaReportProperties < 3) {
o.includeAttributedIPConversions = true;
o.includeUnattributedCookieConversions = true;
o.includeUnattributedIPConversions = true;
}
buildCounterReportFloodlightCriteriaReportProperties--;
return o;
}
void checkReportFloodlightCriteriaReportProperties(
api.ReportFloodlightCriteriaReportProperties o) {
buildCounterReportFloodlightCriteriaReportProperties++;
if (buildCounterReportFloodlightCriteriaReportProperties < 3) {
unittest.expect(o.includeAttributedIPConversions!, unittest.isTrue);
unittest.expect(o.includeUnattributedCookieConversions!, unittest.isTrue);
unittest.expect(o.includeUnattributedIPConversions!, unittest.isTrue);
}
buildCounterReportFloodlightCriteriaReportProperties--;
}
core.int buildCounterReportFloodlightCriteria = 0;
api.ReportFloodlightCriteria buildReportFloodlightCriteria() {
final o = api.ReportFloodlightCriteria();
buildCounterReportFloodlightCriteria++;
if (buildCounterReportFloodlightCriteria < 3) {
o.customRichMediaEvents = buildUnnamed172();
o.dateRange = buildDateRange();
o.dimensionFilters = buildUnnamed173();
o.dimensions = buildUnnamed174();
o.floodlightConfigId = buildDimensionValue();
o.metricNames = buildUnnamed175();
o.reportProperties = buildReportFloodlightCriteriaReportProperties();
}
buildCounterReportFloodlightCriteria--;
return o;
}
void checkReportFloodlightCriteria(api.ReportFloodlightCriteria o) {
buildCounterReportFloodlightCriteria++;
if (buildCounterReportFloodlightCriteria < 3) {
checkUnnamed172(o.customRichMediaEvents!);
checkDateRange(o.dateRange!);
checkUnnamed173(o.dimensionFilters!);
checkUnnamed174(o.dimensions!);
checkDimensionValue(o.floodlightConfigId!);
checkUnnamed175(o.metricNames!);
checkReportFloodlightCriteriaReportProperties(o.reportProperties!);
}
buildCounterReportFloodlightCriteria--;
}
core.List<api.DimensionValue> buildUnnamed176() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed176(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed177() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed177(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<core.String> buildUnnamed178() => [
'foo',
'foo',
];
void checkUnnamed178(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.PathFilter> buildUnnamed179() => [
buildPathFilter(),
buildPathFilter(),
];
void checkUnnamed179(core.List<api.PathFilter> o) {
unittest.expect(o, unittest.hasLength(2));
checkPathFilter(o[0]);
checkPathFilter(o[1]);
}
core.int buildCounterReportPathAttributionCriteria = 0;
api.ReportPathAttributionCriteria buildReportPathAttributionCriteria() {
final o = api.ReportPathAttributionCriteria();
buildCounterReportPathAttributionCriteria++;
if (buildCounterReportPathAttributionCriteria < 3) {
o.activityFilters = buildUnnamed176();
o.customChannelGrouping = buildChannelGrouping();
o.dateRange = buildDateRange();
o.dimensions = buildUnnamed177();
o.floodlightConfigId = buildDimensionValue();
o.metricNames = buildUnnamed178();
o.pathFilters = buildUnnamed179();
}
buildCounterReportPathAttributionCriteria--;
return o;
}
void checkReportPathAttributionCriteria(api.ReportPathAttributionCriteria o) {
buildCounterReportPathAttributionCriteria++;
if (buildCounterReportPathAttributionCriteria < 3) {
checkUnnamed176(o.activityFilters!);
checkChannelGrouping(o.customChannelGrouping!);
checkDateRange(o.dateRange!);
checkUnnamed177(o.dimensions!);
checkDimensionValue(o.floodlightConfigId!);
checkUnnamed178(o.metricNames!);
checkUnnamed179(o.pathFilters!);
}
buildCounterReportPathAttributionCriteria--;
}
core.List<api.DimensionValue> buildUnnamed180() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed180(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed181() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed181(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<core.String> buildUnnamed182() => [
'foo',
'foo',
];
void checkUnnamed182(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.PathFilter> buildUnnamed183() => [
buildPathFilter(),
buildPathFilter(),
];
void checkUnnamed183(core.List<api.PathFilter> o) {
unittest.expect(o, unittest.hasLength(2));
checkPathFilter(o[0]);
checkPathFilter(o[1]);
}
core.int buildCounterReportPathCriteria = 0;
api.ReportPathCriteria buildReportPathCriteria() {
final o = api.ReportPathCriteria();
buildCounterReportPathCriteria++;
if (buildCounterReportPathCriteria < 3) {
o.activityFilters = buildUnnamed180();
o.customChannelGrouping = buildChannelGrouping();
o.dateRange = buildDateRange();
o.dimensions = buildUnnamed181();
o.floodlightConfigId = buildDimensionValue();
o.metricNames = buildUnnamed182();
o.pathFilters = buildUnnamed183();
}
buildCounterReportPathCriteria--;
return o;
}
void checkReportPathCriteria(api.ReportPathCriteria o) {
buildCounterReportPathCriteria++;
if (buildCounterReportPathCriteria < 3) {
checkUnnamed180(o.activityFilters!);
checkChannelGrouping(o.customChannelGrouping!);
checkDateRange(o.dateRange!);
checkUnnamed181(o.dimensions!);
checkDimensionValue(o.floodlightConfigId!);
checkUnnamed182(o.metricNames!);
checkUnnamed183(o.pathFilters!);
}
buildCounterReportPathCriteria--;
}
core.List<api.DimensionValue> buildUnnamed184() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed184(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed185() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed185(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<api.SortedDimension> buildUnnamed186() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed186(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<api.DimensionValue> buildUnnamed187() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed187(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<core.String> buildUnnamed188() => [
'foo',
'foo',
];
void checkUnnamed188(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.SortedDimension> buildUnnamed189() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed189(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.int buildCounterReportPathToConversionCriteriaReportProperties = 0;
api.ReportPathToConversionCriteriaReportProperties
buildReportPathToConversionCriteriaReportProperties() {
final o = api.ReportPathToConversionCriteriaReportProperties();
buildCounterReportPathToConversionCriteriaReportProperties++;
if (buildCounterReportPathToConversionCriteriaReportProperties < 3) {
o.clicksLookbackWindow = 42;
o.impressionsLookbackWindow = 42;
o.includeAttributedIPConversions = true;
o.includeUnattributedCookieConversions = true;
o.includeUnattributedIPConversions = true;
o.maximumClickInteractions = 42;
o.maximumImpressionInteractions = 42;
o.maximumInteractionGap = 42;
o.pivotOnInteractionPath = true;
}
buildCounterReportPathToConversionCriteriaReportProperties--;
return o;
}
void checkReportPathToConversionCriteriaReportProperties(
api.ReportPathToConversionCriteriaReportProperties o) {
buildCounterReportPathToConversionCriteriaReportProperties++;
if (buildCounterReportPathToConversionCriteriaReportProperties < 3) {
unittest.expect(
o.clicksLookbackWindow!,
unittest.equals(42),
);
unittest.expect(
o.impressionsLookbackWindow!,
unittest.equals(42),
);
unittest.expect(o.includeAttributedIPConversions!, unittest.isTrue);
unittest.expect(o.includeUnattributedCookieConversions!, unittest.isTrue);
unittest.expect(o.includeUnattributedIPConversions!, unittest.isTrue);
unittest.expect(
o.maximumClickInteractions!,
unittest.equals(42),
);
unittest.expect(
o.maximumImpressionInteractions!,
unittest.equals(42),
);
unittest.expect(
o.maximumInteractionGap!,
unittest.equals(42),
);
unittest.expect(o.pivotOnInteractionPath!, unittest.isTrue);
}
buildCounterReportPathToConversionCriteriaReportProperties--;
}
core.int buildCounterReportPathToConversionCriteria = 0;
api.ReportPathToConversionCriteria buildReportPathToConversionCriteria() {
final o = api.ReportPathToConversionCriteria();
buildCounterReportPathToConversionCriteria++;
if (buildCounterReportPathToConversionCriteria < 3) {
o.activityFilters = buildUnnamed184();
o.conversionDimensions = buildUnnamed185();
o.customFloodlightVariables = buildUnnamed186();
o.customRichMediaEvents = buildUnnamed187();
o.dateRange = buildDateRange();
o.floodlightConfigId = buildDimensionValue();
o.metricNames = buildUnnamed188();
o.perInteractionDimensions = buildUnnamed189();
o.reportProperties = buildReportPathToConversionCriteriaReportProperties();
}
buildCounterReportPathToConversionCriteria--;
return o;
}
void checkReportPathToConversionCriteria(api.ReportPathToConversionCriteria o) {
buildCounterReportPathToConversionCriteria++;
if (buildCounterReportPathToConversionCriteria < 3) {
checkUnnamed184(o.activityFilters!);
checkUnnamed185(o.conversionDimensions!);
checkUnnamed186(o.customFloodlightVariables!);
checkUnnamed187(o.customRichMediaEvents!);
checkDateRange(o.dateRange!);
checkDimensionValue(o.floodlightConfigId!);
checkUnnamed188(o.metricNames!);
checkUnnamed189(o.perInteractionDimensions!);
checkReportPathToConversionCriteriaReportProperties(o.reportProperties!);
}
buildCounterReportPathToConversionCriteria--;
}
core.List<api.DimensionValue> buildUnnamed190() => [
buildDimensionValue(),
buildDimensionValue(),
];
void checkUnnamed190(core.List<api.DimensionValue> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimensionValue(o[0]);
checkDimensionValue(o[1]);
}
core.List<api.SortedDimension> buildUnnamed191() => [
buildSortedDimension(),
buildSortedDimension(),
];
void checkUnnamed191(core.List<api.SortedDimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkSortedDimension(o[0]);
checkSortedDimension(o[1]);
}
core.List<core.String> buildUnnamed192() => [
'foo',
'foo',
];
void checkUnnamed192(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed193() => [
'foo',
'foo',
];
void checkUnnamed193(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportReachCriteria = 0;
api.ReportReachCriteria buildReportReachCriteria() {
final o = api.ReportReachCriteria();
buildCounterReportReachCriteria++;
if (buildCounterReportReachCriteria < 3) {
o.activities = buildActivities();
o.customRichMediaEvents = buildCustomRichMediaEvents();
o.dateRange = buildDateRange();
o.dimensionFilters = buildUnnamed190();
o.dimensions = buildUnnamed191();
o.enableAllDimensionCombinations = true;
o.metricNames = buildUnnamed192();
o.reachByFrequencyMetricNames = buildUnnamed193();
}
buildCounterReportReachCriteria--;
return o;
}
void checkReportReachCriteria(api.ReportReachCriteria o) {
buildCounterReportReachCriteria++;
if (buildCounterReportReachCriteria < 3) {
checkActivities(o.activities!);
checkCustomRichMediaEvents(o.customRichMediaEvents!);
checkDateRange(o.dateRange!);
checkUnnamed190(o.dimensionFilters!);
checkUnnamed191(o.dimensions!);
unittest.expect(o.enableAllDimensionCombinations!, unittest.isTrue);
checkUnnamed192(o.metricNames!);
checkUnnamed193(o.reachByFrequencyMetricNames!);
}
buildCounterReportReachCriteria--;
}
core.List<core.String> buildUnnamed194() => [
'foo',
'foo',
];
void checkUnnamed194(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterReportSchedule = 0;
api.ReportSchedule buildReportSchedule() {
final o = api.ReportSchedule();
buildCounterReportSchedule++;
if (buildCounterReportSchedule < 3) {
o.active = true;
o.every = 42;
o.expirationDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.repeats = 'foo';
o.repeatsOnWeekDays = buildUnnamed194();
o.runsOnDayOfMonth = 'foo';
o.startDate = core.DateTime.parse('2002-02-27T14:01:02Z');
o.timezone = 'foo';
}
buildCounterReportSchedule--;
return o;
}
void checkReportSchedule(api.ReportSchedule o) {
buildCounterReportSchedule++;
if (buildCounterReportSchedule < 3) {
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.every!,
unittest.equals(42),
);
unittest.expect(
o.expirationDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.repeats!,
unittest.equals('foo'),
);
checkUnnamed194(o.repeatsOnWeekDays!);
unittest.expect(
o.runsOnDayOfMonth!,
unittest.equals('foo'),
);
unittest.expect(
o.startDate!,
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o.timezone!,
unittest.equals('foo'),
);
}
buildCounterReportSchedule--;
}
core.int buildCounterReport = 0;
api.Report buildReport() {
final o = api.Report();
buildCounterReport++;
if (buildCounterReport < 3) {
o.accountId = 'foo';
o.criteria = buildReportCriteria();
o.crossDimensionReachCriteria = buildReportCrossDimensionReachCriteria();
o.delivery = buildReportDelivery();
o.etag = 'foo';
o.fileName = 'foo';
o.floodlightCriteria = buildReportFloodlightCriteria();
o.format = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.lastModifiedTime = 'foo';
o.name = 'foo';
o.ownerProfileId = 'foo';
o.pathAttributionCriteria = buildReportPathAttributionCriteria();
o.pathCriteria = buildReportPathCriteria();
o.pathToConversionCriteria = buildReportPathToConversionCriteria();
o.reachCriteria = buildReportReachCriteria();
o.schedule = buildReportSchedule();
o.subAccountId = 'foo';
o.type = 'foo';
}
buildCounterReport--;
return o;
}
void checkReport(api.Report o) {
buildCounterReport++;
if (buildCounterReport < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
checkReportCriteria(o.criteria!);
checkReportCrossDimensionReachCriteria(o.crossDimensionReachCriteria!);
checkReportDelivery(o.delivery!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.fileName!,
unittest.equals('foo'),
);
checkReportFloodlightCriteria(o.floodlightCriteria!);
unittest.expect(
o.format!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.lastModifiedTime!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.ownerProfileId!,
unittest.equals('foo'),
);
checkReportPathAttributionCriteria(o.pathAttributionCriteria!);
checkReportPathCriteria(o.pathCriteria!);
checkReportPathToConversionCriteria(o.pathToConversionCriteria!);
checkReportReachCriteria(o.reachCriteria!);
checkReportSchedule(o.schedule!);
unittest.expect(
o.subAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterReport--;
}
core.List<api.Dimension> buildUnnamed195() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed195(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Dimension> buildUnnamed196() => [
buildDimension(),
buildDimension(),
];
void checkUnnamed196(core.List<api.Dimension> o) {
unittest.expect(o, unittest.hasLength(2));
checkDimension(o[0]);
checkDimension(o[1]);
}
core.List<api.Metric> buildUnnamed197() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed197(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.List<api.Metric> buildUnnamed198() => [
buildMetric(),
buildMetric(),
];
void checkUnnamed198(core.List<api.Metric> o) {
unittest.expect(o, unittest.hasLength(2));
checkMetric(o[0]);
checkMetric(o[1]);
}
core.int buildCounterReportCompatibleFields = 0;
api.ReportCompatibleFields buildReportCompatibleFields() {
final o = api.ReportCompatibleFields();
buildCounterReportCompatibleFields++;
if (buildCounterReportCompatibleFields < 3) {
o.dimensionFilters = buildUnnamed195();
o.dimensions = buildUnnamed196();
o.kind = 'foo';
o.metrics = buildUnnamed197();
o.pivotedActivityMetrics = buildUnnamed198();
}
buildCounterReportCompatibleFields--;
return o;
}
void checkReportCompatibleFields(api.ReportCompatibleFields o) {
buildCounterReportCompatibleFields++;
if (buildCounterReportCompatibleFields < 3) {
checkUnnamed195(o.dimensionFilters!);
checkUnnamed196(o.dimensions!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed197(o.metrics!);
checkUnnamed198(o.pivotedActivityMetrics!);
}
buildCounterReportCompatibleFields--;
}
core.List<api.Report> buildUnnamed199() => [
buildReport(),
buildReport(),
];
void checkUnnamed199(core.List<api.Report> o) {
unittest.expect(o, unittest.hasLength(2));
checkReport(o[0]);
checkReport(o[1]);
}
core.int buildCounterReportList = 0;
api.ReportList buildReportList() {
final o = api.ReportList();
buildCounterReportList++;
if (buildCounterReportList < 3) {
o.etag = 'foo';
o.items = buildUnnamed199();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterReportList--;
return o;
}
void checkReportList(api.ReportList o) {
buildCounterReportList++;
if (buildCounterReportList < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed199(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterReportList--;
}
core.int buildCounterReportsConfiguration = 0;
api.ReportsConfiguration buildReportsConfiguration() {
final o = api.ReportsConfiguration();
buildCounterReportsConfiguration++;
if (buildCounterReportsConfiguration < 3) {
o.exposureToConversionEnabled = true;
o.lookbackConfiguration = buildLookbackConfiguration();
o.reportGenerationTimeZoneId = 'foo';
}
buildCounterReportsConfiguration--;
return o;
}
void checkReportsConfiguration(api.ReportsConfiguration o) {
buildCounterReportsConfiguration++;
if (buildCounterReportsConfiguration < 3) {
unittest.expect(o.exposureToConversionEnabled!, unittest.isTrue);
checkLookbackConfiguration(o.lookbackConfiguration!);
unittest.expect(
o.reportGenerationTimeZoneId!,
unittest.equals('foo'),
);
}
buildCounterReportsConfiguration--;
}
core.int buildCounterRichMediaExitOverride = 0;
api.RichMediaExitOverride buildRichMediaExitOverride() {
final o = api.RichMediaExitOverride();
buildCounterRichMediaExitOverride++;
if (buildCounterRichMediaExitOverride < 3) {
o.clickThroughUrl = buildClickThroughUrl();
o.enabled = true;
o.exitId = 'foo';
}
buildCounterRichMediaExitOverride--;
return o;
}
void checkRichMediaExitOverride(api.RichMediaExitOverride o) {
buildCounterRichMediaExitOverride++;
if (buildCounterRichMediaExitOverride < 3) {
checkClickThroughUrl(o.clickThroughUrl!);
unittest.expect(o.enabled!, unittest.isTrue);
unittest.expect(
o.exitId!,
unittest.equals('foo'),
);
}
buildCounterRichMediaExitOverride--;
}
core.int buildCounterRule = 0;
api.Rule buildRule() {
final o = api.Rule();
buildCounterRule++;
if (buildCounterRule < 3) {
o.assetId = 'foo';
o.name = 'foo';
o.targetingTemplateId = 'foo';
}
buildCounterRule--;
return o;
}
void checkRule(api.Rule o) {
buildCounterRule++;
if (buildCounterRule < 3) {
unittest.expect(
o.assetId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.targetingTemplateId!,
unittest.equals('foo'),
);
}
buildCounterRule--;
}
core.List<api.SiteContact> buildUnnamed200() => [
buildSiteContact(),
buildSiteContact(),
];
void checkUnnamed200(core.List<api.SiteContact> o) {
unittest.expect(o, unittest.hasLength(2));
checkSiteContact(o[0]);
checkSiteContact(o[1]);
}
core.int buildCounterSite = 0;
api.Site buildSite() {
final o = api.Site();
buildCounterSite++;
if (buildCounterSite < 3) {
o.accountId = 'foo';
o.approved = true;
o.directorySiteId = 'foo';
o.directorySiteIdDimensionValue = buildDimensionValue();
o.id = 'foo';
o.idDimensionValue = buildDimensionValue();
o.keyName = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.siteContacts = buildUnnamed200();
o.siteSettings = buildSiteSettings();
o.subaccountId = 'foo';
o.videoSettings = buildSiteVideoSettings();
}
buildCounterSite--;
return o;
}
void checkSite(api.Site o) {
buildCounterSite++;
if (buildCounterSite < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.approved!, unittest.isTrue);
unittest.expect(
o.directorySiteId!,
unittest.equals('foo'),
);
checkDimensionValue(o.directorySiteIdDimensionValue!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkDimensionValue(o.idDimensionValue!);
unittest.expect(
o.keyName!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed200(o.siteContacts!);
checkSiteSettings(o.siteSettings!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
checkSiteVideoSettings(o.videoSettings!);
}
buildCounterSite--;
}
core.List<api.Size> buildUnnamed201() => [
buildSize(),
buildSize(),
];
void checkUnnamed201(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.int buildCounterSiteCompanionSetting = 0;
api.SiteCompanionSetting buildSiteCompanionSetting() {
final o = api.SiteCompanionSetting();
buildCounterSiteCompanionSetting++;
if (buildCounterSiteCompanionSetting < 3) {
o.companionsDisabled = true;
o.enabledSizes = buildUnnamed201();
o.imageOnly = true;
o.kind = 'foo';
}
buildCounterSiteCompanionSetting--;
return o;
}
void checkSiteCompanionSetting(api.SiteCompanionSetting o) {
buildCounterSiteCompanionSetting++;
if (buildCounterSiteCompanionSetting < 3) {
unittest.expect(o.companionsDisabled!, unittest.isTrue);
checkUnnamed201(o.enabledSizes!);
unittest.expect(o.imageOnly!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterSiteCompanionSetting--;
}
core.int buildCounterSiteContact = 0;
api.SiteContact buildSiteContact() {
final o = api.SiteContact();
buildCounterSiteContact++;
if (buildCounterSiteContact < 3) {
o.address = 'foo';
o.contactType = 'foo';
o.email = 'foo';
o.firstName = 'foo';
o.id = 'foo';
o.lastName = 'foo';
o.phone = 'foo';
o.title = 'foo';
}
buildCounterSiteContact--;
return o;
}
void checkSiteContact(api.SiteContact o) {
buildCounterSiteContact++;
if (buildCounterSiteContact < 3) {
unittest.expect(
o.address!,
unittest.equals('foo'),
);
unittest.expect(
o.contactType!,
unittest.equals('foo'),
);
unittest.expect(
o.email!,
unittest.equals('foo'),
);
unittest.expect(
o.firstName!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.lastName!,
unittest.equals('foo'),
);
unittest.expect(
o.phone!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterSiteContact--;
}
core.int buildCounterSiteSettings = 0;
api.SiteSettings buildSiteSettings() {
final o = api.SiteSettings();
buildCounterSiteSettings++;
if (buildCounterSiteSettings < 3) {
o.activeViewOptOut = true;
o.adBlockingOptOut = true;
o.disableNewCookie = true;
o.tagSetting = buildTagSetting();
o.videoActiveViewOptOutTemplate = true;
o.vpaidAdapterChoiceTemplate = 'foo';
}
buildCounterSiteSettings--;
return o;
}
void checkSiteSettings(api.SiteSettings o) {
buildCounterSiteSettings++;
if (buildCounterSiteSettings < 3) {
unittest.expect(o.activeViewOptOut!, unittest.isTrue);
unittest.expect(o.adBlockingOptOut!, unittest.isTrue);
unittest.expect(o.disableNewCookie!, unittest.isTrue);
checkTagSetting(o.tagSetting!);
unittest.expect(o.videoActiveViewOptOutTemplate!, unittest.isTrue);
unittest.expect(
o.vpaidAdapterChoiceTemplate!,
unittest.equals('foo'),
);
}
buildCounterSiteSettings--;
}
core.int buildCounterSiteSkippableSetting = 0;
api.SiteSkippableSetting buildSiteSkippableSetting() {
final o = api.SiteSkippableSetting();
buildCounterSiteSkippableSetting++;
if (buildCounterSiteSkippableSetting < 3) {
o.kind = 'foo';
o.progressOffset = buildVideoOffset();
o.skipOffset = buildVideoOffset();
o.skippable = true;
}
buildCounterSiteSkippableSetting--;
return o;
}
void checkSiteSkippableSetting(api.SiteSkippableSetting o) {
buildCounterSiteSkippableSetting++;
if (buildCounterSiteSkippableSetting < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkVideoOffset(o.progressOffset!);
checkVideoOffset(o.skipOffset!);
unittest.expect(o.skippable!, unittest.isTrue);
}
buildCounterSiteSkippableSetting--;
}
core.List<core.int> buildUnnamed202() => [
42,
42,
];
void checkUnnamed202(core.List<core.int> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(42),
);
unittest.expect(
o[1],
unittest.equals(42),
);
}
core.int buildCounterSiteTranscodeSetting = 0;
api.SiteTranscodeSetting buildSiteTranscodeSetting() {
final o = api.SiteTranscodeSetting();
buildCounterSiteTranscodeSetting++;
if (buildCounterSiteTranscodeSetting < 3) {
o.enabledVideoFormats = buildUnnamed202();
o.kind = 'foo';
}
buildCounterSiteTranscodeSetting--;
return o;
}
void checkSiteTranscodeSetting(api.SiteTranscodeSetting o) {
buildCounterSiteTranscodeSetting++;
if (buildCounterSiteTranscodeSetting < 3) {
checkUnnamed202(o.enabledVideoFormats!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterSiteTranscodeSetting--;
}
core.int buildCounterSiteVideoSettings = 0;
api.SiteVideoSettings buildSiteVideoSettings() {
final o = api.SiteVideoSettings();
buildCounterSiteVideoSettings++;
if (buildCounterSiteVideoSettings < 3) {
o.companionSettings = buildSiteCompanionSetting();
o.kind = 'foo';
o.obaEnabled = true;
o.obaSettings = buildObaIcon();
o.orientation = 'foo';
o.publisherSpecificationId = 'foo';
o.skippableSettings = buildSiteSkippableSetting();
o.transcodeSettings = buildSiteTranscodeSetting();
}
buildCounterSiteVideoSettings--;
return o;
}
void checkSiteVideoSettings(api.SiteVideoSettings o) {
buildCounterSiteVideoSettings++;
if (buildCounterSiteVideoSettings < 3) {
checkSiteCompanionSetting(o.companionSettings!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.obaEnabled!, unittest.isTrue);
checkObaIcon(o.obaSettings!);
unittest.expect(
o.orientation!,
unittest.equals('foo'),
);
unittest.expect(
o.publisherSpecificationId!,
unittest.equals('foo'),
);
checkSiteSkippableSetting(o.skippableSettings!);
checkSiteTranscodeSetting(o.transcodeSettings!);
}
buildCounterSiteVideoSettings--;
}
core.List<api.Site> buildUnnamed203() => [
buildSite(),
buildSite(),
];
void checkUnnamed203(core.List<api.Site> o) {
unittest.expect(o, unittest.hasLength(2));
checkSite(o[0]);
checkSite(o[1]);
}
core.int buildCounterSitesListResponse = 0;
api.SitesListResponse buildSitesListResponse() {
final o = api.SitesListResponse();
buildCounterSitesListResponse++;
if (buildCounterSitesListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.sites = buildUnnamed203();
}
buildCounterSitesListResponse--;
return o;
}
void checkSitesListResponse(api.SitesListResponse o) {
buildCounterSitesListResponse++;
if (buildCounterSitesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed203(o.sites!);
}
buildCounterSitesListResponse--;
}
core.int buildCounterSize = 0;
api.Size buildSize() {
final o = api.Size();
buildCounterSize++;
if (buildCounterSize < 3) {
o.height = 42;
o.iab = true;
o.id = 'foo';
o.kind = 'foo';
o.width = 42;
}
buildCounterSize--;
return o;
}
void checkSize(api.Size o) {
buildCounterSize++;
if (buildCounterSize < 3) {
unittest.expect(
o.height!,
unittest.equals(42),
);
unittest.expect(o.iab!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42),
);
}
buildCounterSize--;
}
core.List<api.Size> buildUnnamed204() => [
buildSize(),
buildSize(),
];
void checkUnnamed204(core.List<api.Size> o) {
unittest.expect(o, unittest.hasLength(2));
checkSize(o[0]);
checkSize(o[1]);
}
core.int buildCounterSizesListResponse = 0;
api.SizesListResponse buildSizesListResponse() {
final o = api.SizesListResponse();
buildCounterSizesListResponse++;
if (buildCounterSizesListResponse < 3) {
o.kind = 'foo';
o.sizes = buildUnnamed204();
}
buildCounterSizesListResponse--;
return o;
}
void checkSizesListResponse(api.SizesListResponse o) {
buildCounterSizesListResponse++;
if (buildCounterSizesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed204(o.sizes!);
}
buildCounterSizesListResponse--;
}
core.int buildCounterSkippableSetting = 0;
api.SkippableSetting buildSkippableSetting() {
final o = api.SkippableSetting();
buildCounterSkippableSetting++;
if (buildCounterSkippableSetting < 3) {
o.kind = 'foo';
o.progressOffset = buildVideoOffset();
o.skipOffset = buildVideoOffset();
o.skippable = true;
}
buildCounterSkippableSetting--;
return o;
}
void checkSkippableSetting(api.SkippableSetting o) {
buildCounterSkippableSetting++;
if (buildCounterSkippableSetting < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkVideoOffset(o.progressOffset!);
checkVideoOffset(o.skipOffset!);
unittest.expect(o.skippable!, unittest.isTrue);
}
buildCounterSkippableSetting--;
}
core.int buildCounterSortedDimension = 0;
api.SortedDimension buildSortedDimension() {
final o = api.SortedDimension();
buildCounterSortedDimension++;
if (buildCounterSortedDimension < 3) {
o.kind = 'foo';
o.name = 'foo';
o.sortOrder = 'foo';
}
buildCounterSortedDimension--;
return o;
}
void checkSortedDimension(api.SortedDimension o) {
buildCounterSortedDimension++;
if (buildCounterSortedDimension < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.sortOrder!,
unittest.equals('foo'),
);
}
buildCounterSortedDimension--;
}
core.List<core.String> buildUnnamed205() => [
'foo',
'foo',
];
void checkUnnamed205(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterSubaccount = 0;
api.Subaccount buildSubaccount() {
final o = api.Subaccount();
buildCounterSubaccount++;
if (buildCounterSubaccount < 3) {
o.accountId = 'foo';
o.availablePermissionIds = buildUnnamed205();
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterSubaccount--;
return o;
}
void checkSubaccount(api.Subaccount o) {
buildCounterSubaccount++;
if (buildCounterSubaccount < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
checkUnnamed205(o.availablePermissionIds!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterSubaccount--;
}
core.List<api.Subaccount> buildUnnamed206() => [
buildSubaccount(),
buildSubaccount(),
];
void checkUnnamed206(core.List<api.Subaccount> o) {
unittest.expect(o, unittest.hasLength(2));
checkSubaccount(o[0]);
checkSubaccount(o[1]);
}
core.int buildCounterSubaccountsListResponse = 0;
api.SubaccountsListResponse buildSubaccountsListResponse() {
final o = api.SubaccountsListResponse();
buildCounterSubaccountsListResponse++;
if (buildCounterSubaccountsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.subaccounts = buildUnnamed206();
}
buildCounterSubaccountsListResponse--;
return o;
}
void checkSubaccountsListResponse(api.SubaccountsListResponse o) {
buildCounterSubaccountsListResponse++;
if (buildCounterSubaccountsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed206(o.subaccounts!);
}
buildCounterSubaccountsListResponse--;
}
core.int buildCounterTagData = 0;
api.TagData buildTagData() {
final o = api.TagData();
buildCounterTagData++;
if (buildCounterTagData < 3) {
o.adId = 'foo';
o.clickTag = 'foo';
o.creativeId = 'foo';
o.format = 'foo';
o.impressionTag = 'foo';
}
buildCounterTagData--;
return o;
}
void checkTagData(api.TagData o) {
buildCounterTagData++;
if (buildCounterTagData < 3) {
unittest.expect(
o.adId!,
unittest.equals('foo'),
);
unittest.expect(
o.clickTag!,
unittest.equals('foo'),
);
unittest.expect(
o.creativeId!,
unittest.equals('foo'),
);
unittest.expect(
o.format!,
unittest.equals('foo'),
);
unittest.expect(
o.impressionTag!,
unittest.equals('foo'),
);
}
buildCounterTagData--;
}
core.int buildCounterTagSetting = 0;
api.TagSetting buildTagSetting() {
final o = api.TagSetting();
buildCounterTagSetting++;
if (buildCounterTagSetting < 3) {
o.additionalKeyValues = 'foo';
o.includeClickThroughUrls = true;
o.includeClickTracking = true;
o.keywordOption = 'foo';
}
buildCounterTagSetting--;
return o;
}
void checkTagSetting(api.TagSetting o) {
buildCounterTagSetting++;
if (buildCounterTagSetting < 3) {
unittest.expect(
o.additionalKeyValues!,
unittest.equals('foo'),
);
unittest.expect(o.includeClickThroughUrls!, unittest.isTrue);
unittest.expect(o.includeClickTracking!, unittest.isTrue);
unittest.expect(
o.keywordOption!,
unittest.equals('foo'),
);
}
buildCounterTagSetting--;
}
core.int buildCounterTagSettings = 0;
api.TagSettings buildTagSettings() {
final o = api.TagSettings();
buildCounterTagSettings++;
if (buildCounterTagSettings < 3) {
o.dynamicTagEnabled = true;
o.imageTagEnabled = true;
}
buildCounterTagSettings--;
return o;
}
void checkTagSettings(api.TagSettings o) {
buildCounterTagSettings++;
if (buildCounterTagSettings < 3) {
unittest.expect(o.dynamicTagEnabled!, unittest.isTrue);
unittest.expect(o.imageTagEnabled!, unittest.isTrue);
}
buildCounterTagSettings--;
}
core.int buildCounterTargetWindow = 0;
api.TargetWindow buildTargetWindow() {
final o = api.TargetWindow();
buildCounterTargetWindow++;
if (buildCounterTargetWindow < 3) {
o.customHtml = 'foo';
o.targetWindowOption = 'foo';
}
buildCounterTargetWindow--;
return o;
}
void checkTargetWindow(api.TargetWindow o) {
buildCounterTargetWindow++;
if (buildCounterTargetWindow < 3) {
unittest.expect(
o.customHtml!,
unittest.equals('foo'),
);
unittest.expect(
o.targetWindowOption!,
unittest.equals('foo'),
);
}
buildCounterTargetWindow--;
}
core.int buildCounterTargetableRemarketingList = 0;
api.TargetableRemarketingList buildTargetableRemarketingList() {
final o = api.TargetableRemarketingList();
buildCounterTargetableRemarketingList++;
if (buildCounterTargetableRemarketingList < 3) {
o.accountId = 'foo';
o.active = true;
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.description = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.lifeSpan = 'foo';
o.listSize = 'foo';
o.listSource = 'foo';
o.name = 'foo';
o.subaccountId = 'foo';
}
buildCounterTargetableRemarketingList--;
return o;
}
void checkTargetableRemarketingList(api.TargetableRemarketingList o) {
buildCounterTargetableRemarketingList++;
if (buildCounterTargetableRemarketingList < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.active!, unittest.isTrue);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.lifeSpan!,
unittest.equals('foo'),
);
unittest.expect(
o.listSize!,
unittest.equals('foo'),
);
unittest.expect(
o.listSource!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterTargetableRemarketingList--;
}
core.List<api.TargetableRemarketingList> buildUnnamed207() => [
buildTargetableRemarketingList(),
buildTargetableRemarketingList(),
];
void checkUnnamed207(core.List<api.TargetableRemarketingList> o) {
unittest.expect(o, unittest.hasLength(2));
checkTargetableRemarketingList(o[0]);
checkTargetableRemarketingList(o[1]);
}
core.int buildCounterTargetableRemarketingListsListResponse = 0;
api.TargetableRemarketingListsListResponse
buildTargetableRemarketingListsListResponse() {
final o = api.TargetableRemarketingListsListResponse();
buildCounterTargetableRemarketingListsListResponse++;
if (buildCounterTargetableRemarketingListsListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.targetableRemarketingLists = buildUnnamed207();
}
buildCounterTargetableRemarketingListsListResponse--;
return o;
}
void checkTargetableRemarketingListsListResponse(
api.TargetableRemarketingListsListResponse o) {
buildCounterTargetableRemarketingListsListResponse++;
if (buildCounterTargetableRemarketingListsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed207(o.targetableRemarketingLists!);
}
buildCounterTargetableRemarketingListsListResponse--;
}
core.int buildCounterTargetingTemplate = 0;
api.TargetingTemplate buildTargetingTemplate() {
final o = api.TargetingTemplate();
buildCounterTargetingTemplate++;
if (buildCounterTargetingTemplate < 3) {
o.accountId = 'foo';
o.advertiserId = 'foo';
o.advertiserIdDimensionValue = buildDimensionValue();
o.dayPartTargeting = buildDayPartTargeting();
o.geoTargeting = buildGeoTargeting();
o.id = 'foo';
o.keyValueTargetingExpression = buildKeyValueTargetingExpression();
o.kind = 'foo';
o.languageTargeting = buildLanguageTargeting();
o.listTargetingExpression = buildListTargetingExpression();
o.name = 'foo';
o.subaccountId = 'foo';
o.technologyTargeting = buildTechnologyTargeting();
}
buildCounterTargetingTemplate--;
return o;
}
void checkTargetingTemplate(api.TargetingTemplate o) {
buildCounterTargetingTemplate++;
if (buildCounterTargetingTemplate < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.advertiserId!,
unittest.equals('foo'),
);
checkDimensionValue(o.advertiserIdDimensionValue!);
checkDayPartTargeting(o.dayPartTargeting!);
checkGeoTargeting(o.geoTargeting!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkKeyValueTargetingExpression(o.keyValueTargetingExpression!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkLanguageTargeting(o.languageTargeting!);
checkListTargetingExpression(o.listTargetingExpression!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
checkTechnologyTargeting(o.technologyTargeting!);
}
buildCounterTargetingTemplate--;
}
core.List<api.TargetingTemplate> buildUnnamed208() => [
buildTargetingTemplate(),
buildTargetingTemplate(),
];
void checkUnnamed208(core.List<api.TargetingTemplate> o) {
unittest.expect(o, unittest.hasLength(2));
checkTargetingTemplate(o[0]);
checkTargetingTemplate(o[1]);
}
core.int buildCounterTargetingTemplatesListResponse = 0;
api.TargetingTemplatesListResponse buildTargetingTemplatesListResponse() {
final o = api.TargetingTemplatesListResponse();
buildCounterTargetingTemplatesListResponse++;
if (buildCounterTargetingTemplatesListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.targetingTemplates = buildUnnamed208();
}
buildCounterTargetingTemplatesListResponse--;
return o;
}
void checkTargetingTemplatesListResponse(api.TargetingTemplatesListResponse o) {
buildCounterTargetingTemplatesListResponse++;
if (buildCounterTargetingTemplatesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed208(o.targetingTemplates!);
}
buildCounterTargetingTemplatesListResponse--;
}
core.List<api.Browser> buildUnnamed209() => [
buildBrowser(),
buildBrowser(),
];
void checkUnnamed209(core.List<api.Browser> o) {
unittest.expect(o, unittest.hasLength(2));
checkBrowser(o[0]);
checkBrowser(o[1]);
}
core.List<api.ConnectionType> buildUnnamed210() => [
buildConnectionType(),
buildConnectionType(),
];
void checkUnnamed210(core.List<api.ConnectionType> o) {
unittest.expect(o, unittest.hasLength(2));
checkConnectionType(o[0]);
checkConnectionType(o[1]);
}
core.List<api.MobileCarrier> buildUnnamed211() => [
buildMobileCarrier(),
buildMobileCarrier(),
];
void checkUnnamed211(core.List<api.MobileCarrier> o) {
unittest.expect(o, unittest.hasLength(2));
checkMobileCarrier(o[0]);
checkMobileCarrier(o[1]);
}
core.List<api.OperatingSystemVersion> buildUnnamed212() => [
buildOperatingSystemVersion(),
buildOperatingSystemVersion(),
];
void checkUnnamed212(core.List<api.OperatingSystemVersion> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperatingSystemVersion(o[0]);
checkOperatingSystemVersion(o[1]);
}
core.List<api.OperatingSystem> buildUnnamed213() => [
buildOperatingSystem(),
buildOperatingSystem(),
];
void checkUnnamed213(core.List<api.OperatingSystem> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperatingSystem(o[0]);
checkOperatingSystem(o[1]);
}
core.List<api.PlatformType> buildUnnamed214() => [
buildPlatformType(),
buildPlatformType(),
];
void checkUnnamed214(core.List<api.PlatformType> o) {
unittest.expect(o, unittest.hasLength(2));
checkPlatformType(o[0]);
checkPlatformType(o[1]);
}
core.int buildCounterTechnologyTargeting = 0;
api.TechnologyTargeting buildTechnologyTargeting() {
final o = api.TechnologyTargeting();
buildCounterTechnologyTargeting++;
if (buildCounterTechnologyTargeting < 3) {
o.browsers = buildUnnamed209();
o.connectionTypes = buildUnnamed210();
o.mobileCarriers = buildUnnamed211();
o.operatingSystemVersions = buildUnnamed212();
o.operatingSystems = buildUnnamed213();
o.platformTypes = buildUnnamed214();
}
buildCounterTechnologyTargeting--;
return o;
}
void checkTechnologyTargeting(api.TechnologyTargeting o) {
buildCounterTechnologyTargeting++;
if (buildCounterTechnologyTargeting < 3) {
checkUnnamed209(o.browsers!);
checkUnnamed210(o.connectionTypes!);
checkUnnamed211(o.mobileCarriers!);
checkUnnamed212(o.operatingSystemVersions!);
checkUnnamed213(o.operatingSystems!);
checkUnnamed214(o.platformTypes!);
}
buildCounterTechnologyTargeting--;
}
core.int buildCounterThirdPartyAuthenticationToken = 0;
api.ThirdPartyAuthenticationToken buildThirdPartyAuthenticationToken() {
final o = api.ThirdPartyAuthenticationToken();
buildCounterThirdPartyAuthenticationToken++;
if (buildCounterThirdPartyAuthenticationToken < 3) {
o.name = 'foo';
o.value = 'foo';
}
buildCounterThirdPartyAuthenticationToken--;
return o;
}
void checkThirdPartyAuthenticationToken(api.ThirdPartyAuthenticationToken o) {
buildCounterThirdPartyAuthenticationToken++;
if (buildCounterThirdPartyAuthenticationToken < 3) {
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterThirdPartyAuthenticationToken--;
}
core.int buildCounterThirdPartyTrackingUrl = 0;
api.ThirdPartyTrackingUrl buildThirdPartyTrackingUrl() {
final o = api.ThirdPartyTrackingUrl();
buildCounterThirdPartyTrackingUrl++;
if (buildCounterThirdPartyTrackingUrl < 3) {
o.thirdPartyUrlType = 'foo';
o.url = 'foo';
}
buildCounterThirdPartyTrackingUrl--;
return o;
}
void checkThirdPartyTrackingUrl(api.ThirdPartyTrackingUrl o) {
buildCounterThirdPartyTrackingUrl++;
if (buildCounterThirdPartyTrackingUrl < 3) {
unittest.expect(
o.thirdPartyUrlType!,
unittest.equals('foo'),
);
unittest.expect(
o.url!,
unittest.equals('foo'),
);
}
buildCounterThirdPartyTrackingUrl--;
}
core.List<core.int> buildUnnamed215() => [
42,
42,
];
void checkUnnamed215(core.List<core.int> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(42),
);
unittest.expect(
o[1],
unittest.equals(42),
);
}
core.int buildCounterTranscodeSetting = 0;
api.TranscodeSetting buildTranscodeSetting() {
final o = api.TranscodeSetting();
buildCounterTranscodeSetting++;
if (buildCounterTranscodeSetting < 3) {
o.enabledVideoFormats = buildUnnamed215();
o.kind = 'foo';
}
buildCounterTranscodeSetting--;
return o;
}
void checkTranscodeSetting(api.TranscodeSetting o) {
buildCounterTranscodeSetting++;
if (buildCounterTranscodeSetting < 3) {
checkUnnamed215(o.enabledVideoFormats!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterTranscodeSetting--;
}
core.int buildCounterUniversalAdId = 0;
api.UniversalAdId buildUniversalAdId() {
final o = api.UniversalAdId();
buildCounterUniversalAdId++;
if (buildCounterUniversalAdId < 3) {
o.registry = 'foo';
o.value = 'foo';
}
buildCounterUniversalAdId--;
return o;
}
void checkUniversalAdId(api.UniversalAdId o) {
buildCounterUniversalAdId++;
if (buildCounterUniversalAdId < 3) {
unittest.expect(
o.registry!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterUniversalAdId--;
}
core.int buildCounterUserDefinedVariableConfiguration = 0;
api.UserDefinedVariableConfiguration buildUserDefinedVariableConfiguration() {
final o = api.UserDefinedVariableConfiguration();
buildCounterUserDefinedVariableConfiguration++;
if (buildCounterUserDefinedVariableConfiguration < 3) {
o.dataType = 'foo';
o.reportName = 'foo';
o.variableType = 'foo';
}
buildCounterUserDefinedVariableConfiguration--;
return o;
}
void checkUserDefinedVariableConfiguration(
api.UserDefinedVariableConfiguration o) {
buildCounterUserDefinedVariableConfiguration++;
if (buildCounterUserDefinedVariableConfiguration < 3) {
unittest.expect(
o.dataType!,
unittest.equals('foo'),
);
unittest.expect(
o.reportName!,
unittest.equals('foo'),
);
unittest.expect(
o.variableType!,
unittest.equals('foo'),
);
}
buildCounterUserDefinedVariableConfiguration--;
}
core.int buildCounterUserIdentifier = 0;
api.UserIdentifier buildUserIdentifier() {
final o = api.UserIdentifier();
buildCounterUserIdentifier++;
if (buildCounterUserIdentifier < 3) {
o.addressInfo = buildOfflineUserAddressInfo();
o.hashedEmail = 'foo';
o.hashedPhoneNumber = 'foo';
}
buildCounterUserIdentifier--;
return o;
}
void checkUserIdentifier(api.UserIdentifier o) {
buildCounterUserIdentifier++;
if (buildCounterUserIdentifier < 3) {
checkOfflineUserAddressInfo(o.addressInfo!);
unittest.expect(
o.hashedEmail!,
unittest.equals('foo'),
);
unittest.expect(
o.hashedPhoneNumber!,
unittest.equals('foo'),
);
}
buildCounterUserIdentifier--;
}
core.int buildCounterUserProfile = 0;
api.UserProfile buildUserProfile() {
final o = api.UserProfile();
buildCounterUserProfile++;
if (buildCounterUserProfile < 3) {
o.accountId = 'foo';
o.accountName = 'foo';
o.etag = 'foo';
o.kind = 'foo';
o.profileId = 'foo';
o.subAccountId = 'foo';
o.subAccountName = 'foo';
o.userName = 'foo';
}
buildCounterUserProfile--;
return o;
}
void checkUserProfile(api.UserProfile o) {
buildCounterUserProfile++;
if (buildCounterUserProfile < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(
o.accountName!,
unittest.equals('foo'),
);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.profileId!,
unittest.equals('foo'),
);
unittest.expect(
o.subAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.subAccountName!,
unittest.equals('foo'),
);
unittest.expect(
o.userName!,
unittest.equals('foo'),
);
}
buildCounterUserProfile--;
}
core.List<api.UserProfile> buildUnnamed216() => [
buildUserProfile(),
buildUserProfile(),
];
void checkUnnamed216(core.List<api.UserProfile> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserProfile(o[0]);
checkUserProfile(o[1]);
}
core.int buildCounterUserProfileList = 0;
api.UserProfileList buildUserProfileList() {
final o = api.UserProfileList();
buildCounterUserProfileList++;
if (buildCounterUserProfileList < 3) {
o.etag = 'foo';
o.items = buildUnnamed216();
o.kind = 'foo';
}
buildCounterUserProfileList--;
return o;
}
void checkUserProfileList(api.UserProfileList o) {
buildCounterUserProfileList++;
if (buildCounterUserProfileList < 3) {
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
checkUnnamed216(o.items!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
}
buildCounterUserProfileList--;
}
core.List<api.UserRolePermission> buildUnnamed217() => [
buildUserRolePermission(),
buildUserRolePermission(),
];
void checkUnnamed217(core.List<api.UserRolePermission> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserRolePermission(o[0]);
checkUserRolePermission(o[1]);
}
core.int buildCounterUserRole = 0;
api.UserRole buildUserRole() {
final o = api.UserRole();
buildCounterUserRole++;
if (buildCounterUserRole < 3) {
o.accountId = 'foo';
o.defaultUserRole = true;
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.parentUserRoleId = 'foo';
o.permissions = buildUnnamed217();
o.subaccountId = 'foo';
}
buildCounterUserRole--;
return o;
}
void checkUserRole(api.UserRole o) {
buildCounterUserRole++;
if (buildCounterUserRole < 3) {
unittest.expect(
o.accountId!,
unittest.equals('foo'),
);
unittest.expect(o.defaultUserRole!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.parentUserRoleId!,
unittest.equals('foo'),
);
checkUnnamed217(o.permissions!);
unittest.expect(
o.subaccountId!,
unittest.equals('foo'),
);
}
buildCounterUserRole--;
}
core.int buildCounterUserRolePermission = 0;
api.UserRolePermission buildUserRolePermission() {
final o = api.UserRolePermission();
buildCounterUserRolePermission++;
if (buildCounterUserRolePermission < 3) {
o.availability = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.permissionGroupId = 'foo';
}
buildCounterUserRolePermission--;
return o;
}
void checkUserRolePermission(api.UserRolePermission o) {
buildCounterUserRolePermission++;
if (buildCounterUserRolePermission < 3) {
unittest.expect(
o.availability!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.permissionGroupId!,
unittest.equals('foo'),
);
}
buildCounterUserRolePermission--;
}
core.int buildCounterUserRolePermissionGroup = 0;
api.UserRolePermissionGroup buildUserRolePermissionGroup() {
final o = api.UserRolePermissionGroup();
buildCounterUserRolePermissionGroup++;
if (buildCounterUserRolePermissionGroup < 3) {
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
}
buildCounterUserRolePermissionGroup--;
return o;
}
void checkUserRolePermissionGroup(api.UserRolePermissionGroup o) {
buildCounterUserRolePermissionGroup++;
if (buildCounterUserRolePermissionGroup < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterUserRolePermissionGroup--;
}
core.List<api.UserRolePermissionGroup> buildUnnamed218() => [
buildUserRolePermissionGroup(),
buildUserRolePermissionGroup(),
];
void checkUnnamed218(core.List<api.UserRolePermissionGroup> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserRolePermissionGroup(o[0]);
checkUserRolePermissionGroup(o[1]);
}
core.int buildCounterUserRolePermissionGroupsListResponse = 0;
api.UserRolePermissionGroupsListResponse
buildUserRolePermissionGroupsListResponse() {
final o = api.UserRolePermissionGroupsListResponse();
buildCounterUserRolePermissionGroupsListResponse++;
if (buildCounterUserRolePermissionGroupsListResponse < 3) {
o.kind = 'foo';
o.userRolePermissionGroups = buildUnnamed218();
}
buildCounterUserRolePermissionGroupsListResponse--;
return o;
}
void checkUserRolePermissionGroupsListResponse(
api.UserRolePermissionGroupsListResponse o) {
buildCounterUserRolePermissionGroupsListResponse++;
if (buildCounterUserRolePermissionGroupsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed218(o.userRolePermissionGroups!);
}
buildCounterUserRolePermissionGroupsListResponse--;
}
core.List<api.UserRolePermission> buildUnnamed219() => [
buildUserRolePermission(),
buildUserRolePermission(),
];
void checkUnnamed219(core.List<api.UserRolePermission> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserRolePermission(o[0]);
checkUserRolePermission(o[1]);
}
core.int buildCounterUserRolePermissionsListResponse = 0;
api.UserRolePermissionsListResponse buildUserRolePermissionsListResponse() {
final o = api.UserRolePermissionsListResponse();
buildCounterUserRolePermissionsListResponse++;
if (buildCounterUserRolePermissionsListResponse < 3) {
o.kind = 'foo';
o.userRolePermissions = buildUnnamed219();
}
buildCounterUserRolePermissionsListResponse--;
return o;
}
void checkUserRolePermissionsListResponse(
api.UserRolePermissionsListResponse o) {
buildCounterUserRolePermissionsListResponse++;
if (buildCounterUserRolePermissionsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed219(o.userRolePermissions!);
}
buildCounterUserRolePermissionsListResponse--;
}
core.List<api.UserRole> buildUnnamed220() => [
buildUserRole(),
buildUserRole(),
];
void checkUnnamed220(core.List<api.UserRole> o) {
unittest.expect(o, unittest.hasLength(2));
checkUserRole(o[0]);
checkUserRole(o[1]);
}
core.int buildCounterUserRolesListResponse = 0;
api.UserRolesListResponse buildUserRolesListResponse() {
final o = api.UserRolesListResponse();
buildCounterUserRolesListResponse++;
if (buildCounterUserRolesListResponse < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.userRoles = buildUnnamed220();
}
buildCounterUserRolesListResponse--;
return o;
}
void checkUserRolesListResponse(api.UserRolesListResponse o) {
buildCounterUserRolesListResponse++;
if (buildCounterUserRolesListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed220(o.userRoles!);
}
buildCounterUserRolesListResponse--;
}
core.List<core.String> buildUnnamed221() => [
'foo',
'foo',
];
void checkUnnamed221(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterUvarFilter = 0;
api.UvarFilter buildUvarFilter() {
final o = api.UvarFilter();
buildCounterUvarFilter++;
if (buildCounterUvarFilter < 3) {
o.complement = true;
o.index = 'foo';
o.kind = 'foo';
o.match = 'foo';
o.values = buildUnnamed221();
}
buildCounterUvarFilter--;
return o;
}
void checkUvarFilter(api.UvarFilter o) {
buildCounterUvarFilter++;
if (buildCounterUvarFilter < 3) {
unittest.expect(o.complement!, unittest.isTrue);
unittest.expect(
o.index!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.match!,
unittest.equals('foo'),
);
checkUnnamed221(o.values!);
}
buildCounterUvarFilter--;
}
core.int buildCounterVideoFormat = 0;
api.VideoFormat buildVideoFormat() {
final o = api.VideoFormat();
buildCounterVideoFormat++;
if (buildCounterVideoFormat < 3) {
o.fileType = 'foo';
o.id = 42;
o.kind = 'foo';
o.resolution = buildSize();
o.targetBitRate = 42;
}
buildCounterVideoFormat--;
return o;
}
void checkVideoFormat(api.VideoFormat o) {
buildCounterVideoFormat++;
if (buildCounterVideoFormat < 3) {
unittest.expect(
o.fileType!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals(42),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkSize(o.resolution!);
unittest.expect(
o.targetBitRate!,
unittest.equals(42),
);
}
buildCounterVideoFormat--;
}
core.List<api.VideoFormat> buildUnnamed222() => [
buildVideoFormat(),
buildVideoFormat(),
];
void checkUnnamed222(core.List<api.VideoFormat> o) {
unittest.expect(o, unittest.hasLength(2));
checkVideoFormat(o[0]);
checkVideoFormat(o[1]);
}
core.int buildCounterVideoFormatsListResponse = 0;
api.VideoFormatsListResponse buildVideoFormatsListResponse() {
final o = api.VideoFormatsListResponse();
buildCounterVideoFormatsListResponse++;
if (buildCounterVideoFormatsListResponse < 3) {
o.kind = 'foo';
o.videoFormats = buildUnnamed222();
}
buildCounterVideoFormatsListResponse--;
return o;
}
void checkVideoFormatsListResponse(api.VideoFormatsListResponse o) {
buildCounterVideoFormatsListResponse++;
if (buildCounterVideoFormatsListResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed222(o.videoFormats!);
}
buildCounterVideoFormatsListResponse--;
}
core.int buildCounterVideoOffset = 0;
api.VideoOffset buildVideoOffset() {
final o = api.VideoOffset();
buildCounterVideoOffset++;
if (buildCounterVideoOffset < 3) {
o.offsetPercentage = 42;
o.offsetSeconds = 42;
}
buildCounterVideoOffset--;
return o;
}
void checkVideoOffset(api.VideoOffset o) {
buildCounterVideoOffset++;
if (buildCounterVideoOffset < 3) {
unittest.expect(
o.offsetPercentage!,
unittest.equals(42),
);
unittest.expect(
o.offsetSeconds!,
unittest.equals(42),
);
}
buildCounterVideoOffset--;
}
core.int buildCounterVideoSettings = 0;
api.VideoSettings buildVideoSettings() {
final o = api.VideoSettings();
buildCounterVideoSettings++;
if (buildCounterVideoSettings < 3) {
o.companionSettings = buildCompanionSetting();
o.durationSeconds = 42;
o.kind = 'foo';
o.obaEnabled = true;
o.obaSettings = buildObaIcon();
o.orientation = 'foo';
o.publisherSpecificationId = 'foo';
o.skippableSettings = buildSkippableSetting();
o.transcodeSettings = buildTranscodeSetting();
}
buildCounterVideoSettings--;
return o;
}
void checkVideoSettings(api.VideoSettings o) {
buildCounterVideoSettings++;
if (buildCounterVideoSettings < 3) {
checkCompanionSetting(o.companionSettings!);
unittest.expect(
o.durationSeconds!,
unittest.equals(42),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.obaEnabled!, unittest.isTrue);
checkObaIcon(o.obaSettings!);
unittest.expect(
o.orientation!,
unittest.equals('foo'),
);
unittest.expect(
o.publisherSpecificationId!,
unittest.equals('foo'),
);
checkSkippableSetting(o.skippableSettings!);
checkTranscodeSetting(o.transcodeSettings!);
}
buildCounterVideoSettings--;
}
core.List<core.String> buildUnnamed223() => [
'foo',
'foo',
];
void checkUnnamed223(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed224() => [
'foo',
'foo',
];
void checkUnnamed224(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed225() => [
'foo',
'foo',
];
void checkUnnamed225(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed226() => [
'foo',
'foo',
];
void checkUnnamed226(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed227() => [
'foo',
'foo',
];
void checkUnnamed227(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed228() => [
'foo',
'foo',
];
void checkUnnamed228(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed229() => [
'foo',
'foo',
];
void checkUnnamed229(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed230() => [
'foo',
'foo',
];
void checkUnnamed230(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed231() => [
'foo',
'foo',
];
void checkUnnamed231(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed232() => [
'foo',
'foo',
];
void checkUnnamed232(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed233() => [
'foo',
'foo',
];
void checkUnnamed233(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed234() => [
'foo',
'foo',
];
void checkUnnamed234(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed235() => [
'foo',
'foo',
];
void checkUnnamed235(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed236() => [
'foo',
'foo',
];
void checkUnnamed236(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed237() => [
'foo',
'foo',
];
void checkUnnamed237(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed238() => [
'foo',
'foo',
];
void checkUnnamed238(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed239() => [
'foo',
'foo',
];
void checkUnnamed239(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed240() => [
'foo',
'foo',
];
void checkUnnamed240(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed241() => [
'foo',
'foo',
];
void checkUnnamed241(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed242() => [
'foo',
'foo',
];
void checkUnnamed242(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed243() => [
'foo',
'foo',
];
void checkUnnamed243(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed244() => [
'foo',
'foo',
];
void checkUnnamed244(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed245() => [
'foo',
'foo',
];
void checkUnnamed245(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed246() => [
'foo',
'foo',
];
void checkUnnamed246(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed247() => [
'foo',
'foo',
];
void checkUnnamed247(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed248() => [
'foo',
'foo',
];
void checkUnnamed248(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed249() => [
'foo',
'foo',
];
void checkUnnamed249(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed250() => [
'foo',
'foo',
];
void checkUnnamed250(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed251() => [
'foo',
'foo',
];
void checkUnnamed251(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed252() => [
'foo',
'foo',
];
void checkUnnamed252(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed253() => [
'foo',
'foo',
];
void checkUnnamed253(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed254() => [
'foo',
'foo',
];
void checkUnnamed254(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed255() => [
'foo',
'foo',
];
void checkUnnamed255(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed256() => [
'foo',
'foo',
];
void checkUnnamed256(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed257() => [
'foo',
'foo',
];
void checkUnnamed257(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed258() => [
'foo',
'foo',
];
void checkUnnamed258(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed259() => [
'foo',
'foo',
];
void checkUnnamed259(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed260() => [
'foo',
'foo',
];
void checkUnnamed260(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed261() => [
'foo',
'foo',
];
void checkUnnamed261(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed262() => [
'foo',
'foo',
];
void checkUnnamed262(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed263() => [
'foo',
'foo',
];
void checkUnnamed263(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed264() => [
'foo',
'foo',
];
void checkUnnamed264(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed265() => [
'foo',
'foo',
];
void checkUnnamed265(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed266() => [
'foo',
'foo',
];
void checkUnnamed266(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed267() => [
'foo',
'foo',
];
void checkUnnamed267(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed268() => [
'foo',
'foo',
];
void checkUnnamed268(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed269() => [
'foo',
'foo',
];
void checkUnnamed269(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed270() => [
'foo',
'foo',
];
void checkUnnamed270(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed271() => [
'foo',
'foo',
];
void checkUnnamed271(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed272() => [
'foo',
'foo',
];
void checkUnnamed272(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed273() => [
'foo',
'foo',
];
void checkUnnamed273(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed274() => [
'foo',
'foo',
];
void checkUnnamed274(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed275() => [
'foo',
'foo',
];
void checkUnnamed275(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed276() => [
'foo',
'foo',
];
void checkUnnamed276(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed277() => [
'foo',
'foo',
];
void checkUnnamed277(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed278() => [
'foo',
'foo',
];
void checkUnnamed278(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed279() => [
'foo',
'foo',
];
void checkUnnamed279(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed280() => [
'foo',
'foo',
];
void checkUnnamed280(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed281() => [
'foo',
'foo',
];
void checkUnnamed281(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed282() => [
'foo',
'foo',
];
void checkUnnamed282(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed283() => [
'foo',
'foo',
];
void checkUnnamed283(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed284() => [
'foo',
'foo',
];
void checkUnnamed284(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed285() => [
'foo',
'foo',
];
void checkUnnamed285(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed286() => [
'foo',
'foo',
];
void checkUnnamed286(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed287() => [
'foo',
'foo',
];
void checkUnnamed287(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed288() => [
'foo',
'foo',
];
void checkUnnamed288(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed289() => [
'foo',
'foo',
];
void checkUnnamed289(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed290() => [
'foo',
'foo',
];
void checkUnnamed290(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed291() => [
'foo',
'foo',
];
void checkUnnamed291(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed292() => [
'foo',
'foo',
];
void checkUnnamed292(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed293() => [
'foo',
'foo',
];
void checkUnnamed293(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed294() => [
'foo',
'foo',
];
void checkUnnamed294(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed295() => [
'foo',
'foo',
];
void checkUnnamed295(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed296() => [
'foo',
'foo',
];
void checkUnnamed296(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed297() => [
'foo',
'foo',
];
void checkUnnamed297(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed298() => [
'foo',
'foo',
];
void checkUnnamed298(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed299() => [
'foo',
'foo',
];
void checkUnnamed299(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed300() => [
'foo',
'foo',
];
void checkUnnamed300(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed301() => [
'foo',
'foo',
];
void checkUnnamed301(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed302() => [
'foo',
'foo',
];
void checkUnnamed302(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed303() => [
'foo',
'foo',
];
void checkUnnamed303(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed304() => [
'foo',
'foo',
];
void checkUnnamed304(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed305() => [
'foo',
'foo',
];
void checkUnnamed305(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed306() => [
'foo',
'foo',
];
void checkUnnamed306(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed307() => [
'foo',
'foo',
];
void checkUnnamed307(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed308() => [
'foo',
'foo',
];
void checkUnnamed308(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed309() => [
'foo',
'foo',
];
void checkUnnamed309(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed310() => [
'foo',
'foo',
];
void checkUnnamed310(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed311() => [
'foo',
'foo',
];
void checkUnnamed311(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed312() => [
'foo',
'foo',
];
void checkUnnamed312(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed313() => [
'foo',
'foo',
];
void checkUnnamed313(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed314() => [
'foo',
'foo',
];
void checkUnnamed314(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed315() => [
'foo',
'foo',
];
void checkUnnamed315(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
void main() {
unittest.group('obj-schema-Account', () {
unittest.test('to-json--from-json', () async {
final o = buildAccount();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Account.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAccount(od);
});
});
unittest.group('obj-schema-AccountActiveAdSummary', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountActiveAdSummary();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountActiveAdSummary.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountActiveAdSummary(od);
});
});
unittest.group('obj-schema-AccountPermission', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountPermission();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountPermission.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountPermission(od);
});
});
unittest.group('obj-schema-AccountPermissionGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountPermissionGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountPermissionGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountPermissionGroup(od);
});
});
unittest.group('obj-schema-AccountPermissionGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountPermissionGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountPermissionGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountPermissionGroupsListResponse(od);
});
});
unittest.group('obj-schema-AccountPermissionsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountPermissionsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountPermissionsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountPermissionsListResponse(od);
});
});
unittest.group('obj-schema-AccountUserProfile', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountUserProfile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountUserProfile.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountUserProfile(od);
});
});
unittest.group('obj-schema-AccountUserProfilesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountUserProfilesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountUserProfilesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountUserProfilesListResponse(od);
});
});
unittest.group('obj-schema-AccountsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountsListResponse(od);
});
});
unittest.group('obj-schema-Activities', () {
unittest.test('to-json--from-json', () async {
final o = buildActivities();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Activities.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkActivities(od);
});
});
unittest.group('obj-schema-Ad', () {
unittest.test('to-json--from-json', () async {
final o = buildAd();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Ad.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAd(od);
});
});
unittest.group('obj-schema-AdBlockingConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildAdBlockingConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdBlockingConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdBlockingConfiguration(od);
});
});
unittest.group('obj-schema-AdSlot', () {
unittest.test('to-json--from-json', () async {
final o = buildAdSlot();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.AdSlot.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAdSlot(od);
});
});
unittest.group('obj-schema-AdsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAdsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdsListResponse(od);
});
});
unittest.group('obj-schema-Advertiser', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertiser();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Advertiser.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAdvertiser(od);
});
});
unittest.group('obj-schema-AdvertiserGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertiserGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvertiserGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvertiserGroup(od);
});
});
unittest.group('obj-schema-AdvertiserGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertiserGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvertiserGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvertiserGroupsListResponse(od);
});
});
unittest.group('obj-schema-AdvertiserInvoicesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertiserInvoicesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvertiserInvoicesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvertiserInvoicesListResponse(od);
});
});
unittest.group('obj-schema-AdvertiserLandingPagesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertiserLandingPagesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvertiserLandingPagesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvertiserLandingPagesListResponse(od);
});
});
unittest.group('obj-schema-AdvertisersListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildAdvertisersListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AdvertisersListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAdvertisersListResponse(od);
});
});
unittest.group('obj-schema-AudienceSegment', () {
unittest.test('to-json--from-json', () async {
final o = buildAudienceSegment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AudienceSegment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAudienceSegment(od);
});
});
unittest.group('obj-schema-AudienceSegmentGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildAudienceSegmentGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AudienceSegmentGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAudienceSegmentGroup(od);
});
});
unittest.group('obj-schema-BillingAssignment', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingAssignment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingAssignment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingAssignment(od);
});
});
unittest.group('obj-schema-BillingAssignmentsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingAssignmentsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingAssignmentsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingAssignmentsListResponse(od);
});
});
unittest.group('obj-schema-BillingProfile', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingProfile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingProfile.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingProfile(od);
});
});
unittest.group('obj-schema-BillingProfilesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingProfilesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingProfilesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingProfilesListResponse(od);
});
});
unittest.group('obj-schema-BillingRate', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingRate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingRate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingRate(od);
});
});
unittest.group('obj-schema-BillingRateTieredRate', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingRateTieredRate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingRateTieredRate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingRateTieredRate(od);
});
});
unittest.group('obj-schema-BillingRatesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildBillingRatesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BillingRatesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBillingRatesListResponse(od);
});
});
unittest.group('obj-schema-Browser', () {
unittest.test('to-json--from-json', () async {
final o = buildBrowser();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Browser.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkBrowser(od);
});
});
unittest.group('obj-schema-BrowsersListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildBrowsersListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BrowsersListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBrowsersListResponse(od);
});
});
unittest.group('obj-schema-Campaign', () {
unittest.test('to-json--from-json', () async {
final o = buildCampaign();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Campaign.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCampaign(od);
});
});
unittest.group('obj-schema-CampaignCreativeAssociation', () {
unittest.test('to-json--from-json', () async {
final o = buildCampaignCreativeAssociation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CampaignCreativeAssociation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCampaignCreativeAssociation(od);
});
});
unittest.group('obj-schema-CampaignCreativeAssociationsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCampaignCreativeAssociationsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CampaignCreativeAssociationsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCampaignCreativeAssociationsListResponse(od);
});
});
unittest.group('obj-schema-CampaignSummary', () {
unittest.test('to-json--from-json', () async {
final o = buildCampaignSummary();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CampaignSummary.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCampaignSummary(od);
});
});
unittest.group('obj-schema-CampaignsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCampaignsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CampaignsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCampaignsListResponse(od);
});
});
unittest.group('obj-schema-ChangeLog', () {
unittest.test('to-json--from-json', () async {
final o = buildChangeLog();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ChangeLog.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkChangeLog(od);
});
});
unittest.group('obj-schema-ChangeLogsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildChangeLogsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ChangeLogsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkChangeLogsListResponse(od);
});
});
unittest.group('obj-schema-ChannelGrouping', () {
unittest.test('to-json--from-json', () async {
final o = buildChannelGrouping();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ChannelGrouping.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkChannelGrouping(od);
});
});
unittest.group('obj-schema-ChannelGroupingRule', () {
unittest.test('to-json--from-json', () async {
final o = buildChannelGroupingRule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ChannelGroupingRule.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkChannelGroupingRule(od);
});
});
unittest.group('obj-schema-CitiesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCitiesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CitiesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCitiesListResponse(od);
});
});
unittest.group('obj-schema-City', () {
unittest.test('to-json--from-json', () async {
final o = buildCity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.City.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCity(od);
});
});
unittest.group('obj-schema-ClickTag', () {
unittest.test('to-json--from-json', () async {
final o = buildClickTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ClickTag.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkClickTag(od);
});
});
unittest.group('obj-schema-ClickThroughUrl', () {
unittest.test('to-json--from-json', () async {
final o = buildClickThroughUrl();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClickThroughUrl.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClickThroughUrl(od);
});
});
unittest.group('obj-schema-ClickThroughUrlSuffixProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildClickThroughUrlSuffixProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ClickThroughUrlSuffixProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkClickThroughUrlSuffixProperties(od);
});
});
unittest.group('obj-schema-CompanionClickThroughOverride', () {
unittest.test('to-json--from-json', () async {
final o = buildCompanionClickThroughOverride();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CompanionClickThroughOverride.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCompanionClickThroughOverride(od);
});
});
unittest.group('obj-schema-CompanionSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildCompanionSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CompanionSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCompanionSetting(od);
});
});
unittest.group('obj-schema-CompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCompatibleFields(od);
});
});
unittest.group('obj-schema-ConnectionType', () {
unittest.test('to-json--from-json', () async {
final o = buildConnectionType();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConnectionType.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConnectionType(od);
});
});
unittest.group('obj-schema-ConnectionTypesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildConnectionTypesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConnectionTypesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConnectionTypesListResponse(od);
});
});
unittest.group('obj-schema-ContentCategoriesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildContentCategoriesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ContentCategoriesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkContentCategoriesListResponse(od);
});
});
unittest.group('obj-schema-ContentCategory', () {
unittest.test('to-json--from-json', () async {
final o = buildContentCategory();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ContentCategory.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkContentCategory(od);
});
});
unittest.group('obj-schema-Conversion', () {
unittest.test('to-json--from-json', () async {
final o = buildConversion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Conversion.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkConversion(od);
});
});
unittest.group('obj-schema-ConversionError', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionError();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionError.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionError(od);
});
});
unittest.group('obj-schema-ConversionStatus', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionStatus.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionStatus(od);
});
});
unittest.group('obj-schema-ConversionsBatchInsertRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionsBatchInsertRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionsBatchInsertRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionsBatchInsertRequest(od);
});
});
unittest.group('obj-schema-ConversionsBatchInsertResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionsBatchInsertResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionsBatchInsertResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionsBatchInsertResponse(od);
});
});
unittest.group('obj-schema-ConversionsBatchUpdateRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionsBatchUpdateRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionsBatchUpdateRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionsBatchUpdateRequest(od);
});
});
unittest.group('obj-schema-ConversionsBatchUpdateResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildConversionsBatchUpdateResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConversionsBatchUpdateResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConversionsBatchUpdateResponse(od);
});
});
unittest.group('obj-schema-CountriesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCountriesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CountriesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCountriesListResponse(od);
});
});
unittest.group('obj-schema-Country', () {
unittest.test('to-json--from-json', () async {
final o = buildCountry();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Country.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCountry(od);
});
});
unittest.group('obj-schema-Creative', () {
unittest.test('to-json--from-json', () async {
final o = buildCreative();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Creative.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkCreative(od);
});
});
unittest.group('obj-schema-CreativeAsset', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeAsset();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeAsset.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeAsset(od);
});
});
unittest.group('obj-schema-CreativeAssetId', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeAssetId();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeAssetId.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeAssetId(od);
});
});
unittest.group('obj-schema-CreativeAssetMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeAssetMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeAssetMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeAssetMetadata(od);
});
});
unittest.group('obj-schema-CreativeAssetSelection', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeAssetSelection();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeAssetSelection.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeAssetSelection(od);
});
});
unittest.group('obj-schema-CreativeAssignment', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeAssignment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeAssignment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeAssignment(od);
});
});
unittest.group('obj-schema-CreativeClickThroughUrl', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeClickThroughUrl();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeClickThroughUrl.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeClickThroughUrl(od);
});
});
unittest.group('obj-schema-CreativeCustomEvent', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeCustomEvent();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeCustomEvent.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeCustomEvent(od);
});
});
unittest.group('obj-schema-CreativeField', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeField();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeField.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeField(od);
});
});
unittest.group('obj-schema-CreativeFieldAssignment', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeFieldAssignment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeFieldAssignment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeFieldAssignment(od);
});
});
unittest.group('obj-schema-CreativeFieldValue', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeFieldValue();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeFieldValue.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeFieldValue(od);
});
});
unittest.group('obj-schema-CreativeFieldValuesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeFieldValuesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeFieldValuesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeFieldValuesListResponse(od);
});
});
unittest.group('obj-schema-CreativeFieldsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeFieldsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeFieldsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeFieldsListResponse(od);
});
});
unittest.group('obj-schema-CreativeGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeGroup(od);
});
});
unittest.group('obj-schema-CreativeGroupAssignment', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeGroupAssignment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeGroupAssignment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeGroupAssignment(od);
});
});
unittest.group('obj-schema-CreativeGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeGroupsListResponse(od);
});
});
unittest.group('obj-schema-CreativeOptimizationConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeOptimizationConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeOptimizationConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeOptimizationConfiguration(od);
});
});
unittest.group('obj-schema-CreativeRotation', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativeRotation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativeRotation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativeRotation(od);
});
});
unittest.group('obj-schema-CreativesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCreativesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreativesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreativesListResponse(od);
});
});
unittest.group('obj-schema-CrossDimensionReachReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildCrossDimensionReachReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CrossDimensionReachReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCrossDimensionReachReportCompatibleFields(od);
});
});
unittest.group('obj-schema-CustomFloodlightVariable', () {
unittest.test('to-json--from-json', () async {
final o = buildCustomFloodlightVariable();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CustomFloodlightVariable.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCustomFloodlightVariable(od);
});
});
unittest.group('obj-schema-CustomRichMediaEvents', () {
unittest.test('to-json--from-json', () async {
final o = buildCustomRichMediaEvents();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CustomRichMediaEvents.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCustomRichMediaEvents(od);
});
});
unittest.group('obj-schema-CustomViewabilityMetric', () {
unittest.test('to-json--from-json', () async {
final o = buildCustomViewabilityMetric();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CustomViewabilityMetric.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCustomViewabilityMetric(od);
});
});
unittest.group('obj-schema-CustomViewabilityMetricConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildCustomViewabilityMetricConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CustomViewabilityMetricConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCustomViewabilityMetricConfiguration(od);
});
});
unittest.group('obj-schema-DateRange', () {
unittest.test('to-json--from-json', () async {
final o = buildDateRange();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.DateRange.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDateRange(od);
});
});
unittest.group('obj-schema-DayPartTargeting', () {
unittest.test('to-json--from-json', () async {
final o = buildDayPartTargeting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DayPartTargeting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDayPartTargeting(od);
});
});
unittest.group('obj-schema-DeepLink', () {
unittest.test('to-json--from-json', () async {
final o = buildDeepLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.DeepLink.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDeepLink(od);
});
});
unittest.group('obj-schema-DefaultClickThroughEventTagProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildDefaultClickThroughEventTagProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DefaultClickThroughEventTagProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDefaultClickThroughEventTagProperties(od);
});
});
unittest.group('obj-schema-DeliverySchedule', () {
unittest.test('to-json--from-json', () async {
final o = buildDeliverySchedule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DeliverySchedule.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDeliverySchedule(od);
});
});
unittest.group('obj-schema-DfpSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildDfpSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DfpSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDfpSettings(od);
});
});
unittest.group('obj-schema-Dimension', () {
unittest.test('to-json--from-json', () async {
final o = buildDimension();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Dimension.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDimension(od);
});
});
unittest.group('obj-schema-DimensionFilter', () {
unittest.test('to-json--from-json', () async {
final o = buildDimensionFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DimensionFilter.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDimensionFilter(od);
});
});
unittest.group('obj-schema-DimensionValue', () {
unittest.test('to-json--from-json', () async {
final o = buildDimensionValue();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DimensionValue.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDimensionValue(od);
});
});
unittest.group('obj-schema-DimensionValueList', () {
unittest.test('to-json--from-json', () async {
final o = buildDimensionValueList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DimensionValueList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDimensionValueList(od);
});
});
unittest.group('obj-schema-DimensionValueRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildDimensionValueRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DimensionValueRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDimensionValueRequest(od);
});
});
unittest.group('obj-schema-DirectorySite', () {
unittest.test('to-json--from-json', () async {
final o = buildDirectorySite();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DirectorySite.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDirectorySite(od);
});
});
unittest.group('obj-schema-DirectorySiteSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildDirectorySiteSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DirectorySiteSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDirectorySiteSettings(od);
});
});
unittest.group('obj-schema-DirectorySitesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildDirectorySitesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DirectorySitesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDirectorySitesListResponse(od);
});
});
unittest.group('obj-schema-DisjunctiveMatchStatement', () {
unittest.test('to-json--from-json', () async {
final o = buildDisjunctiveMatchStatement();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DisjunctiveMatchStatement.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDisjunctiveMatchStatement(od);
});
});
unittest.group('obj-schema-DynamicTargetingKey', () {
unittest.test('to-json--from-json', () async {
final o = buildDynamicTargetingKey();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DynamicTargetingKey.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDynamicTargetingKey(od);
});
});
unittest.group('obj-schema-DynamicTargetingKeysListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildDynamicTargetingKeysListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DynamicTargetingKeysListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDynamicTargetingKeysListResponse(od);
});
});
unittest.group('obj-schema-EncryptionInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildEncryptionInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EncryptionInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEncryptionInfo(od);
});
});
unittest.group('obj-schema-EventFilter', () {
unittest.test('to-json--from-json', () async {
final o = buildEventFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventFilter.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventFilter(od);
});
});
unittest.group('obj-schema-EventTag', () {
unittest.test('to-json--from-json', () async {
final o = buildEventTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.EventTag.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEventTag(od);
});
});
unittest.group('obj-schema-EventTagOverride', () {
unittest.test('to-json--from-json', () async {
final o = buildEventTagOverride();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventTagOverride.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventTagOverride(od);
});
});
unittest.group('obj-schema-EventTagsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildEventTagsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EventTagsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEventTagsListResponse(od);
});
});
unittest.group('obj-schema-FileUrls', () {
unittest.test('to-json--from-json', () async {
final o = buildFileUrls();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.FileUrls.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFileUrls(od);
});
});
unittest.group('obj-schema-File', () {
unittest.test('to-json--from-json', () async {
final o = buildFile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.File.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFile(od);
});
});
unittest.group('obj-schema-FileList', () {
unittest.test('to-json--from-json', () async {
final o = buildFileList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.FileList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFileList(od);
});
});
unittest.group('obj-schema-Flight', () {
unittest.test('to-json--from-json', () async {
final o = buildFlight();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Flight.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFlight(od);
});
});
unittest.group('obj-schema-FloodlightActivitiesGenerateTagResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivitiesGenerateTagResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivitiesGenerateTagResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivitiesGenerateTagResponse(od);
});
});
unittest.group('obj-schema-FloodlightActivitiesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivitiesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivitiesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivitiesListResponse(od);
});
});
unittest.group('obj-schema-FloodlightActivity', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivity(od);
});
});
unittest.group('obj-schema-FloodlightActivityDynamicTag', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivityDynamicTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivityDynamicTag.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivityDynamicTag(od);
});
});
unittest.group('obj-schema-FloodlightActivityGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivityGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivityGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivityGroup(od);
});
});
unittest.group('obj-schema-FloodlightActivityGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivityGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivityGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivityGroupsListResponse(od);
});
});
unittest.group('obj-schema-FloodlightActivityPublisherDynamicTag', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightActivityPublisherDynamicTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightActivityPublisherDynamicTag.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightActivityPublisherDynamicTag(od);
});
});
unittest.group('obj-schema-FloodlightConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightConfiguration(od);
});
});
unittest.group('obj-schema-FloodlightConfigurationsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightConfigurationsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightConfigurationsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightConfigurationsListResponse(od);
});
});
unittest.group('obj-schema-FloodlightReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildFloodlightReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FloodlightReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFloodlightReportCompatibleFields(od);
});
});
unittest.group('obj-schema-FrequencyCap', () {
unittest.test('to-json--from-json', () async {
final o = buildFrequencyCap();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FrequencyCap.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFrequencyCap(od);
});
});
unittest.group('obj-schema-FsCommand', () {
unittest.test('to-json--from-json', () async {
final o = buildFsCommand();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.FsCommand.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFsCommand(od);
});
});
unittest.group('obj-schema-GeoTargeting', () {
unittest.test('to-json--from-json', () async {
final o = buildGeoTargeting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GeoTargeting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGeoTargeting(od);
});
});
unittest.group('obj-schema-InventoryItem', () {
unittest.test('to-json--from-json', () async {
final o = buildInventoryItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.InventoryItem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkInventoryItem(od);
});
});
unittest.group('obj-schema-InventoryItemsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildInventoryItemsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.InventoryItemsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkInventoryItemsListResponse(od);
});
});
unittest.group('obj-schema-Invoice', () {
unittest.test('to-json--from-json', () async {
final o = buildInvoice();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Invoice.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkInvoice(od);
});
});
unittest.group('obj-schema-KeyValueTargetingExpression', () {
unittest.test('to-json--from-json', () async {
final o = buildKeyValueTargetingExpression();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.KeyValueTargetingExpression.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkKeyValueTargetingExpression(od);
});
});
unittest.group('obj-schema-LandingPage', () {
unittest.test('to-json--from-json', () async {
final o = buildLandingPage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LandingPage.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLandingPage(od);
});
});
unittest.group('obj-schema-Language', () {
unittest.test('to-json--from-json', () async {
final o = buildLanguage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Language.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLanguage(od);
});
});
unittest.group('obj-schema-LanguageTargeting', () {
unittest.test('to-json--from-json', () async {
final o = buildLanguageTargeting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LanguageTargeting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLanguageTargeting(od);
});
});
unittest.group('obj-schema-LanguagesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildLanguagesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LanguagesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLanguagesListResponse(od);
});
});
unittest.group('obj-schema-LastModifiedInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildLastModifiedInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LastModifiedInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLastModifiedInfo(od);
});
});
unittest.group('obj-schema-ListPopulationClause', () {
unittest.test('to-json--from-json', () async {
final o = buildListPopulationClause();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPopulationClause.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPopulationClause(od);
});
});
unittest.group('obj-schema-ListPopulationRule', () {
unittest.test('to-json--from-json', () async {
final o = buildListPopulationRule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPopulationRule.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPopulationRule(od);
});
});
unittest.group('obj-schema-ListPopulationTerm', () {
unittest.test('to-json--from-json', () async {
final o = buildListPopulationTerm();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListPopulationTerm.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListPopulationTerm(od);
});
});
unittest.group('obj-schema-ListTargetingExpression', () {
unittest.test('to-json--from-json', () async {
final o = buildListTargetingExpression();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListTargetingExpression.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListTargetingExpression(od);
});
});
unittest.group('obj-schema-LookbackConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildLookbackConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LookbackConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLookbackConfiguration(od);
});
});
unittest.group('obj-schema-MeasurementPartnerAdvertiserLink', () {
unittest.test('to-json--from-json', () async {
final o = buildMeasurementPartnerAdvertiserLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MeasurementPartnerAdvertiserLink.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMeasurementPartnerAdvertiserLink(od);
});
});
unittest.group('obj-schema-MeasurementPartnerCampaignLink', () {
unittest.test('to-json--from-json', () async {
final o = buildMeasurementPartnerCampaignLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MeasurementPartnerCampaignLink.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMeasurementPartnerCampaignLink(od);
});
});
unittest.group('obj-schema-MeasurementPartnerWrappingData', () {
unittest.test('to-json--from-json', () async {
final o = buildMeasurementPartnerWrappingData();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MeasurementPartnerWrappingData.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMeasurementPartnerWrappingData(od);
});
});
unittest.group('obj-schema-Metric', () {
unittest.test('to-json--from-json', () async {
final o = buildMetric();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Metric.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkMetric(od);
});
});
unittest.group('obj-schema-Metro', () {
unittest.test('to-json--from-json', () async {
final o = buildMetro();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Metro.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkMetro(od);
});
});
unittest.group('obj-schema-MetrosListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildMetrosListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MetrosListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMetrosListResponse(od);
});
});
unittest.group('obj-schema-MobileApp', () {
unittest.test('to-json--from-json', () async {
final o = buildMobileApp();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.MobileApp.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkMobileApp(od);
});
});
unittest.group('obj-schema-MobileAppsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildMobileAppsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MobileAppsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMobileAppsListResponse(od);
});
});
unittest.group('obj-schema-MobileCarrier', () {
unittest.test('to-json--from-json', () async {
final o = buildMobileCarrier();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MobileCarrier.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMobileCarrier(od);
});
});
unittest.group('obj-schema-MobileCarriersListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildMobileCarriersListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MobileCarriersListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMobileCarriersListResponse(od);
});
});
unittest.group('obj-schema-ObaIcon', () {
unittest.test('to-json--from-json', () async {
final o = buildObaIcon();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ObaIcon.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkObaIcon(od);
});
});
unittest.group('obj-schema-ObjectFilter', () {
unittest.test('to-json--from-json', () async {
final o = buildObjectFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ObjectFilter.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkObjectFilter(od);
});
});
unittest.group('obj-schema-OfflineUserAddressInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildOfflineUserAddressInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OfflineUserAddressInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOfflineUserAddressInfo(od);
});
});
unittest.group('obj-schema-OffsetPosition', () {
unittest.test('to-json--from-json', () async {
final o = buildOffsetPosition();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OffsetPosition.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOffsetPosition(od);
});
});
unittest.group('obj-schema-OmnitureSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildOmnitureSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OmnitureSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOmnitureSettings(od);
});
});
unittest.group('obj-schema-OperatingSystem', () {
unittest.test('to-json--from-json', () async {
final o = buildOperatingSystem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OperatingSystem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOperatingSystem(od);
});
});
unittest.group('obj-schema-OperatingSystemVersion', () {
unittest.test('to-json--from-json', () async {
final o = buildOperatingSystemVersion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OperatingSystemVersion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOperatingSystemVersion(od);
});
});
unittest.group('obj-schema-OperatingSystemVersionsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildOperatingSystemVersionsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OperatingSystemVersionsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOperatingSystemVersionsListResponse(od);
});
});
unittest.group('obj-schema-OperatingSystemsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildOperatingSystemsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OperatingSystemsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOperatingSystemsListResponse(od);
});
});
unittest.group('obj-schema-OptimizationActivity', () {
unittest.test('to-json--from-json', () async {
final o = buildOptimizationActivity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OptimizationActivity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOptimizationActivity(od);
});
});
unittest.group('obj-schema-Order', () {
unittest.test('to-json--from-json', () async {
final o = buildOrder();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Order.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOrder(od);
});
});
unittest.group('obj-schema-OrderContact', () {
unittest.test('to-json--from-json', () async {
final o = buildOrderContact();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OrderContact.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOrderContact(od);
});
});
unittest.group('obj-schema-OrdersListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildOrdersListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.OrdersListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkOrdersListResponse(od);
});
});
unittest.group('obj-schema-PathFilter', () {
unittest.test('to-json--from-json', () async {
final o = buildPathFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.PathFilter.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPathFilter(od);
});
});
unittest.group('obj-schema-PathReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildPathReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PathReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPathReportCompatibleFields(od);
});
});
unittest.group('obj-schema-PathReportDimensionValue', () {
unittest.test('to-json--from-json', () async {
final o = buildPathReportDimensionValue();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PathReportDimensionValue.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPathReportDimensionValue(od);
});
});
unittest.group('obj-schema-PathToConversionReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildPathToConversionReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PathToConversionReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPathToConversionReportCompatibleFields(od);
});
});
unittest.group('obj-schema-Placement', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacement();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Placement.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPlacement(od);
});
});
unittest.group('obj-schema-PlacementAssignment', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementAssignment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementAssignment.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementAssignment(od);
});
});
unittest.group('obj-schema-PlacementGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementGroup(od);
});
});
unittest.group('obj-schema-PlacementGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementGroupsListResponse(od);
});
});
unittest.group('obj-schema-PlacementStrategiesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementStrategiesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementStrategiesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementStrategiesListResponse(od);
});
});
unittest.group('obj-schema-PlacementStrategy', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementStrategy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementStrategy.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementStrategy(od);
});
});
unittest.group('obj-schema-PlacementTag', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementTag();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementTag.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementTag(od);
});
});
unittest.group('obj-schema-PlacementsGenerateTagsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementsGenerateTagsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementsGenerateTagsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementsGenerateTagsResponse(od);
});
});
unittest.group('obj-schema-PlacementsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPlacementsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlacementsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlacementsListResponse(od);
});
});
unittest.group('obj-schema-PlatformType', () {
unittest.test('to-json--from-json', () async {
final o = buildPlatformType();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlatformType.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlatformType(od);
});
});
unittest.group('obj-schema-PlatformTypesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPlatformTypesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PlatformTypesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPlatformTypesListResponse(od);
});
});
unittest.group('obj-schema-PopupWindowProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildPopupWindowProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PopupWindowProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPopupWindowProperties(od);
});
});
unittest.group('obj-schema-PostalCode', () {
unittest.test('to-json--from-json', () async {
final o = buildPostalCode();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.PostalCode.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPostalCode(od);
});
});
unittest.group('obj-schema-PostalCodesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildPostalCodesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PostalCodesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPostalCodesListResponse(od);
});
});
unittest.group('obj-schema-Pricing', () {
unittest.test('to-json--from-json', () async {
final o = buildPricing();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Pricing.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPricing(od);
});
});
unittest.group('obj-schema-PricingSchedule', () {
unittest.test('to-json--from-json', () async {
final o = buildPricingSchedule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PricingSchedule.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPricingSchedule(od);
});
});
unittest.group('obj-schema-PricingSchedulePricingPeriod', () {
unittest.test('to-json--from-json', () async {
final o = buildPricingSchedulePricingPeriod();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PricingSchedulePricingPeriod.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPricingSchedulePricingPeriod(od);
});
});
unittest.group('obj-schema-Project', () {
unittest.test('to-json--from-json', () async {
final o = buildProject();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Project.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkProject(od);
});
});
unittest.group('obj-schema-ProjectsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildProjectsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ProjectsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkProjectsListResponse(od);
});
});
unittest.group('obj-schema-ReachReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildReachReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReachReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReachReportCompatibleFields(od);
});
});
unittest.group('obj-schema-Recipient', () {
unittest.test('to-json--from-json', () async {
final o = buildRecipient();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Recipient.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRecipient(od);
});
});
unittest.group('obj-schema-Region', () {
unittest.test('to-json--from-json', () async {
final o = buildRegion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Region.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRegion(od);
});
});
unittest.group('obj-schema-RegionsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildRegionsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RegionsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRegionsListResponse(od);
});
});
unittest.group('obj-schema-RemarketingList', () {
unittest.test('to-json--from-json', () async {
final o = buildRemarketingList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RemarketingList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRemarketingList(od);
});
});
unittest.group('obj-schema-RemarketingListShare', () {
unittest.test('to-json--from-json', () async {
final o = buildRemarketingListShare();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RemarketingListShare.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRemarketingListShare(od);
});
});
unittest.group('obj-schema-RemarketingListsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildRemarketingListsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RemarketingListsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRemarketingListsListResponse(od);
});
});
unittest.group('obj-schema-ReportCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportCriteria(od);
});
});
unittest.group('obj-schema-ReportCrossDimensionReachCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportCrossDimensionReachCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportCrossDimensionReachCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportCrossDimensionReachCriteria(od);
});
});
unittest.group('obj-schema-ReportDelivery', () {
unittest.test('to-json--from-json', () async {
final o = buildReportDelivery();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportDelivery.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportDelivery(od);
});
});
unittest.group('obj-schema-ReportFloodlightCriteriaReportProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildReportFloodlightCriteriaReportProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportFloodlightCriteriaReportProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportFloodlightCriteriaReportProperties(od);
});
});
unittest.group('obj-schema-ReportFloodlightCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportFloodlightCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportFloodlightCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportFloodlightCriteria(od);
});
});
unittest.group('obj-schema-ReportPathAttributionCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportPathAttributionCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportPathAttributionCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportPathAttributionCriteria(od);
});
});
unittest.group('obj-schema-ReportPathCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportPathCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportPathCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportPathCriteria(od);
});
});
unittest.group('obj-schema-ReportPathToConversionCriteriaReportProperties',
() {
unittest.test('to-json--from-json', () async {
final o = buildReportPathToConversionCriteriaReportProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportPathToConversionCriteriaReportProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportPathToConversionCriteriaReportProperties(od);
});
});
unittest.group('obj-schema-ReportPathToConversionCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportPathToConversionCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportPathToConversionCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportPathToConversionCriteria(od);
});
});
unittest.group('obj-schema-ReportReachCriteria', () {
unittest.test('to-json--from-json', () async {
final o = buildReportReachCriteria();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportReachCriteria.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportReachCriteria(od);
});
});
unittest.group('obj-schema-ReportSchedule', () {
unittest.test('to-json--from-json', () async {
final o = buildReportSchedule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportSchedule.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportSchedule(od);
});
});
unittest.group('obj-schema-Report', () {
unittest.test('to-json--from-json', () async {
final o = buildReport();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Report.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkReport(od);
});
});
unittest.group('obj-schema-ReportCompatibleFields', () {
unittest.test('to-json--from-json', () async {
final o = buildReportCompatibleFields();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportCompatibleFields.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportCompatibleFields(od);
});
});
unittest.group('obj-schema-ReportList', () {
unittest.test('to-json--from-json', () async {
final o = buildReportList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ReportList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkReportList(od);
});
});
unittest.group('obj-schema-ReportsConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildReportsConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReportsConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReportsConfiguration(od);
});
});
unittest.group('obj-schema-RichMediaExitOverride', () {
unittest.test('to-json--from-json', () async {
final o = buildRichMediaExitOverride();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RichMediaExitOverride.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRichMediaExitOverride(od);
});
});
unittest.group('obj-schema-Rule', () {
unittest.test('to-json--from-json', () async {
final o = buildRule();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Rule.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRule(od);
});
});
unittest.group('obj-schema-Site', () {
unittest.test('to-json--from-json', () async {
final o = buildSite();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Site.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSite(od);
});
});
unittest.group('obj-schema-SiteCompanionSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteCompanionSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteCompanionSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteCompanionSetting(od);
});
});
unittest.group('obj-schema-SiteContact', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteContact();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteContact.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteContact(od);
});
});
unittest.group('obj-schema-SiteSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteSettings(od);
});
});
unittest.group('obj-schema-SiteSkippableSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteSkippableSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteSkippableSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteSkippableSetting(od);
});
});
unittest.group('obj-schema-SiteTranscodeSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteTranscodeSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteTranscodeSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteTranscodeSetting(od);
});
});
unittest.group('obj-schema-SiteVideoSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildSiteVideoSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SiteVideoSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSiteVideoSettings(od);
});
});
unittest.group('obj-schema-SitesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildSitesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SitesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSitesListResponse(od);
});
});
unittest.group('obj-schema-Size', () {
unittest.test('to-json--from-json', () async {
final o = buildSize();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Size.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSize(od);
});
});
unittest.group('obj-schema-SizesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildSizesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SizesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSizesListResponse(od);
});
});
unittest.group('obj-schema-SkippableSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildSkippableSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SkippableSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSkippableSetting(od);
});
});
unittest.group('obj-schema-SortedDimension', () {
unittest.test('to-json--from-json', () async {
final o = buildSortedDimension();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SortedDimension.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSortedDimension(od);
});
});
unittest.group('obj-schema-Subaccount', () {
unittest.test('to-json--from-json', () async {
final o = buildSubaccount();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Subaccount.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSubaccount(od);
});
});
unittest.group('obj-schema-SubaccountsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildSubaccountsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SubaccountsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSubaccountsListResponse(od);
});
});
unittest.group('obj-schema-TagData', () {
unittest.test('to-json--from-json', () async {
final o = buildTagData();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TagData.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTagData(od);
});
});
unittest.group('obj-schema-TagSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildTagSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TagSetting.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTagSetting(od);
});
});
unittest.group('obj-schema-TagSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildTagSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TagSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTagSettings(od);
});
});
unittest.group('obj-schema-TargetWindow', () {
unittest.test('to-json--from-json', () async {
final o = buildTargetWindow();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TargetWindow.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTargetWindow(od);
});
});
unittest.group('obj-schema-TargetableRemarketingList', () {
unittest.test('to-json--from-json', () async {
final o = buildTargetableRemarketingList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TargetableRemarketingList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTargetableRemarketingList(od);
});
});
unittest.group('obj-schema-TargetableRemarketingListsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTargetableRemarketingListsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TargetableRemarketingListsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTargetableRemarketingListsListResponse(od);
});
});
unittest.group('obj-schema-TargetingTemplate', () {
unittest.test('to-json--from-json', () async {
final o = buildTargetingTemplate();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TargetingTemplate.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTargetingTemplate(od);
});
});
unittest.group('obj-schema-TargetingTemplatesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTargetingTemplatesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TargetingTemplatesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTargetingTemplatesListResponse(od);
});
});
unittest.group('obj-schema-TechnologyTargeting', () {
unittest.test('to-json--from-json', () async {
final o = buildTechnologyTargeting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TechnologyTargeting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTechnologyTargeting(od);
});
});
unittest.group('obj-schema-ThirdPartyAuthenticationToken', () {
unittest.test('to-json--from-json', () async {
final o = buildThirdPartyAuthenticationToken();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ThirdPartyAuthenticationToken.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkThirdPartyAuthenticationToken(od);
});
});
unittest.group('obj-schema-ThirdPartyTrackingUrl', () {
unittest.test('to-json--from-json', () async {
final o = buildThirdPartyTrackingUrl();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ThirdPartyTrackingUrl.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkThirdPartyTrackingUrl(od);
});
});
unittest.group('obj-schema-TranscodeSetting', () {
unittest.test('to-json--from-json', () async {
final o = buildTranscodeSetting();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TranscodeSetting.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTranscodeSetting(od);
});
});
unittest.group('obj-schema-UniversalAdId', () {
unittest.test('to-json--from-json', () async {
final o = buildUniversalAdId();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UniversalAdId.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUniversalAdId(od);
});
});
unittest.group('obj-schema-UserDefinedVariableConfiguration', () {
unittest.test('to-json--from-json', () async {
final o = buildUserDefinedVariableConfiguration();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserDefinedVariableConfiguration.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserDefinedVariableConfiguration(od);
});
});
unittest.group('obj-schema-UserIdentifier', () {
unittest.test('to-json--from-json', () async {
final o = buildUserIdentifier();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserIdentifier.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserIdentifier(od);
});
});
unittest.group('obj-schema-UserProfile', () {
unittest.test('to-json--from-json', () async {
final o = buildUserProfile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserProfile.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserProfile(od);
});
});
unittest.group('obj-schema-UserProfileList', () {
unittest.test('to-json--from-json', () async {
final o = buildUserProfileList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserProfileList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserProfileList(od);
});
});
unittest.group('obj-schema-UserRole', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRole();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.UserRole.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkUserRole(od);
});
});
unittest.group('obj-schema-UserRolePermission', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRolePermission();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserRolePermission.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserRolePermission(od);
});
});
unittest.group('obj-schema-UserRolePermissionGroup', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRolePermissionGroup();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserRolePermissionGroup.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserRolePermissionGroup(od);
});
});
unittest.group('obj-schema-UserRolePermissionGroupsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRolePermissionGroupsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserRolePermissionGroupsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserRolePermissionGroupsListResponse(od);
});
});
unittest.group('obj-schema-UserRolePermissionsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRolePermissionsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserRolePermissionsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserRolePermissionsListResponse(od);
});
});
unittest.group('obj-schema-UserRolesListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildUserRolesListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UserRolesListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUserRolesListResponse(od);
});
});
unittest.group('obj-schema-UvarFilter', () {
unittest.test('to-json--from-json', () async {
final o = buildUvarFilter();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.UvarFilter.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkUvarFilter(od);
});
});
unittest.group('obj-schema-VideoFormat', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoFormat();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VideoFormat.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVideoFormat(od);
});
});
unittest.group('obj-schema-VideoFormatsListResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoFormatsListResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VideoFormatsListResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVideoFormatsListResponse(od);
});
});
unittest.group('obj-schema-VideoOffset', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoOffset();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VideoOffset.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVideoOffset(od);
});
});
unittest.group('obj-schema-VideoSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VideoSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVideoSettings(od);
});
});
unittest.group('resource-AccountActiveAdSummariesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountActiveAdSummaries;
final arg_profileId = 'foo';
final arg_summaryAccountId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountActiveAdSummary());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_summaryAccountId,
$fields: arg_$fields);
checkAccountActiveAdSummary(response as api.AccountActiveAdSummary);
});
});
unittest.group('resource-AccountPermissionGroupsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountPermissionGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountPermissionGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAccountPermissionGroup(response as api.AccountPermissionGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountPermissionGroups;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildAccountPermissionGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkAccountPermissionGroupsListResponse(
response as api.AccountPermissionGroupsListResponse);
});
});
unittest.group('resource-AccountPermissionsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountPermissions;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountPermission());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAccountPermission(response as api.AccountPermission);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountPermissions;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountPermissionsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkAccountPermissionsListResponse(
response as api.AccountPermissionsListResponse);
});
});
unittest.group('resource-AccountUserProfilesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountUserProfiles;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/accountUserProfiles/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 21),
unittest.equals('/accountUserProfiles/'),
);
pathOffset += 21;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountUserProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAccountUserProfile(response as api.AccountUserProfile);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountUserProfiles;
final arg_request = buildAccountUserProfile();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AccountUserProfile.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAccountUserProfile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountUserProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkAccountUserProfile(response as api.AccountUserProfile);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountUserProfiles;
final arg_profileId = 'foo';
final arg_active = true;
final arg_ids = buildUnnamed223();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_subaccountId = 'foo';
final arg_userRoleId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['userRoleId']!.first,
unittest.equals(arg_userRoleId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildAccountUserProfilesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
active: arg_active,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
subaccountId: arg_subaccountId,
userRoleId: arg_userRoleId,
$fields: arg_$fields);
checkAccountUserProfilesListResponse(
response as api.AccountUserProfilesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountUserProfiles;
final arg_request = buildAccountUserProfile();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AccountUserProfile.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAccountUserProfile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountUserProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkAccountUserProfile(response as api.AccountUserProfile);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accountUserProfiles;
final arg_request = buildAccountUserProfile();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AccountUserProfile.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAccountUserProfile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountUserProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkAccountUserProfile(response as api.AccountUserProfile);
});
});
unittest.group('resource-AccountsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accounts;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAccount(response as api.Account);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accounts;
final arg_profileId = 'foo';
final arg_active = true;
final arg_ids = buildUnnamed224();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccountsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
active: arg_active,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkAccountsListResponse(response as api.AccountsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accounts;
final arg_request = buildAccount();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Account.fromJson(json as core.Map<core.String, core.dynamic>);
checkAccount(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkAccount(response as api.Account);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).accounts;
final arg_request = buildAccount();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Account.fromJson(json as core.Map<core.String, core.dynamic>);
checkAccount(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkAccount(response as api.Account);
});
});
unittest.group('resource-AdsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).ads;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAd());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAd(response as api.Ad);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).ads;
final arg_request = buildAd();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Ad.fromJson(json as core.Map<core.String, core.dynamic>);
checkAd(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAd());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkAd(response as api.Ad);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).ads;
final arg_profileId = 'foo';
final arg_active = true;
final arg_advertiserId = 'foo';
final arg_archived = true;
final arg_audienceSegmentIds = buildUnnamed225();
final arg_campaignIds = buildUnnamed226();
final arg_compatibility = 'foo';
final arg_creativeIds = buildUnnamed227();
final arg_creativeOptimizationConfigurationIds = buildUnnamed228();
final arg_dynamicClickTracker = true;
final arg_ids = buildUnnamed229();
final arg_landingPageIds = buildUnnamed230();
final arg_maxResults = 42;
final arg_overriddenEventTagId = 'foo';
final arg_pageToken = 'foo';
final arg_placementIds = buildUnnamed231();
final arg_remarketingListIds = buildUnnamed232();
final arg_searchString = 'foo';
final arg_sizeIds = buildUnnamed233();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_sslCompliant = true;
final arg_sslRequired = true;
final arg_type = buildUnnamed234();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['archived']!.first,
unittest.equals('$arg_archived'),
);
unittest.expect(
queryMap['audienceSegmentIds']!,
unittest.equals(arg_audienceSegmentIds),
);
unittest.expect(
queryMap['campaignIds']!,
unittest.equals(arg_campaignIds),
);
unittest.expect(
queryMap['compatibility']!.first,
unittest.equals(arg_compatibility),
);
unittest.expect(
queryMap['creativeIds']!,
unittest.equals(arg_creativeIds),
);
unittest.expect(
queryMap['creativeOptimizationConfigurationIds']!,
unittest.equals(arg_creativeOptimizationConfigurationIds),
);
unittest.expect(
queryMap['dynamicClickTracker']!.first,
unittest.equals('$arg_dynamicClickTracker'),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['landingPageIds']!,
unittest.equals(arg_landingPageIds),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['overriddenEventTagId']!.first,
unittest.equals(arg_overriddenEventTagId),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['placementIds']!,
unittest.equals(arg_placementIds),
);
unittest.expect(
queryMap['remarketingListIds']!,
unittest.equals(arg_remarketingListIds),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sizeIds']!,
unittest.equals(arg_sizeIds),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['sslCompliant']!.first,
unittest.equals('$arg_sslCompliant'),
);
unittest.expect(
queryMap['sslRequired']!.first,
unittest.equals('$arg_sslRequired'),
);
unittest.expect(
queryMap['type']!,
unittest.equals(arg_type),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
active: arg_active,
advertiserId: arg_advertiserId,
archived: arg_archived,
audienceSegmentIds: arg_audienceSegmentIds,
campaignIds: arg_campaignIds,
compatibility: arg_compatibility,
creativeIds: arg_creativeIds,
creativeOptimizationConfigurationIds:
arg_creativeOptimizationConfigurationIds,
dynamicClickTracker: arg_dynamicClickTracker,
ids: arg_ids,
landingPageIds: arg_landingPageIds,
maxResults: arg_maxResults,
overriddenEventTagId: arg_overriddenEventTagId,
pageToken: arg_pageToken,
placementIds: arg_placementIds,
remarketingListIds: arg_remarketingListIds,
searchString: arg_searchString,
sizeIds: arg_sizeIds,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
sslCompliant: arg_sslCompliant,
sslRequired: arg_sslRequired,
type: arg_type,
$fields: arg_$fields);
checkAdsListResponse(response as api.AdsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).ads;
final arg_request = buildAd();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Ad.fromJson(json as core.Map<core.String, core.dynamic>);
checkAd(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAd());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkAd(response as api.Ad);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).ads;
final arg_request = buildAd();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Ad.fromJson(json as core.Map<core.String, core.dynamic>);
checkAd(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAd());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkAd(response as api.Ad);
});
});
unittest.group('resource-AdvertiserGroupsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAdvertiserGroup(response as api.AdvertiserGroup);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_request = buildAdvertiserGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AdvertiserGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiserGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkAdvertiserGroup(response as api.AdvertiserGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed235();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkAdvertiserGroupsListResponse(
response as api.AdvertiserGroupsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_request = buildAdvertiserGroup();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AdvertiserGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiserGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkAdvertiserGroup(response as api.AdvertiserGroup);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserGroups;
final arg_request = buildAdvertiserGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.AdvertiserGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiserGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkAdvertiserGroup(response as api.AdvertiserGroup);
});
});
unittest.group('resource-AdvertiserInvoicesResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserInvoices;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_issueMonth = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['issueMonth']!.first,
unittest.equals(arg_issueMonth),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiserInvoicesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_advertiserId,
issueMonth: arg_issueMonth,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkAdvertiserInvoicesListResponse(
response as api.AdvertiserInvoicesListResponse);
});
});
unittest.group('resource-AdvertiserLandingPagesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserLandingPages;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLandingPage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkLandingPage(response as api.LandingPage);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserLandingPages;
final arg_request = buildLandingPage();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LandingPage.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLandingPage(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLandingPage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkLandingPage(response as api.LandingPage);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserLandingPages;
final arg_profileId = 'foo';
final arg_advertiserIds = buildUnnamed236();
final arg_archived = true;
final arg_campaignIds = buildUnnamed237();
final arg_ids = buildUnnamed238();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_subaccountId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['archived']!.first,
unittest.equals('$arg_archived'),
);
unittest.expect(
queryMap['campaignIds']!,
unittest.equals(arg_campaignIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildAdvertiserLandingPagesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserIds: arg_advertiserIds,
archived: arg_archived,
campaignIds: arg_campaignIds,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
subaccountId: arg_subaccountId,
$fields: arg_$fields);
checkAdvertiserLandingPagesListResponse(
response as api.AdvertiserLandingPagesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserLandingPages;
final arg_request = buildLandingPage();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LandingPage.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLandingPage(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLandingPage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkLandingPage(response as api.LandingPage);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertiserLandingPages;
final arg_request = buildLandingPage();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LandingPage.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLandingPage(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLandingPage());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkLandingPage(response as api.LandingPage);
});
});
unittest.group('resource-AdvertisersResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertisers;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiser());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkAdvertiser(response as api.Advertiser);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertisers;
final arg_request = buildAdvertiser();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Advertiser.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiser(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiser());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkAdvertiser(response as api.Advertiser);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertisers;
final arg_profileId = 'foo';
final arg_advertiserGroupIds = buildUnnamed239();
final arg_floodlightConfigurationIds = buildUnnamed240();
final arg_ids = buildUnnamed241();
final arg_includeAdvertisersWithoutGroupsOnly = true;
final arg_maxResults = 42;
final arg_onlyParent = true;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_status = 'foo';
final arg_subaccountId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserGroupIds']!,
unittest.equals(arg_advertiserGroupIds),
);
unittest.expect(
queryMap['floodlightConfigurationIds']!,
unittest.equals(arg_floodlightConfigurationIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['includeAdvertisersWithoutGroupsOnly']!.first,
unittest.equals('$arg_includeAdvertisersWithoutGroupsOnly'),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['onlyParent']!.first,
unittest.equals('$arg_onlyParent'),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['status']!.first,
unittest.equals(arg_status),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertisersListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserGroupIds: arg_advertiserGroupIds,
floodlightConfigurationIds: arg_floodlightConfigurationIds,
ids: arg_ids,
includeAdvertisersWithoutGroupsOnly:
arg_includeAdvertisersWithoutGroupsOnly,
maxResults: arg_maxResults,
onlyParent: arg_onlyParent,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
status: arg_status,
subaccountId: arg_subaccountId,
$fields: arg_$fields);
checkAdvertisersListResponse(response as api.AdvertisersListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertisers;
final arg_request = buildAdvertiser();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Advertiser.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiser(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiser());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkAdvertiser(response as api.Advertiser);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).advertisers;
final arg_request = buildAdvertiser();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Advertiser.fromJson(
json as core.Map<core.String, core.dynamic>);
checkAdvertiser(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAdvertiser());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkAdvertiser(response as api.Advertiser);
});
});
unittest.group('resource-BillingAssignmentsResource', () {
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingAssignments;
final arg_request = buildBillingAssignment();
final arg_profileId = 'foo';
final arg_billingProfileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.BillingAssignment.fromJson(
json as core.Map<core.String, core.dynamic>);
checkBillingAssignment(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingAssignment());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(
arg_request, arg_profileId, arg_billingProfileId,
$fields: arg_$fields);
checkBillingAssignment(response as api.BillingAssignment);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingAssignments;
final arg_profileId = 'foo';
final arg_billingProfileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingAssignmentsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_billingProfileId,
$fields: arg_$fields);
checkBillingAssignmentsListResponse(
response as api.BillingAssignmentsListResponse);
});
});
unittest.group('resource-BillingProfilesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingProfiles;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkBillingProfile(response as api.BillingProfile);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingProfiles;
final arg_profileId = 'foo';
final arg_currencyCode = 'foo';
final arg_ids = buildUnnamed242();
final arg_maxResults = 42;
final arg_name = 'foo';
final arg_onlySuggestion = true;
final arg_pageToken = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_status = buildUnnamed243();
final arg_subaccountIds = buildUnnamed244();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['currency_code']!.first,
unittest.equals(arg_currencyCode),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['onlySuggestion']!.first,
unittest.equals('$arg_onlySuggestion'),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['status']!,
unittest.equals(arg_status),
);
unittest.expect(
queryMap['subaccountIds']!,
unittest.equals(arg_subaccountIds),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingProfilesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
currencyCode: arg_currencyCode,
ids: arg_ids,
maxResults: arg_maxResults,
name: arg_name,
onlySuggestion: arg_onlySuggestion,
pageToken: arg_pageToken,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
status: arg_status,
subaccountIds: arg_subaccountIds,
$fields: arg_$fields);
checkBillingProfilesListResponse(
response as api.BillingProfilesListResponse);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingProfiles;
final arg_request = buildBillingProfile();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.BillingProfile.fromJson(
json as core.Map<core.String, core.dynamic>);
checkBillingProfile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkBillingProfile(response as api.BillingProfile);
});
});
unittest.group('resource-BillingRatesResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).billingRates;
final arg_profileId = 'foo';
final arg_billingProfileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBillingRatesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_billingProfileId,
$fields: arg_$fields);
checkBillingRatesListResponse(response as api.BillingRatesListResponse);
});
});
unittest.group('resource-BrowsersResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).browsers;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBrowsersListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkBrowsersListResponse(response as api.BrowsersListResponse);
});
});
unittest.group('resource-CampaignCreativeAssociationsResource', () {
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaignCreativeAssociations;
final arg_request = buildCampaignCreativeAssociation();
final arg_profileId = 'foo';
final arg_campaignId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CampaignCreativeAssociation.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCampaignCreativeAssociation(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaignCreativeAssociation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(
arg_request, arg_profileId, arg_campaignId,
$fields: arg_$fields);
checkCampaignCreativeAssociation(
response as api.CampaignCreativeAssociation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaignCreativeAssociations;
final arg_profileId = 'foo';
final arg_campaignId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json
.encode(buildCampaignCreativeAssociationsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_campaignId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkCampaignCreativeAssociationsListResponse(
response as api.CampaignCreativeAssociationsListResponse);
});
});
unittest.group('resource-CampaignsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaigns;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaign());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkCampaign(response as api.Campaign);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaigns;
final arg_request = buildCampaign();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Campaign.fromJson(json as core.Map<core.String, core.dynamic>);
checkCampaign(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaign());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkCampaign(response as api.Campaign);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaigns;
final arg_profileId = 'foo';
final arg_advertiserGroupIds = buildUnnamed245();
final arg_advertiserIds = buildUnnamed246();
final arg_archived = true;
final arg_atLeastOneOptimizationActivity = true;
final arg_excludedIds = buildUnnamed247();
final arg_ids = buildUnnamed248();
final arg_maxResults = 42;
final arg_overriddenEventTagId = 'foo';
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_subaccountId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserGroupIds']!,
unittest.equals(arg_advertiserGroupIds),
);
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['archived']!.first,
unittest.equals('$arg_archived'),
);
unittest.expect(
queryMap['atLeastOneOptimizationActivity']!.first,
unittest.equals('$arg_atLeastOneOptimizationActivity'),
);
unittest.expect(
queryMap['excludedIds']!,
unittest.equals(arg_excludedIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['overriddenEventTagId']!.first,
unittest.equals(arg_overriddenEventTagId),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaignsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserGroupIds: arg_advertiserGroupIds,
advertiserIds: arg_advertiserIds,
archived: arg_archived,
atLeastOneOptimizationActivity: arg_atLeastOneOptimizationActivity,
excludedIds: arg_excludedIds,
ids: arg_ids,
maxResults: arg_maxResults,
overriddenEventTagId: arg_overriddenEventTagId,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
subaccountId: arg_subaccountId,
$fields: arg_$fields);
checkCampaignsListResponse(response as api.CampaignsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaigns;
final arg_request = buildCampaign();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Campaign.fromJson(json as core.Map<core.String, core.dynamic>);
checkCampaign(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaign());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkCampaign(response as api.Campaign);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).campaigns;
final arg_request = buildCampaign();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Campaign.fromJson(json as core.Map<core.String, core.dynamic>);
checkCampaign(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCampaign());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkCampaign(response as api.Campaign);
});
});
unittest.group('resource-ChangeLogsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).changeLogs;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChangeLog());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkChangeLog(response as api.ChangeLog);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).changeLogs;
final arg_profileId = 'foo';
final arg_action = 'foo';
final arg_ids = buildUnnamed249();
final arg_maxChangeTime = 'foo';
final arg_maxResults = 42;
final arg_minChangeTime = 'foo';
final arg_objectIds = buildUnnamed250();
final arg_objectType = 'foo';
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_userProfileIds = buildUnnamed251();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['action']!.first,
unittest.equals(arg_action),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['maxChangeTime']!.first,
unittest.equals(arg_maxChangeTime),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['minChangeTime']!.first,
unittest.equals(arg_minChangeTime),
);
unittest.expect(
queryMap['objectIds']!,
unittest.equals(arg_objectIds),
);
unittest.expect(
queryMap['objectType']!.first,
unittest.equals(arg_objectType),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['userProfileIds']!,
unittest.equals(arg_userProfileIds),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChangeLogsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
action: arg_action,
ids: arg_ids,
maxChangeTime: arg_maxChangeTime,
maxResults: arg_maxResults,
minChangeTime: arg_minChangeTime,
objectIds: arg_objectIds,
objectType: arg_objectType,
pageToken: arg_pageToken,
searchString: arg_searchString,
userProfileIds: arg_userProfileIds,
$fields: arg_$fields);
checkChangeLogsListResponse(response as api.ChangeLogsListResponse);
});
});
unittest.group('resource-CitiesResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).cities;
final arg_profileId = 'foo';
final arg_countryDartIds = buildUnnamed252();
final arg_dartIds = buildUnnamed253();
final arg_namePrefix = 'foo';
final arg_regionDartIds = buildUnnamed254();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['countryDartIds']!,
unittest.equals(arg_countryDartIds),
);
unittest.expect(
queryMap['dartIds']!,
unittest.equals(arg_dartIds),
);
unittest.expect(
queryMap['namePrefix']!.first,
unittest.equals(arg_namePrefix),
);
unittest.expect(
queryMap['regionDartIds']!,
unittest.equals(arg_regionDartIds),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCitiesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
countryDartIds: arg_countryDartIds,
dartIds: arg_dartIds,
namePrefix: arg_namePrefix,
regionDartIds: arg_regionDartIds,
$fields: arg_$fields);
checkCitiesListResponse(response as api.CitiesListResponse);
});
});
unittest.group('resource-ConnectionTypesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).connectionTypes;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildConnectionType());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkConnectionType(response as api.ConnectionType);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).connectionTypes;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildConnectionTypesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkConnectionTypesListResponse(
response as api.ConnectionTypesListResponse);
});
});
unittest.group('resource-ContentCategoriesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildContentCategory());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkContentCategory(response as api.ContentCategory);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_request = buildContentCategory();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ContentCategory.fromJson(
json as core.Map<core.String, core.dynamic>);
checkContentCategory(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildContentCategory());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkContentCategory(response as api.ContentCategory);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed255();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildContentCategoriesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkContentCategoriesListResponse(
response as api.ContentCategoriesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_request = buildContentCategory();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ContentCategory.fromJson(
json as core.Map<core.String, core.dynamic>);
checkContentCategory(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildContentCategory());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkContentCategory(response as api.ContentCategory);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).contentCategories;
final arg_request = buildContentCategory();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ContentCategory.fromJson(
json as core.Map<core.String, core.dynamic>);
checkContentCategory(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildContentCategory());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkContentCategory(response as api.ContentCategory);
});
});
unittest.group('resource-ConversionsResource', () {
unittest.test('method--batchinsert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).conversions;
final arg_request = buildConversionsBatchInsertRequest();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ConversionsBatchInsertRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkConversionsBatchInsertRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/conversions/batchinsert', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 24),
unittest.equals('/conversions/batchinsert'),
);
pathOffset += 24;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildConversionsBatchInsertResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.batchinsert(arg_request, arg_profileId,
$fields: arg_$fields);
checkConversionsBatchInsertResponse(
response as api.ConversionsBatchInsertResponse);
});
unittest.test('method--batchupdate', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).conversions;
final arg_request = buildConversionsBatchUpdateRequest();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ConversionsBatchUpdateRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkConversionsBatchUpdateRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/conversions/batchupdate', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 24),
unittest.equals('/conversions/batchupdate'),
);
pathOffset += 24;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildConversionsBatchUpdateResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.batchupdate(arg_request, arg_profileId,
$fields: arg_$fields);
checkConversionsBatchUpdateResponse(
response as api.ConversionsBatchUpdateResponse);
});
});
unittest.group('resource-CountriesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).countries;
final arg_profileId = 'foo';
final arg_dartId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCountry());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_dartId, $fields: arg_$fields);
checkCountry(response as api.Country);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).countries;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCountriesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkCountriesListResponse(response as api.CountriesListResponse);
});
});
unittest.group('resource-CreativeAssetsResource', () {
unittest.test('method--insert', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeAssets;
final arg_request = buildCreativeAssetMetadata();
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeAssetMetadata.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeAssetMetadata(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeAssetMetadata());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(
arg_request, arg_profileId, arg_advertiserId,
$fields: arg_$fields);
checkCreativeAssetMetadata(response as api.CreativeAssetMetadata);
});
});
unittest.group('resource-CreativeFieldValuesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_creativeFieldId, arg_id,
$fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeFieldValue());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_creativeFieldId, arg_id,
$fields: arg_$fields);
checkCreativeFieldValue(response as api.CreativeFieldValue);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_request = buildCreativeFieldValue();
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeFieldValue.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeFieldValue(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeFieldValue());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.insert(
arg_request, arg_profileId, arg_creativeFieldId,
$fields: arg_$fields);
checkCreativeFieldValue(response as api.CreativeFieldValue);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_ids = buildUnnamed256();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildCreativeFieldValuesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_creativeFieldId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkCreativeFieldValuesListResponse(
response as api.CreativeFieldValuesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_request = buildCreativeFieldValue();
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeFieldValue.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeFieldValue(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeFieldValue());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(
arg_request, arg_profileId, arg_creativeFieldId, arg_id,
$fields: arg_$fields);
checkCreativeFieldValue(response as api.CreativeFieldValue);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFieldValues;
final arg_request = buildCreativeFieldValue();
final arg_profileId = 'foo';
final arg_creativeFieldId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeFieldValue.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeFieldValue(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeFieldValue());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_profileId, arg_creativeFieldId,
$fields: arg_$fields);
checkCreativeFieldValue(response as api.CreativeFieldValue);
});
});
unittest.group('resource-CreativeFieldsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeField());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkCreativeField(response as api.CreativeField);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_request = buildCreativeField();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeField.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeField(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeField());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkCreativeField(response as api.CreativeField);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_profileId = 'foo';
final arg_advertiserIds = buildUnnamed257();
final arg_ids = buildUnnamed258();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeFieldsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserIds: arg_advertiserIds,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkCreativeFieldsListResponse(
response as api.CreativeFieldsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_request = buildCreativeField();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeField.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeField(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeField());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkCreativeField(response as api.CreativeField);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeFields;
final arg_request = buildCreativeField();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeField.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeField(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeField());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkCreativeField(response as api.CreativeField);
});
});
unittest.group('resource-CreativeGroupsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkCreativeGroup(response as api.CreativeGroup);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeGroups;
final arg_request = buildCreativeGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkCreativeGroup(response as api.CreativeGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeGroups;
final arg_profileId = 'foo';
final arg_advertiserIds = buildUnnamed259();
final arg_groupNumber = 42;
final arg_ids = buildUnnamed260();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
core.int.parse(queryMap['groupNumber']!.first),
unittest.equals(arg_groupNumber),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserIds: arg_advertiserIds,
groupNumber: arg_groupNumber,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkCreativeGroupsListResponse(
response as api.CreativeGroupsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeGroups;
final arg_request = buildCreativeGroup();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkCreativeGroup(response as api.CreativeGroup);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creativeGroups;
final arg_request = buildCreativeGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreativeGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreativeGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativeGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkCreativeGroup(response as api.CreativeGroup);
});
});
unittest.group('resource-CreativesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creatives;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreative());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkCreative(response as api.Creative);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creatives;
final arg_request = buildCreative();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Creative.fromJson(json as core.Map<core.String, core.dynamic>);
checkCreative(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreative());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkCreative(response as api.Creative);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creatives;
final arg_profileId = 'foo';
final arg_active = true;
final arg_advertiserId = 'foo';
final arg_archived = true;
final arg_campaignId = 'foo';
final arg_companionCreativeIds = buildUnnamed261();
final arg_creativeFieldIds = buildUnnamed262();
final arg_ids = buildUnnamed263();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_renderingIds = buildUnnamed264();
final arg_searchString = 'foo';
final arg_sizeIds = buildUnnamed265();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_studioCreativeId = 'foo';
final arg_types = buildUnnamed266();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['archived']!.first,
unittest.equals('$arg_archived'),
);
unittest.expect(
queryMap['campaignId']!.first,
unittest.equals(arg_campaignId),
);
unittest.expect(
queryMap['companionCreativeIds']!,
unittest.equals(arg_companionCreativeIds),
);
unittest.expect(
queryMap['creativeFieldIds']!,
unittest.equals(arg_creativeFieldIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['renderingIds']!,
unittest.equals(arg_renderingIds),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sizeIds']!,
unittest.equals(arg_sizeIds),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['studioCreativeId']!.first,
unittest.equals(arg_studioCreativeId),
);
unittest.expect(
queryMap['types']!,
unittest.equals(arg_types),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreativesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
active: arg_active,
advertiserId: arg_advertiserId,
archived: arg_archived,
campaignId: arg_campaignId,
companionCreativeIds: arg_companionCreativeIds,
creativeFieldIds: arg_creativeFieldIds,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
renderingIds: arg_renderingIds,
searchString: arg_searchString,
sizeIds: arg_sizeIds,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
studioCreativeId: arg_studioCreativeId,
types: arg_types,
$fields: arg_$fields);
checkCreativesListResponse(response as api.CreativesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creatives;
final arg_request = buildCreative();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Creative.fromJson(json as core.Map<core.String, core.dynamic>);
checkCreative(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreative());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkCreative(response as api.Creative);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).creatives;
final arg_request = buildCreative();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Creative.fromJson(json as core.Map<core.String, core.dynamic>);
checkCreative(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCreative());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkCreative(response as api.Creative);
});
});
unittest.group('resource-DimensionValuesResource', () {
unittest.test('method--query', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).dimensionValues;
final arg_request = buildDimensionValueRequest();
final arg_profileId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DimensionValueRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDimensionValueRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/dimensionvalues/query', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('/dimensionvalues/query'),
);
pathOffset += 22;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDimensionValueList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.query(arg_request, arg_profileId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkDimensionValueList(response as api.DimensionValueList);
});
});
unittest.group('resource-DirectorySitesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).directorySites;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDirectorySite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkDirectorySite(response as api.DirectorySite);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).directorySites;
final arg_request = buildDirectorySite();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DirectorySite.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDirectorySite(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDirectorySite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkDirectorySite(response as api.DirectorySite);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).directorySites;
final arg_profileId = 'foo';
final arg_acceptsInStreamVideoPlacements = true;
final arg_acceptsInterstitialPlacements = true;
final arg_acceptsPublisherPaidPlacements = true;
final arg_active = true;
final arg_dfpNetworkCode = 'foo';
final arg_ids = buildUnnamed267();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['acceptsInStreamVideoPlacements']!.first,
unittest.equals('$arg_acceptsInStreamVideoPlacements'),
);
unittest.expect(
queryMap['acceptsInterstitialPlacements']!.first,
unittest.equals('$arg_acceptsInterstitialPlacements'),
);
unittest.expect(
queryMap['acceptsPublisherPaidPlacements']!.first,
unittest.equals('$arg_acceptsPublisherPaidPlacements'),
);
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['dfpNetworkCode']!.first,
unittest.equals(arg_dfpNetworkCode),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDirectorySitesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
acceptsInStreamVideoPlacements: arg_acceptsInStreamVideoPlacements,
acceptsInterstitialPlacements: arg_acceptsInterstitialPlacements,
acceptsPublisherPaidPlacements: arg_acceptsPublisherPaidPlacements,
active: arg_active,
dfpNetworkCode: arg_dfpNetworkCode,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkDirectorySitesListResponse(
response as api.DirectorySitesListResponse);
});
});
unittest.group('resource-DynamicTargetingKeysResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).dynamicTargetingKeys;
final arg_profileId = 'foo';
final arg_objectId = 'foo';
final arg_name = 'foo';
final arg_objectType = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['objectType']!.first,
unittest.equals(arg_objectType),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_objectId, arg_name, arg_objectType,
$fields: arg_$fields);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).dynamicTargetingKeys;
final arg_request = buildDynamicTargetingKey();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DynamicTargetingKey.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDynamicTargetingKey(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDynamicTargetingKey());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkDynamicTargetingKey(response as api.DynamicTargetingKey);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).dynamicTargetingKeys;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_names = buildUnnamed268();
final arg_objectId = 'foo';
final arg_objectType = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['names']!,
unittest.equals(arg_names),
);
unittest.expect(
queryMap['objectId']!.first,
unittest.equals(arg_objectId),
);
unittest.expect(
queryMap['objectType']!.first,
unittest.equals(arg_objectType),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildDynamicTargetingKeysListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserId: arg_advertiserId,
names: arg_names,
objectId: arg_objectId,
objectType: arg_objectType,
$fields: arg_$fields);
checkDynamicTargetingKeysListResponse(
response as api.DynamicTargetingKeysListResponse);
});
});
unittest.group('resource-EventTagsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEventTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkEventTag(response as api.EventTag);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_request = buildEventTag();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.EventTag.fromJson(json as core.Map<core.String, core.dynamic>);
checkEventTag(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEventTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkEventTag(response as api.EventTag);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_profileId = 'foo';
final arg_adId = 'foo';
final arg_advertiserId = 'foo';
final arg_campaignId = 'foo';
final arg_definitionsOnly = true;
final arg_enabled = true;
final arg_eventTagTypes = buildUnnamed269();
final arg_ids = buildUnnamed270();
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['adId']!.first,
unittest.equals(arg_adId),
);
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['campaignId']!.first,
unittest.equals(arg_campaignId),
);
unittest.expect(
queryMap['definitionsOnly']!.first,
unittest.equals('$arg_definitionsOnly'),
);
unittest.expect(
queryMap['enabled']!.first,
unittest.equals('$arg_enabled'),
);
unittest.expect(
queryMap['eventTagTypes']!,
unittest.equals(arg_eventTagTypes),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEventTagsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
adId: arg_adId,
advertiserId: arg_advertiserId,
campaignId: arg_campaignId,
definitionsOnly: arg_definitionsOnly,
enabled: arg_enabled,
eventTagTypes: arg_eventTagTypes,
ids: arg_ids,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkEventTagsListResponse(response as api.EventTagsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_request = buildEventTag();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.EventTag.fromJson(json as core.Map<core.String, core.dynamic>);
checkEventTag(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEventTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkEventTag(response as api.EventTag);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).eventTags;
final arg_request = buildEventTag();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.EventTag.fromJson(json as core.Map<core.String, core.dynamic>);
checkEventTag(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEventTag());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkEventTag(response as api.EventTag);
});
});
unittest.group('resource-FilesResource', () {
unittest.test('method--get', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).files;
final arg_reportId = 'foo';
final arg_fileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('reports/'),
);
pathOffset += 8;
index = path.indexOf('/files/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/files/'),
);
pathOffset += 7;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_reportId, arg_fileId, $fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).files;
final arg_profileId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_scope = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/files', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('/files'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['scope']!.first,
unittest.equals(arg_scope),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFileList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
scope: arg_scope,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkFileList(response as api.FileList);
});
});
unittest.group('resource-FloodlightActivitiesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--generatetag', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_profileId = 'foo';
final arg_floodlightActivityId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['floodlightActivityId']!.first,
unittest.equals(arg_floodlightActivityId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildFloodlightActivitiesGenerateTagResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generatetag(arg_profileId,
floodlightActivityId: arg_floodlightActivityId, $fields: arg_$fields);
checkFloodlightActivitiesGenerateTagResponse(
response as api.FloodlightActivitiesGenerateTagResponse);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivity());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkFloodlightActivity(response as api.FloodlightActivity);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_request = buildFloodlightActivity();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivity.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivity(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivity());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkFloodlightActivity(response as api.FloodlightActivity);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_floodlightActivityGroupIds = buildUnnamed271();
final arg_floodlightActivityGroupName = 'foo';
final arg_floodlightActivityGroupTagString = 'foo';
final arg_floodlightActivityGroupType = 'foo';
final arg_floodlightConfigurationId = 'foo';
final arg_ids = buildUnnamed272();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_tagString = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['floodlightActivityGroupIds']!,
unittest.equals(arg_floodlightActivityGroupIds),
);
unittest.expect(
queryMap['floodlightActivityGroupName']!.first,
unittest.equals(arg_floodlightActivityGroupName),
);
unittest.expect(
queryMap['floodlightActivityGroupTagString']!.first,
unittest.equals(arg_floodlightActivityGroupTagString),
);
unittest.expect(
queryMap['floodlightActivityGroupType']!.first,
unittest.equals(arg_floodlightActivityGroupType),
);
unittest.expect(
queryMap['floodlightConfigurationId']!.first,
unittest.equals(arg_floodlightConfigurationId),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['tagString']!.first,
unittest.equals(arg_tagString),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildFloodlightActivitiesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserId: arg_advertiserId,
floodlightActivityGroupIds: arg_floodlightActivityGroupIds,
floodlightActivityGroupName: arg_floodlightActivityGroupName,
floodlightActivityGroupTagString:
arg_floodlightActivityGroupTagString,
floodlightActivityGroupType: arg_floodlightActivityGroupType,
floodlightConfigurationId: arg_floodlightConfigurationId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
tagString: arg_tagString,
$fields: arg_$fields);
checkFloodlightActivitiesListResponse(
response as api.FloodlightActivitiesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_request = buildFloodlightActivity();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivity.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivity(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivity());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkFloodlightActivity(response as api.FloodlightActivity);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivities;
final arg_request = buildFloodlightActivity();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivity.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivity(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivity());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkFloodlightActivity(response as api.FloodlightActivity);
});
});
unittest.group('resource-FloodlightActivityGroupsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivityGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivityGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkFloodlightActivityGroup(response as api.FloodlightActivityGroup);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivityGroups;
final arg_request = buildFloodlightActivityGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivityGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivityGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivityGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkFloodlightActivityGroup(response as api.FloodlightActivityGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivityGroups;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_floodlightConfigurationId = 'foo';
final arg_ids = buildUnnamed273();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_type = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['floodlightConfigurationId']!.first,
unittest.equals(arg_floodlightConfigurationId),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['type']!.first,
unittest.equals(arg_type),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildFloodlightActivityGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserId: arg_advertiserId,
floodlightConfigurationId: arg_floodlightConfigurationId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
type: arg_type,
$fields: arg_$fields);
checkFloodlightActivityGroupsListResponse(
response as api.FloodlightActivityGroupsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivityGroups;
final arg_request = buildFloodlightActivityGroup();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivityGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivityGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivityGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkFloodlightActivityGroup(response as api.FloodlightActivityGroup);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightActivityGroups;
final arg_request = buildFloodlightActivityGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightActivityGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightActivityGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightActivityGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkFloodlightActivityGroup(response as api.FloodlightActivityGroup);
});
});
unittest.group('resource-FloodlightConfigurationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightConfigurations;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightConfiguration());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkFloodlightConfiguration(response as api.FloodlightConfiguration);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightConfigurations;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed274();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildFloodlightConfigurationsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.list(arg_profileId, ids: arg_ids, $fields: arg_$fields);
checkFloodlightConfigurationsListResponse(
response as api.FloodlightConfigurationsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightConfigurations;
final arg_request = buildFloodlightConfiguration();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightConfiguration.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightConfiguration(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightConfiguration());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkFloodlightConfiguration(response as api.FloodlightConfiguration);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).floodlightConfigurations;
final arg_request = buildFloodlightConfiguration();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.FloodlightConfiguration.fromJson(
json as core.Map<core.String, core.dynamic>);
checkFloodlightConfiguration(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFloodlightConfiguration());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkFloodlightConfiguration(response as api.FloodlightConfiguration);
});
});
unittest.group('resource-InventoryItemsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).inventoryItems;
final arg_profileId = 'foo';
final arg_projectId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildInventoryItem());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_projectId, arg_id,
$fields: arg_$fields);
checkInventoryItem(response as api.InventoryItem);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).inventoryItems;
final arg_profileId = 'foo';
final arg_projectId = 'foo';
final arg_ids = buildUnnamed275();
final arg_inPlan = true;
final arg_maxResults = 42;
final arg_orderId = buildUnnamed276();
final arg_pageToken = 'foo';
final arg_siteId = buildUnnamed277();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_type = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['inPlan']!.first,
unittest.equals('$arg_inPlan'),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['orderId']!,
unittest.equals(arg_orderId),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['siteId']!,
unittest.equals(arg_siteId),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['type']!.first,
unittest.equals(arg_type),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildInventoryItemsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_projectId,
ids: arg_ids,
inPlan: arg_inPlan,
maxResults: arg_maxResults,
orderId: arg_orderId,
pageToken: arg_pageToken,
siteId: arg_siteId,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
type: arg_type,
$fields: arg_$fields);
checkInventoryItemsListResponse(
response as api.InventoryItemsListResponse);
});
});
unittest.group('resource-LanguagesResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).languages;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLanguagesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkLanguagesListResponse(response as api.LanguagesListResponse);
});
});
unittest.group('resource-MetrosResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).metros;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMetrosListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkMetrosListResponse(response as api.MetrosListResponse);
});
});
unittest.group('resource-MobileAppsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).mobileApps;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMobileApp());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkMobileApp(response as api.MobileApp);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).mobileApps;
final arg_profileId = 'foo';
final arg_directories = buildUnnamed278();
final arg_ids = buildUnnamed279();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['directories']!,
unittest.equals(arg_directories),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMobileAppsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
directories: arg_directories,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
$fields: arg_$fields);
checkMobileAppsListResponse(response as api.MobileAppsListResponse);
});
});
unittest.group('resource-MobileCarriersResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).mobileCarriers;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMobileCarrier());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkMobileCarrier(response as api.MobileCarrier);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).mobileCarriers;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildMobileCarriersListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkMobileCarriersListResponse(
response as api.MobileCarriersListResponse);
});
});
unittest.group('resource-OperatingSystemVersionsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).operatingSystemVersions;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperatingSystemVersion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkOperatingSystemVersion(response as api.OperatingSystemVersion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).operatingSystemVersions;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildOperatingSystemVersionsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkOperatingSystemVersionsListResponse(
response as api.OperatingSystemVersionsListResponse);
});
});
unittest.group('resource-OperatingSystemsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).operatingSystems;
final arg_profileId = 'foo';
final arg_dartId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperatingSystem());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_dartId, $fields: arg_$fields);
checkOperatingSystem(response as api.OperatingSystem);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).operatingSystems;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperatingSystemsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkOperatingSystemsListResponse(
response as api.OperatingSystemsListResponse);
});
});
unittest.group('resource-OrdersResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).orders;
final arg_profileId = 'foo';
final arg_projectId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOrder());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_projectId, arg_id,
$fields: arg_$fields);
checkOrder(response as api.Order);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).orders;
final arg_profileId = 'foo';
final arg_projectId = 'foo';
final arg_ids = buildUnnamed280();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_siteId = buildUnnamed281();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['siteId']!,
unittest.equals(arg_siteId),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOrdersListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_projectId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
siteId: arg_siteId,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkOrdersListResponse(response as api.OrdersListResponse);
});
});
unittest.group('resource-PlacementGroupsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkPlacementGroup(response as api.PlacementGroup);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementGroups;
final arg_request = buildPlacementGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacementGroup(response as api.PlacementGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementGroups;
final arg_profileId = 'foo';
final arg_activeStatus = buildUnnamed282();
final arg_advertiserIds = buildUnnamed283();
final arg_campaignIds = buildUnnamed284();
final arg_contentCategoryIds = buildUnnamed285();
final arg_directorySiteIds = buildUnnamed286();
final arg_ids = buildUnnamed287();
final arg_maxEndDate = 'foo';
final arg_maxResults = 42;
final arg_maxStartDate = 'foo';
final arg_minEndDate = 'foo';
final arg_minStartDate = 'foo';
final arg_pageToken = 'foo';
final arg_placementGroupType = 'foo';
final arg_placementStrategyIds = buildUnnamed288();
final arg_pricingTypes = buildUnnamed289();
final arg_searchString = 'foo';
final arg_siteIds = buildUnnamed290();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['activeStatus']!,
unittest.equals(arg_activeStatus),
);
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['campaignIds']!,
unittest.equals(arg_campaignIds),
);
unittest.expect(
queryMap['contentCategoryIds']!,
unittest.equals(arg_contentCategoryIds),
);
unittest.expect(
queryMap['directorySiteIds']!,
unittest.equals(arg_directorySiteIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['maxEndDate']!.first,
unittest.equals(arg_maxEndDate),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['maxStartDate']!.first,
unittest.equals(arg_maxStartDate),
);
unittest.expect(
queryMap['minEndDate']!.first,
unittest.equals(arg_minEndDate),
);
unittest.expect(
queryMap['minStartDate']!.first,
unittest.equals(arg_minStartDate),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['placementGroupType']!.first,
unittest.equals(arg_placementGroupType),
);
unittest.expect(
queryMap['placementStrategyIds']!,
unittest.equals(arg_placementStrategyIds),
);
unittest.expect(
queryMap['pricingTypes']!,
unittest.equals(arg_pricingTypes),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['siteIds']!,
unittest.equals(arg_siteIds),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
activeStatus: arg_activeStatus,
advertiserIds: arg_advertiserIds,
campaignIds: arg_campaignIds,
contentCategoryIds: arg_contentCategoryIds,
directorySiteIds: arg_directorySiteIds,
ids: arg_ids,
maxEndDate: arg_maxEndDate,
maxResults: arg_maxResults,
maxStartDate: arg_maxStartDate,
minEndDate: arg_minEndDate,
minStartDate: arg_minStartDate,
pageToken: arg_pageToken,
placementGroupType: arg_placementGroupType,
placementStrategyIds: arg_placementStrategyIds,
pricingTypes: arg_pricingTypes,
searchString: arg_searchString,
siteIds: arg_siteIds,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkPlacementGroupsListResponse(
response as api.PlacementGroupsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementGroups;
final arg_request = buildPlacementGroup();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkPlacementGroup(response as api.PlacementGroup);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementGroups;
final arg_request = buildPlacementGroup();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementGroup.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementGroup(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacementGroup(response as api.PlacementGroup);
});
});
unittest.group('resource-PlacementStrategiesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementStrategy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkPlacementStrategy(response as api.PlacementStrategy);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_request = buildPlacementStrategy();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementStrategy.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementStrategy(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementStrategy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacementStrategy(response as api.PlacementStrategy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed291();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildPlacementStrategiesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkPlacementStrategiesListResponse(
response as api.PlacementStrategiesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_request = buildPlacementStrategy();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementStrategy.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementStrategy(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementStrategy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkPlacementStrategy(response as api.PlacementStrategy);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placementStrategies;
final arg_request = buildPlacementStrategy();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.PlacementStrategy.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPlacementStrategy(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementStrategy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacementStrategy(response as api.PlacementStrategy);
});
});
unittest.group('resource-PlacementsResource', () {
unittest.test('method--generatetags', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_profileId = 'foo';
final arg_campaignId = 'foo';
final arg_placementIds = buildUnnamed292();
final arg_tagFormats = buildUnnamed293();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['campaignId']!.first,
unittest.equals(arg_campaignId),
);
unittest.expect(
queryMap['placementIds']!,
unittest.equals(arg_placementIds),
);
unittest.expect(
queryMap['tagFormats']!,
unittest.equals(arg_tagFormats),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementsGenerateTagsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generatetags(arg_profileId,
campaignId: arg_campaignId,
placementIds: arg_placementIds,
tagFormats: arg_tagFormats,
$fields: arg_$fields);
checkPlacementsGenerateTagsResponse(
response as api.PlacementsGenerateTagsResponse);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacement());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkPlacement(response as api.Placement);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_request = buildPlacement();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Placement.fromJson(json as core.Map<core.String, core.dynamic>);
checkPlacement(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacement());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacement(response as api.Placement);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_profileId = 'foo';
final arg_activeStatus = buildUnnamed294();
final arg_advertiserIds = buildUnnamed295();
final arg_campaignIds = buildUnnamed296();
final arg_compatibilities = buildUnnamed297();
final arg_contentCategoryIds = buildUnnamed298();
final arg_directorySiteIds = buildUnnamed299();
final arg_groupIds = buildUnnamed300();
final arg_ids = buildUnnamed301();
final arg_maxEndDate = 'foo';
final arg_maxResults = 42;
final arg_maxStartDate = 'foo';
final arg_minEndDate = 'foo';
final arg_minStartDate = 'foo';
final arg_pageToken = 'foo';
final arg_paymentSource = 'foo';
final arg_placementStrategyIds = buildUnnamed302();
final arg_pricingTypes = buildUnnamed303();
final arg_searchString = 'foo';
final arg_siteIds = buildUnnamed304();
final arg_sizeIds = buildUnnamed305();
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['activeStatus']!,
unittest.equals(arg_activeStatus),
);
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['campaignIds']!,
unittest.equals(arg_campaignIds),
);
unittest.expect(
queryMap['compatibilities']!,
unittest.equals(arg_compatibilities),
);
unittest.expect(
queryMap['contentCategoryIds']!,
unittest.equals(arg_contentCategoryIds),
);
unittest.expect(
queryMap['directorySiteIds']!,
unittest.equals(arg_directorySiteIds),
);
unittest.expect(
queryMap['groupIds']!,
unittest.equals(arg_groupIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['maxEndDate']!.first,
unittest.equals(arg_maxEndDate),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['maxStartDate']!.first,
unittest.equals(arg_maxStartDate),
);
unittest.expect(
queryMap['minEndDate']!.first,
unittest.equals(arg_minEndDate),
);
unittest.expect(
queryMap['minStartDate']!.first,
unittest.equals(arg_minStartDate),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['paymentSource']!.first,
unittest.equals(arg_paymentSource),
);
unittest.expect(
queryMap['placementStrategyIds']!,
unittest.equals(arg_placementStrategyIds),
);
unittest.expect(
queryMap['pricingTypes']!,
unittest.equals(arg_pricingTypes),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['siteIds']!,
unittest.equals(arg_siteIds),
);
unittest.expect(
queryMap['sizeIds']!,
unittest.equals(arg_sizeIds),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacementsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
activeStatus: arg_activeStatus,
advertiserIds: arg_advertiserIds,
campaignIds: arg_campaignIds,
compatibilities: arg_compatibilities,
contentCategoryIds: arg_contentCategoryIds,
directorySiteIds: arg_directorySiteIds,
groupIds: arg_groupIds,
ids: arg_ids,
maxEndDate: arg_maxEndDate,
maxResults: arg_maxResults,
maxStartDate: arg_maxStartDate,
minEndDate: arg_minEndDate,
minStartDate: arg_minStartDate,
pageToken: arg_pageToken,
paymentSource: arg_paymentSource,
placementStrategyIds: arg_placementStrategyIds,
pricingTypes: arg_pricingTypes,
searchString: arg_searchString,
siteIds: arg_siteIds,
sizeIds: arg_sizeIds,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkPlacementsListResponse(response as api.PlacementsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_request = buildPlacement();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Placement.fromJson(json as core.Map<core.String, core.dynamic>);
checkPlacement(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacement());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkPlacement(response as api.Placement);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).placements;
final arg_request = buildPlacement();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Placement.fromJson(json as core.Map<core.String, core.dynamic>);
checkPlacement(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlacement());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkPlacement(response as api.Placement);
});
});
unittest.group('resource-PlatformTypesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).platformTypes;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlatformType());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkPlatformType(response as api.PlatformType);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).platformTypes;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPlatformTypesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkPlatformTypesListResponse(response as api.PlatformTypesListResponse);
});
});
unittest.group('resource-PostalCodesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).postalCodes;
final arg_profileId = 'foo';
final arg_code = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPostalCode());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_code, $fields: arg_$fields);
checkPostalCode(response as api.PostalCode);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).postalCodes;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPostalCodesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkPostalCodesListResponse(response as api.PostalCodesListResponse);
});
});
unittest.group('resource-ProjectsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).projects;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildProject());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkProject(response as api.Project);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).projects;
final arg_profileId = 'foo';
final arg_advertiserIds = buildUnnamed306();
final arg_ids = buildUnnamed307();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserIds']!,
unittest.equals(arg_advertiserIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildProjectsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserIds: arg_advertiserIds,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkProjectsListResponse(response as api.ProjectsListResponse);
});
});
unittest.group('resource-RegionsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).regions;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRegionsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkRegionsListResponse(response as api.RegionsListResponse);
});
});
unittest.group('resource-RemarketingListSharesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingListShares;
final arg_profileId = 'foo';
final arg_remarketingListId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingListShare());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_remarketingListId,
$fields: arg_$fields);
checkRemarketingListShare(response as api.RemarketingListShare);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingListShares;
final arg_request = buildRemarketingListShare();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RemarketingListShare.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRemarketingListShare(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingListShare());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkRemarketingListShare(response as api.RemarketingListShare);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingListShares;
final arg_request = buildRemarketingListShare();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RemarketingListShare.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRemarketingListShare(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingListShare());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkRemarketingListShare(response as api.RemarketingListShare);
});
});
unittest.group('resource-RemarketingListsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingLists;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkRemarketingList(response as api.RemarketingList);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingLists;
final arg_request = buildRemarketingList();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RemarketingList.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRemarketingList(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkRemarketingList(response as api.RemarketingList);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingLists;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_active = true;
final arg_floodlightActivityId = 'foo';
final arg_maxResults = 42;
final arg_name = 'foo';
final arg_pageToken = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
queryMap['floodlightActivityId']!.first,
unittest.equals(arg_floodlightActivityId),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingListsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_advertiserId,
active: arg_active,
floodlightActivityId: arg_floodlightActivityId,
maxResults: arg_maxResults,
name: arg_name,
pageToken: arg_pageToken,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkRemarketingListsListResponse(
response as api.RemarketingListsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingLists;
final arg_request = buildRemarketingList();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RemarketingList.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRemarketingList(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkRemarketingList(response as api.RemarketingList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).remarketingLists;
final arg_request = buildRemarketingList();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RemarketingList.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRemarketingList(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRemarketingList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkRemarketingList(response as api.RemarketingList);
});
});
unittest.group('resource-ReportsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_reportId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReport());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_reportId, $fields: arg_$fields);
checkReport(response as api.Report);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_request = buildReport();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Report.fromJson(json as core.Map<core.String, core.dynamic>);
checkReport(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/reports'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReport());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkReport(response as api.Report);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_profileId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_scope = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/reports'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['scope']!.first,
unittest.equals(arg_scope),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReportList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
scope: arg_scope,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkReportList(response as api.ReportList);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_request = buildReport();
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Report.fromJson(json as core.Map<core.String, core.dynamic>);
checkReport(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReport());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_reportId,
$fields: arg_$fields);
checkReport(response as api.Report);
});
unittest.test('method--run', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_synchronous = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
index = path.indexOf('/run', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 4),
unittest.equals('/run'),
);
pathOffset += 4;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['synchronous']!.first,
unittest.equals('$arg_synchronous'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.run(arg_profileId, arg_reportId,
synchronous: arg_synchronous, $fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports;
final arg_request = buildReport();
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Report.fromJson(json as core.Map<core.String, core.dynamic>);
checkReport(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReport());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_profileId, arg_reportId,
$fields: arg_$fields);
checkReport(response as api.Report);
});
});
unittest.group('resource-ReportsCompatibleFieldsResource', () {
unittest.test('method--query', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports.compatibleFields;
final arg_request = buildReport();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Report.fromJson(json as core.Map<core.String, core.dynamic>);
checkReport(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/compatiblefields/query', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 31),
unittest.equals('/reports/compatiblefields/query'),
);
pathOffset += 31;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCompatibleFields());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.query(arg_request, arg_profileId, $fields: arg_$fields);
checkCompatibleFields(response as api.CompatibleFields);
});
});
unittest.group('resource-ReportsFilesResource', () {
unittest.test('method--get', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports.files;
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_fileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
index = path.indexOf('/files/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/files/'),
);
pathOffset += 7;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, arg_reportId, arg_fileId,
$fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).reports.files;
final arg_profileId = 'foo';
final arg_reportId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
index = path.indexOf('/reports/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/reports/'),
);
pathOffset += 9;
index = path.indexOf('/files', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_reportId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('/files'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFileList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_reportId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkFileList(response as api.FileList);
});
});
unittest.group('resource-SitesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sites;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkSite(response as api.Site);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sites;
final arg_request = buildSite();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Site.fromJson(json as core.Map<core.String, core.dynamic>);
checkSite(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkSite(response as api.Site);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sites;
final arg_profileId = 'foo';
final arg_acceptsInStreamVideoPlacements = true;
final arg_acceptsInterstitialPlacements = true;
final arg_acceptsPublisherPaidPlacements = true;
final arg_adWordsSite = true;
final arg_approved = true;
final arg_campaignIds = buildUnnamed308();
final arg_directorySiteIds = buildUnnamed309();
final arg_ids = buildUnnamed310();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_subaccountId = 'foo';
final arg_unmappedSite = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['acceptsInStreamVideoPlacements']!.first,
unittest.equals('$arg_acceptsInStreamVideoPlacements'),
);
unittest.expect(
queryMap['acceptsInterstitialPlacements']!.first,
unittest.equals('$arg_acceptsInterstitialPlacements'),
);
unittest.expect(
queryMap['acceptsPublisherPaidPlacements']!.first,
unittest.equals('$arg_acceptsPublisherPaidPlacements'),
);
unittest.expect(
queryMap['adWordsSite']!.first,
unittest.equals('$arg_adWordsSite'),
);
unittest.expect(
queryMap['approved']!.first,
unittest.equals('$arg_approved'),
);
unittest.expect(
queryMap['campaignIds']!,
unittest.equals(arg_campaignIds),
);
unittest.expect(
queryMap['directorySiteIds']!,
unittest.equals(arg_directorySiteIds),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['unmappedSite']!.first,
unittest.equals('$arg_unmappedSite'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSitesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
acceptsInStreamVideoPlacements: arg_acceptsInStreamVideoPlacements,
acceptsInterstitialPlacements: arg_acceptsInterstitialPlacements,
acceptsPublisherPaidPlacements: arg_acceptsPublisherPaidPlacements,
adWordsSite: arg_adWordsSite,
approved: arg_approved,
campaignIds: arg_campaignIds,
directorySiteIds: arg_directorySiteIds,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
subaccountId: arg_subaccountId,
unmappedSite: arg_unmappedSite,
$fields: arg_$fields);
checkSitesListResponse(response as api.SitesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sites;
final arg_request = buildSite();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Site.fromJson(json as core.Map<core.String, core.dynamic>);
checkSite(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkSite(response as api.Site);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sites;
final arg_request = buildSite();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Site.fromJson(json as core.Map<core.String, core.dynamic>);
checkSite(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSite());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkSite(response as api.Site);
});
});
unittest.group('resource-SizesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sizes;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSize());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkSize(response as api.Size);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sizes;
final arg_request = buildSize();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Size.fromJson(json as core.Map<core.String, core.dynamic>);
checkSize(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSize());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkSize(response as api.Size);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).sizes;
final arg_profileId = 'foo';
final arg_height = 42;
final arg_iabStandard = true;
final arg_ids = buildUnnamed311();
final arg_width = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['height']!.first),
unittest.equals(arg_height),
);
unittest.expect(
queryMap['iabStandard']!.first,
unittest.equals('$arg_iabStandard'),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['width']!.first),
unittest.equals(arg_width),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSizesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
height: arg_height,
iabStandard: arg_iabStandard,
ids: arg_ids,
width: arg_width,
$fields: arg_$fields);
checkSizesListResponse(response as api.SizesListResponse);
});
});
unittest.group('resource-SubaccountsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).subaccounts;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSubaccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkSubaccount(response as api.Subaccount);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).subaccounts;
final arg_request = buildSubaccount();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Subaccount.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSubaccount(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSubaccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkSubaccount(response as api.Subaccount);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).subaccounts;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed312();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSubaccountsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkSubaccountsListResponse(response as api.SubaccountsListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).subaccounts;
final arg_request = buildSubaccount();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Subaccount.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSubaccount(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSubaccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkSubaccount(response as api.Subaccount);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).subaccounts;
final arg_request = buildSubaccount();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Subaccount.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSubaccount(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSubaccount());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkSubaccount(response as api.Subaccount);
});
});
unittest.group('resource-TargetableRemarketingListsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetableRemarketingLists;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetableRemarketingList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkTargetableRemarketingList(response as api.TargetableRemarketingList);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetableRemarketingLists;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_active = true;
final arg_maxResults = 42;
final arg_name = 'foo';
final arg_pageToken = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['active']!.first,
unittest.equals('$arg_active'),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['name']!.first,
unittest.equals(arg_name),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildTargetableRemarketingListsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, arg_advertiserId,
active: arg_active,
maxResults: arg_maxResults,
name: arg_name,
pageToken: arg_pageToken,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkTargetableRemarketingListsListResponse(
response as api.TargetableRemarketingListsListResponse);
});
});
unittest.group('resource-TargetingTemplatesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetingTemplates;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetingTemplate());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkTargetingTemplate(response as api.TargetingTemplate);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetingTemplates;
final arg_request = buildTargetingTemplate();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TargetingTemplate.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTargetingTemplate(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetingTemplate());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkTargetingTemplate(response as api.TargetingTemplate);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetingTemplates;
final arg_profileId = 'foo';
final arg_advertiserId = 'foo';
final arg_ids = buildUnnamed313();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['advertiserId']!.first,
unittest.equals(arg_advertiserId),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetingTemplatesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
advertiserId: arg_advertiserId,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
$fields: arg_$fields);
checkTargetingTemplatesListResponse(
response as api.TargetingTemplatesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetingTemplates;
final arg_request = buildTargetingTemplate();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TargetingTemplate.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTargetingTemplate(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetingTemplate());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkTargetingTemplate(response as api.TargetingTemplate);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).targetingTemplates;
final arg_request = buildTargetingTemplate();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TargetingTemplate.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTargetingTemplate(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTargetingTemplate());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkTargetingTemplate(response as api.TargetingTemplate);
});
});
unittest.group('resource-UserProfilesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userProfiles;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_profileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserProfile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_profileId, $fields: arg_$fields);
checkUserProfile(response as api.UserProfile);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userProfiles;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('userprofiles'),
);
pathOffset += 12;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserProfileList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list($fields: arg_$fields);
checkUserProfileList(response as api.UserProfileList);
});
});
unittest.group('resource-UserRolePermissionGroupsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRolePermissionGroups;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRolePermissionGroup());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkUserRolePermissionGroup(response as api.UserRolePermissionGroup);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRolePermissionGroups;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildUserRolePermissionGroupsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkUserRolePermissionGroupsListResponse(
response as api.UserRolePermissionGroupsListResponse);
});
});
unittest.group('resource-UserRolePermissionsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRolePermissions;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRolePermission());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkUserRolePermission(response as api.UserRolePermission);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRolePermissions;
final arg_profileId = 'foo';
final arg_ids = buildUnnamed314();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp =
convert.json.encode(buildUserRolePermissionsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.list(arg_profileId, ids: arg_ids, $fields: arg_$fields);
checkUserRolePermissionsListResponse(
response as api.UserRolePermissionsListResponse);
});
});
unittest.group('resource-UserRolesResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_profileId, arg_id, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRole());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkUserRole(response as api.UserRole);
});
unittest.test('method--insert', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_request = buildUserRole();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.UserRole.fromJson(json as core.Map<core.String, core.dynamic>);
checkUserRole(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRole());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.insert(arg_request, arg_profileId, $fields: arg_$fields);
checkUserRole(response as api.UserRole);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_profileId = 'foo';
final arg_accountUserRoleOnly = true;
final arg_ids = buildUnnamed315();
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_searchString = 'foo';
final arg_sortField = 'foo';
final arg_sortOrder = 'foo';
final arg_subaccountId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['accountUserRoleOnly']!.first,
unittest.equals('$arg_accountUserRoleOnly'),
);
unittest.expect(
queryMap['ids']!,
unittest.equals(arg_ids),
);
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['searchString']!.first,
unittest.equals(arg_searchString),
);
unittest.expect(
queryMap['sortField']!.first,
unittest.equals(arg_sortField),
);
unittest.expect(
queryMap['sortOrder']!.first,
unittest.equals(arg_sortOrder),
);
unittest.expect(
queryMap['subaccountId']!.first,
unittest.equals(arg_subaccountId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRolesListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId,
accountUserRoleOnly: arg_accountUserRoleOnly,
ids: arg_ids,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
searchString: arg_searchString,
sortField: arg_sortField,
sortOrder: arg_sortOrder,
subaccountId: arg_subaccountId,
$fields: arg_$fields);
checkUserRolesListResponse(response as api.UserRolesListResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_request = buildUserRole();
final arg_profileId = 'foo';
final arg_id = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.UserRole.fromJson(json as core.Map<core.String, core.dynamic>);
checkUserRole(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['id']!.first,
unittest.equals(arg_id),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRole());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_profileId, arg_id,
$fields: arg_$fields);
checkUserRole(response as api.UserRole);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).userRoles;
final arg_request = buildUserRole();
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.UserRole.fromJson(json as core.Map<core.String, core.dynamic>);
checkUserRole(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildUserRole());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_profileId, $fields: arg_$fields);
checkUserRole(response as api.UserRole);
});
});
unittest.group('resource-VideoFormatsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).videoFormats;
final arg_profileId = 'foo';
final arg_id = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVideoFormat());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_profileId, arg_id, $fields: arg_$fields);
checkVideoFormat(response as api.VideoFormat);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DfareportingApi(mock).videoFormats;
final arg_profileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('dfareporting/v4/'),
);
pathOffset += 16;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('userprofiles/'),
);
pathOffset += 13;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildVideoFormatsListResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_profileId, $fields: arg_$fields);
checkVideoFormatsListResponse(response as api.VideoFormatsListResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/dfareporting/v4_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/dfareporting/v4_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 436135}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/drive/v3.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterAboutDriveThemes = 0;
api.AboutDriveThemes buildAboutDriveThemes() {
final o = api.AboutDriveThemes();
buildCounterAboutDriveThemes++;
if (buildCounterAboutDriveThemes < 3) {
o.backgroundImageLink = 'foo';
o.colorRgb = 'foo';
o.id = 'foo';
}
buildCounterAboutDriveThemes--;
return o;
}
void checkAboutDriveThemes(api.AboutDriveThemes o) {
buildCounterAboutDriveThemes++;
if (buildCounterAboutDriveThemes < 3) {
unittest.expect(
o.backgroundImageLink!,
unittest.equals('foo'),
);
unittest.expect(
o.colorRgb!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
}
buildCounterAboutDriveThemes--;
}
core.List<api.AboutDriveThemes> buildUnnamed0() => [
buildAboutDriveThemes(),
buildAboutDriveThemes(),
];
void checkUnnamed0(core.List<api.AboutDriveThemes> o) {
unittest.expect(o, unittest.hasLength(2));
checkAboutDriveThemes(o[0]);
checkAboutDriveThemes(o[1]);
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.Map<core.String, core.List<core.String>> buildUnnamed2() => {
'x': buildUnnamed1(),
'y': buildUnnamed1(),
};
void checkUnnamed2(core.Map<core.String, core.List<core.String>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed1(o['x']!);
checkUnnamed1(o['y']!);
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.Map<core.String, core.List<core.String>> buildUnnamed5() => {
'x': buildUnnamed4(),
'y': buildUnnamed4(),
};
void checkUnnamed5(core.Map<core.String, core.List<core.String>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed4(o['x']!);
checkUnnamed4(o['y']!);
}
core.Map<core.String, core.String> buildUnnamed6() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed6(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterAboutStorageQuota = 0;
api.AboutStorageQuota buildAboutStorageQuota() {
final o = api.AboutStorageQuota();
buildCounterAboutStorageQuota++;
if (buildCounterAboutStorageQuota < 3) {
o.limit = 'foo';
o.usage = 'foo';
o.usageInDrive = 'foo';
o.usageInDriveTrash = 'foo';
}
buildCounterAboutStorageQuota--;
return o;
}
void checkAboutStorageQuota(api.AboutStorageQuota o) {
buildCounterAboutStorageQuota++;
if (buildCounterAboutStorageQuota < 3) {
unittest.expect(
o.limit!,
unittest.equals('foo'),
);
unittest.expect(
o.usage!,
unittest.equals('foo'),
);
unittest.expect(
o.usageInDrive!,
unittest.equals('foo'),
);
unittest.expect(
o.usageInDriveTrash!,
unittest.equals('foo'),
);
}
buildCounterAboutStorageQuota--;
}
core.int buildCounterAboutTeamDriveThemes = 0;
api.AboutTeamDriveThemes buildAboutTeamDriveThemes() {
final o = api.AboutTeamDriveThemes();
buildCounterAboutTeamDriveThemes++;
if (buildCounterAboutTeamDriveThemes < 3) {
o.backgroundImageLink = 'foo';
o.colorRgb = 'foo';
o.id = 'foo';
}
buildCounterAboutTeamDriveThemes--;
return o;
}
void checkAboutTeamDriveThemes(api.AboutTeamDriveThemes o) {
buildCounterAboutTeamDriveThemes++;
if (buildCounterAboutTeamDriveThemes < 3) {
unittest.expect(
o.backgroundImageLink!,
unittest.equals('foo'),
);
unittest.expect(
o.colorRgb!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
}
buildCounterAboutTeamDriveThemes--;
}
core.List<api.AboutTeamDriveThemes> buildUnnamed7() => [
buildAboutTeamDriveThemes(),
buildAboutTeamDriveThemes(),
];
void checkUnnamed7(core.List<api.AboutTeamDriveThemes> o) {
unittest.expect(o, unittest.hasLength(2));
checkAboutTeamDriveThemes(o[0]);
checkAboutTeamDriveThemes(o[1]);
}
core.int buildCounterAbout = 0;
api.About buildAbout() {
final o = api.About();
buildCounterAbout++;
if (buildCounterAbout < 3) {
o.appInstalled = true;
o.canCreateDrives = true;
o.canCreateTeamDrives = true;
o.driveThemes = buildUnnamed0();
o.exportFormats = buildUnnamed2();
o.folderColorPalette = buildUnnamed3();
o.importFormats = buildUnnamed5();
o.kind = 'foo';
o.maxImportSizes = buildUnnamed6();
o.maxUploadSize = 'foo';
o.storageQuota = buildAboutStorageQuota();
o.teamDriveThemes = buildUnnamed7();
o.user = buildUser();
}
buildCounterAbout--;
return o;
}
void checkAbout(api.About o) {
buildCounterAbout++;
if (buildCounterAbout < 3) {
unittest.expect(o.appInstalled!, unittest.isTrue);
unittest.expect(o.canCreateDrives!, unittest.isTrue);
unittest.expect(o.canCreateTeamDrives!, unittest.isTrue);
checkUnnamed0(o.driveThemes!);
checkUnnamed2(o.exportFormats!);
checkUnnamed3(o.folderColorPalette!);
checkUnnamed5(o.importFormats!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed6(o.maxImportSizes!);
unittest.expect(
o.maxUploadSize!,
unittest.equals('foo'),
);
checkAboutStorageQuota(o.storageQuota!);
checkUnnamed7(o.teamDriveThemes!);
checkUser(o.user!);
}
buildCounterAbout--;
}
core.int buildCounterChange = 0;
api.Change buildChange() {
final o = api.Change();
buildCounterChange++;
if (buildCounterChange < 3) {
o.changeType = 'foo';
o.drive = buildDrive();
o.driveId = 'foo';
o.file = buildFile();
o.fileId = 'foo';
o.kind = 'foo';
o.removed = true;
o.teamDrive = buildTeamDrive();
o.teamDriveId = 'foo';
o.time = core.DateTime.parse('2002-02-27T14:01:02Z');
o.type = 'foo';
}
buildCounterChange--;
return o;
}
void checkChange(api.Change o) {
buildCounterChange++;
if (buildCounterChange < 3) {
unittest.expect(
o.changeType!,
unittest.equals('foo'),
);
checkDrive(o.drive!);
unittest.expect(
o.driveId!,
unittest.equals('foo'),
);
checkFile(o.file!);
unittest.expect(
o.fileId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.removed!, unittest.isTrue);
checkTeamDrive(o.teamDrive!);
unittest.expect(
o.teamDriveId!,
unittest.equals('foo'),
);
unittest.expect(
o.time!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterChange--;
}
core.List<api.Change> buildUnnamed8() => [
buildChange(),
buildChange(),
];
void checkUnnamed8(core.List<api.Change> o) {
unittest.expect(o, unittest.hasLength(2));
checkChange(o[0]);
checkChange(o[1]);
}
core.int buildCounterChangeList = 0;
api.ChangeList buildChangeList() {
final o = api.ChangeList();
buildCounterChangeList++;
if (buildCounterChangeList < 3) {
o.changes = buildUnnamed8();
o.kind = 'foo';
o.newStartPageToken = 'foo';
o.nextPageToken = 'foo';
}
buildCounterChangeList--;
return o;
}
void checkChangeList(api.ChangeList o) {
buildCounterChangeList++;
if (buildCounterChangeList < 3) {
checkUnnamed8(o.changes!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.newStartPageToken!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterChangeList--;
}
core.Map<core.String, core.String> buildUnnamed9() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed9(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterChannel = 0;
api.Channel buildChannel() {
final o = api.Channel();
buildCounterChannel++;
if (buildCounterChannel < 3) {
o.address = 'foo';
o.expiration = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.params = buildUnnamed9();
o.payload = true;
o.resourceId = 'foo';
o.resourceUri = 'foo';
o.token = 'foo';
o.type = 'foo';
}
buildCounterChannel--;
return o;
}
void checkChannel(api.Channel o) {
buildCounterChannel++;
if (buildCounterChannel < 3) {
unittest.expect(
o.address!,
unittest.equals('foo'),
);
unittest.expect(
o.expiration!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed9(o.params!);
unittest.expect(o.payload!, unittest.isTrue);
unittest.expect(
o.resourceId!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
unittest.expect(
o.token!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterChannel--;
}
core.int buildCounterCommentQuotedFileContent = 0;
api.CommentQuotedFileContent buildCommentQuotedFileContent() {
final o = api.CommentQuotedFileContent();
buildCounterCommentQuotedFileContent++;
if (buildCounterCommentQuotedFileContent < 3) {
o.mimeType = 'foo';
o.value = 'foo';
}
buildCounterCommentQuotedFileContent--;
return o;
}
void checkCommentQuotedFileContent(api.CommentQuotedFileContent o) {
buildCounterCommentQuotedFileContent++;
if (buildCounterCommentQuotedFileContent < 3) {
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterCommentQuotedFileContent--;
}
core.List<api.Reply> buildUnnamed10() => [
buildReply(),
buildReply(),
];
void checkUnnamed10(core.List<api.Reply> o) {
unittest.expect(o, unittest.hasLength(2));
checkReply(o[0]);
checkReply(o[1]);
}
core.int buildCounterComment = 0;
api.Comment buildComment() {
final o = api.Comment();
buildCounterComment++;
if (buildCounterComment < 3) {
o.anchor = 'foo';
o.author = buildUser();
o.content = 'foo';
o.createdTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.deleted = true;
o.htmlContent = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.modifiedTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.quotedFileContent = buildCommentQuotedFileContent();
o.replies = buildUnnamed10();
o.resolved = true;
}
buildCounterComment--;
return o;
}
void checkComment(api.Comment o) {
buildCounterComment++;
if (buildCounterComment < 3) {
unittest.expect(
o.anchor!,
unittest.equals('foo'),
);
checkUser(o.author!);
unittest.expect(
o.content!,
unittest.equals('foo'),
);
unittest.expect(
o.createdTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(o.deleted!, unittest.isTrue);
unittest.expect(
o.htmlContent!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.modifiedTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkCommentQuotedFileContent(o.quotedFileContent!);
checkUnnamed10(o.replies!);
unittest.expect(o.resolved!, unittest.isTrue);
}
buildCounterComment--;
}
core.List<api.Comment> buildUnnamed11() => [
buildComment(),
buildComment(),
];
void checkUnnamed11(core.List<api.Comment> o) {
unittest.expect(o, unittest.hasLength(2));
checkComment(o[0]);
checkComment(o[1]);
}
core.int buildCounterCommentList = 0;
api.CommentList buildCommentList() {
final o = api.CommentList();
buildCounterCommentList++;
if (buildCounterCommentList < 3) {
o.comments = buildUnnamed11();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterCommentList--;
return o;
}
void checkCommentList(api.CommentList o) {
buildCounterCommentList++;
if (buildCounterCommentList < 3) {
checkUnnamed11(o.comments!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterCommentList--;
}
core.int buildCounterContentRestriction = 0;
api.ContentRestriction buildContentRestriction() {
final o = api.ContentRestriction();
buildCounterContentRestriction++;
if (buildCounterContentRestriction < 3) {
o.ownerRestricted = true;
o.readOnly = true;
o.reason = 'foo';
o.restrictingUser = buildUser();
o.restrictionTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.type = 'foo';
}
buildCounterContentRestriction--;
return o;
}
void checkContentRestriction(api.ContentRestriction o) {
buildCounterContentRestriction++;
if (buildCounterContentRestriction < 3) {
unittest.expect(o.ownerRestricted!, unittest.isTrue);
unittest.expect(o.readOnly!, unittest.isTrue);
unittest.expect(
o.reason!,
unittest.equals('foo'),
);
checkUser(o.restrictingUser!);
unittest.expect(
o.restrictionTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterContentRestriction--;
}
core.int buildCounterDriveBackgroundImageFile = 0;
api.DriveBackgroundImageFile buildDriveBackgroundImageFile() {
final o = api.DriveBackgroundImageFile();
buildCounterDriveBackgroundImageFile++;
if (buildCounterDriveBackgroundImageFile < 3) {
o.id = 'foo';
o.width = 42.0;
o.xCoordinate = 42.0;
o.yCoordinate = 42.0;
}
buildCounterDriveBackgroundImageFile--;
return o;
}
void checkDriveBackgroundImageFile(api.DriveBackgroundImageFile o) {
buildCounterDriveBackgroundImageFile++;
if (buildCounterDriveBackgroundImageFile < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42.0),
);
unittest.expect(
o.xCoordinate!,
unittest.equals(42.0),
);
unittest.expect(
o.yCoordinate!,
unittest.equals(42.0),
);
}
buildCounterDriveBackgroundImageFile--;
}
core.int buildCounterDriveCapabilities = 0;
api.DriveCapabilities buildDriveCapabilities() {
final o = api.DriveCapabilities();
buildCounterDriveCapabilities++;
if (buildCounterDriveCapabilities < 3) {
o.canAddChildren = true;
o.canChangeCopyRequiresWriterPermissionRestriction = true;
o.canChangeDomainUsersOnlyRestriction = true;
o.canChangeDriveBackground = true;
o.canChangeDriveMembersOnlyRestriction = true;
o.canChangeSharingFoldersRequiresOrganizerPermissionRestriction = true;
o.canComment = true;
o.canCopy = true;
o.canDeleteChildren = true;
o.canDeleteDrive = true;
o.canDownload = true;
o.canEdit = true;
o.canListChildren = true;
o.canManageMembers = true;
o.canReadRevisions = true;
o.canRename = true;
o.canRenameDrive = true;
o.canResetDriveRestrictions = true;
o.canShare = true;
o.canTrashChildren = true;
}
buildCounterDriveCapabilities--;
return o;
}
void checkDriveCapabilities(api.DriveCapabilities o) {
buildCounterDriveCapabilities++;
if (buildCounterDriveCapabilities < 3) {
unittest.expect(o.canAddChildren!, unittest.isTrue);
unittest.expect(
o.canChangeCopyRequiresWriterPermissionRestriction!, unittest.isTrue);
unittest.expect(o.canChangeDomainUsersOnlyRestriction!, unittest.isTrue);
unittest.expect(o.canChangeDriveBackground!, unittest.isTrue);
unittest.expect(o.canChangeDriveMembersOnlyRestriction!, unittest.isTrue);
unittest.expect(
o.canChangeSharingFoldersRequiresOrganizerPermissionRestriction!,
unittest.isTrue);
unittest.expect(o.canComment!, unittest.isTrue);
unittest.expect(o.canCopy!, unittest.isTrue);
unittest.expect(o.canDeleteChildren!, unittest.isTrue);
unittest.expect(o.canDeleteDrive!, unittest.isTrue);
unittest.expect(o.canDownload!, unittest.isTrue);
unittest.expect(o.canEdit!, unittest.isTrue);
unittest.expect(o.canListChildren!, unittest.isTrue);
unittest.expect(o.canManageMembers!, unittest.isTrue);
unittest.expect(o.canReadRevisions!, unittest.isTrue);
unittest.expect(o.canRename!, unittest.isTrue);
unittest.expect(o.canRenameDrive!, unittest.isTrue);
unittest.expect(o.canResetDriveRestrictions!, unittest.isTrue);
unittest.expect(o.canShare!, unittest.isTrue);
unittest.expect(o.canTrashChildren!, unittest.isTrue);
}
buildCounterDriveCapabilities--;
}
core.int buildCounterDriveRestrictions = 0;
api.DriveRestrictions buildDriveRestrictions() {
final o = api.DriveRestrictions();
buildCounterDriveRestrictions++;
if (buildCounterDriveRestrictions < 3) {
o.adminManagedRestrictions = true;
o.copyRequiresWriterPermission = true;
o.domainUsersOnly = true;
o.driveMembersOnly = true;
o.sharingFoldersRequiresOrganizerPermission = true;
}
buildCounterDriveRestrictions--;
return o;
}
void checkDriveRestrictions(api.DriveRestrictions o) {
buildCounterDriveRestrictions++;
if (buildCounterDriveRestrictions < 3) {
unittest.expect(o.adminManagedRestrictions!, unittest.isTrue);
unittest.expect(o.copyRequiresWriterPermission!, unittest.isTrue);
unittest.expect(o.domainUsersOnly!, unittest.isTrue);
unittest.expect(o.driveMembersOnly!, unittest.isTrue);
unittest.expect(
o.sharingFoldersRequiresOrganizerPermission!, unittest.isTrue);
}
buildCounterDriveRestrictions--;
}
core.int buildCounterDrive = 0;
api.Drive buildDrive() {
final o = api.Drive();
buildCounterDrive++;
if (buildCounterDrive < 3) {
o.backgroundImageFile = buildDriveBackgroundImageFile();
o.backgroundImageLink = 'foo';
o.capabilities = buildDriveCapabilities();
o.colorRgb = 'foo';
o.createdTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.hidden = true;
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.orgUnitId = 'foo';
o.restrictions = buildDriveRestrictions();
o.themeId = 'foo';
}
buildCounterDrive--;
return o;
}
void checkDrive(api.Drive o) {
buildCounterDrive++;
if (buildCounterDrive < 3) {
checkDriveBackgroundImageFile(o.backgroundImageFile!);
unittest.expect(
o.backgroundImageLink!,
unittest.equals('foo'),
);
checkDriveCapabilities(o.capabilities!);
unittest.expect(
o.colorRgb!,
unittest.equals('foo'),
);
unittest.expect(
o.createdTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(o.hidden!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.orgUnitId!,
unittest.equals('foo'),
);
checkDriveRestrictions(o.restrictions!);
unittest.expect(
o.themeId!,
unittest.equals('foo'),
);
}
buildCounterDrive--;
}
core.List<api.Drive> buildUnnamed12() => [
buildDrive(),
buildDrive(),
];
void checkUnnamed12(core.List<api.Drive> o) {
unittest.expect(o, unittest.hasLength(2));
checkDrive(o[0]);
checkDrive(o[1]);
}
core.int buildCounterDriveList = 0;
api.DriveList buildDriveList() {
final o = api.DriveList();
buildCounterDriveList++;
if (buildCounterDriveList < 3) {
o.drives = buildUnnamed12();
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterDriveList--;
return o;
}
void checkDriveList(api.DriveList o) {
buildCounterDriveList++;
if (buildCounterDriveList < 3) {
checkUnnamed12(o.drives!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterDriveList--;
}
core.Map<core.String, core.String?> buildUnnamed13() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed13(core.Map<core.String, core.String?> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterFileCapabilities = 0;
api.FileCapabilities buildFileCapabilities() {
final o = api.FileCapabilities();
buildCounterFileCapabilities++;
if (buildCounterFileCapabilities < 3) {
o.canAcceptOwnership = true;
o.canAddChildren = true;
o.canAddFolderFromAnotherDrive = true;
o.canAddMyDriveParent = true;
o.canChangeCopyRequiresWriterPermission = true;
o.canChangeSecurityUpdateEnabled = true;
o.canChangeViewersCanCopyContent = true;
o.canComment = true;
o.canCopy = true;
o.canDelete = true;
o.canDeleteChildren = true;
o.canDownload = true;
o.canEdit = true;
o.canListChildren = true;
o.canModifyContent = true;
o.canModifyContentRestriction = true;
o.canModifyEditorContentRestriction = true;
o.canModifyLabels = true;
o.canModifyOwnerContentRestriction = true;
o.canMoveChildrenOutOfDrive = true;
o.canMoveChildrenOutOfTeamDrive = true;
o.canMoveChildrenWithinDrive = true;
o.canMoveChildrenWithinTeamDrive = true;
o.canMoveItemIntoTeamDrive = true;
o.canMoveItemOutOfDrive = true;
o.canMoveItemOutOfTeamDrive = true;
o.canMoveItemWithinDrive = true;
o.canMoveItemWithinTeamDrive = true;
o.canMoveTeamDriveItem = true;
o.canReadDrive = true;
o.canReadLabels = true;
o.canReadRevisions = true;
o.canReadTeamDrive = true;
o.canRemoveChildren = true;
o.canRemoveContentRestriction = true;
o.canRemoveMyDriveParent = true;
o.canRename = true;
o.canShare = true;
o.canTrash = true;
o.canTrashChildren = true;
o.canUntrash = true;
}
buildCounterFileCapabilities--;
return o;
}
void checkFileCapabilities(api.FileCapabilities o) {
buildCounterFileCapabilities++;
if (buildCounterFileCapabilities < 3) {
unittest.expect(o.canAcceptOwnership!, unittest.isTrue);
unittest.expect(o.canAddChildren!, unittest.isTrue);
unittest.expect(o.canAddFolderFromAnotherDrive!, unittest.isTrue);
unittest.expect(o.canAddMyDriveParent!, unittest.isTrue);
unittest.expect(o.canChangeCopyRequiresWriterPermission!, unittest.isTrue);
unittest.expect(o.canChangeSecurityUpdateEnabled!, unittest.isTrue);
unittest.expect(o.canChangeViewersCanCopyContent!, unittest.isTrue);
unittest.expect(o.canComment!, unittest.isTrue);
unittest.expect(o.canCopy!, unittest.isTrue);
unittest.expect(o.canDelete!, unittest.isTrue);
unittest.expect(o.canDeleteChildren!, unittest.isTrue);
unittest.expect(o.canDownload!, unittest.isTrue);
unittest.expect(o.canEdit!, unittest.isTrue);
unittest.expect(o.canListChildren!, unittest.isTrue);
unittest.expect(o.canModifyContent!, unittest.isTrue);
unittest.expect(o.canModifyContentRestriction!, unittest.isTrue);
unittest.expect(o.canModifyEditorContentRestriction!, unittest.isTrue);
unittest.expect(o.canModifyLabels!, unittest.isTrue);
unittest.expect(o.canModifyOwnerContentRestriction!, unittest.isTrue);
unittest.expect(o.canMoveChildrenOutOfDrive!, unittest.isTrue);
unittest.expect(o.canMoveChildrenOutOfTeamDrive!, unittest.isTrue);
unittest.expect(o.canMoveChildrenWithinDrive!, unittest.isTrue);
unittest.expect(o.canMoveChildrenWithinTeamDrive!, unittest.isTrue);
unittest.expect(o.canMoveItemIntoTeamDrive!, unittest.isTrue);
unittest.expect(o.canMoveItemOutOfDrive!, unittest.isTrue);
unittest.expect(o.canMoveItemOutOfTeamDrive!, unittest.isTrue);
unittest.expect(o.canMoveItemWithinDrive!, unittest.isTrue);
unittest.expect(o.canMoveItemWithinTeamDrive!, unittest.isTrue);
unittest.expect(o.canMoveTeamDriveItem!, unittest.isTrue);
unittest.expect(o.canReadDrive!, unittest.isTrue);
unittest.expect(o.canReadLabels!, unittest.isTrue);
unittest.expect(o.canReadRevisions!, unittest.isTrue);
unittest.expect(o.canReadTeamDrive!, unittest.isTrue);
unittest.expect(o.canRemoveChildren!, unittest.isTrue);
unittest.expect(o.canRemoveContentRestriction!, unittest.isTrue);
unittest.expect(o.canRemoveMyDriveParent!, unittest.isTrue);
unittest.expect(o.canRename!, unittest.isTrue);
unittest.expect(o.canShare!, unittest.isTrue);
unittest.expect(o.canTrash!, unittest.isTrue);
unittest.expect(o.canTrashChildren!, unittest.isTrue);
unittest.expect(o.canUntrash!, unittest.isTrue);
}
buildCounterFileCapabilities--;
}
core.int buildCounterFileContentHintsThumbnail = 0;
api.FileContentHintsThumbnail buildFileContentHintsThumbnail() {
final o = api.FileContentHintsThumbnail();
buildCounterFileContentHintsThumbnail++;
if (buildCounterFileContentHintsThumbnail < 3) {
o.image = 'foo';
o.mimeType = 'foo';
}
buildCounterFileContentHintsThumbnail--;
return o;
}
void checkFileContentHintsThumbnail(api.FileContentHintsThumbnail o) {
buildCounterFileContentHintsThumbnail++;
if (buildCounterFileContentHintsThumbnail < 3) {
unittest.expect(
o.image!,
unittest.equals('foo'),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
}
buildCounterFileContentHintsThumbnail--;
}
core.int buildCounterFileContentHints = 0;
api.FileContentHints buildFileContentHints() {
final o = api.FileContentHints();
buildCounterFileContentHints++;
if (buildCounterFileContentHints < 3) {
o.indexableText = 'foo';
o.thumbnail = buildFileContentHintsThumbnail();
}
buildCounterFileContentHints--;
return o;
}
void checkFileContentHints(api.FileContentHints o) {
buildCounterFileContentHints++;
if (buildCounterFileContentHints < 3) {
unittest.expect(
o.indexableText!,
unittest.equals('foo'),
);
checkFileContentHintsThumbnail(o.thumbnail!);
}
buildCounterFileContentHints--;
}
core.List<api.ContentRestriction> buildUnnamed14() => [
buildContentRestriction(),
buildContentRestriction(),
];
void checkUnnamed14(core.List<api.ContentRestriction> o) {
unittest.expect(o, unittest.hasLength(2));
checkContentRestriction(o[0]);
checkContentRestriction(o[1]);
}
core.Map<core.String, core.String> buildUnnamed15() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed15(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterFileImageMediaMetadataLocation = 0;
api.FileImageMediaMetadataLocation buildFileImageMediaMetadataLocation() {
final o = api.FileImageMediaMetadataLocation();
buildCounterFileImageMediaMetadataLocation++;
if (buildCounterFileImageMediaMetadataLocation < 3) {
o.altitude = 42.0;
o.latitude = 42.0;
o.longitude = 42.0;
}
buildCounterFileImageMediaMetadataLocation--;
return o;
}
void checkFileImageMediaMetadataLocation(api.FileImageMediaMetadataLocation o) {
buildCounterFileImageMediaMetadataLocation++;
if (buildCounterFileImageMediaMetadataLocation < 3) {
unittest.expect(
o.altitude!,
unittest.equals(42.0),
);
unittest.expect(
o.latitude!,
unittest.equals(42.0),
);
unittest.expect(
o.longitude!,
unittest.equals(42.0),
);
}
buildCounterFileImageMediaMetadataLocation--;
}
core.int buildCounterFileImageMediaMetadata = 0;
api.FileImageMediaMetadata buildFileImageMediaMetadata() {
final o = api.FileImageMediaMetadata();
buildCounterFileImageMediaMetadata++;
if (buildCounterFileImageMediaMetadata < 3) {
o.aperture = 42.0;
o.cameraMake = 'foo';
o.cameraModel = 'foo';
o.colorSpace = 'foo';
o.exposureBias = 42.0;
o.exposureMode = 'foo';
o.exposureTime = 42.0;
o.flashUsed = true;
o.focalLength = 42.0;
o.height = 42;
o.isoSpeed = 42;
o.lens = 'foo';
o.location = buildFileImageMediaMetadataLocation();
o.maxApertureValue = 42.0;
o.meteringMode = 'foo';
o.rotation = 42;
o.sensor = 'foo';
o.subjectDistance = 42;
o.time = 'foo';
o.whiteBalance = 'foo';
o.width = 42;
}
buildCounterFileImageMediaMetadata--;
return o;
}
void checkFileImageMediaMetadata(api.FileImageMediaMetadata o) {
buildCounterFileImageMediaMetadata++;
if (buildCounterFileImageMediaMetadata < 3) {
unittest.expect(
o.aperture!,
unittest.equals(42.0),
);
unittest.expect(
o.cameraMake!,
unittest.equals('foo'),
);
unittest.expect(
o.cameraModel!,
unittest.equals('foo'),
);
unittest.expect(
o.colorSpace!,
unittest.equals('foo'),
);
unittest.expect(
o.exposureBias!,
unittest.equals(42.0),
);
unittest.expect(
o.exposureMode!,
unittest.equals('foo'),
);
unittest.expect(
o.exposureTime!,
unittest.equals(42.0),
);
unittest.expect(o.flashUsed!, unittest.isTrue);
unittest.expect(
o.focalLength!,
unittest.equals(42.0),
);
unittest.expect(
o.height!,
unittest.equals(42),
);
unittest.expect(
o.isoSpeed!,
unittest.equals(42),
);
unittest.expect(
o.lens!,
unittest.equals('foo'),
);
checkFileImageMediaMetadataLocation(o.location!);
unittest.expect(
o.maxApertureValue!,
unittest.equals(42.0),
);
unittest.expect(
o.meteringMode!,
unittest.equals('foo'),
);
unittest.expect(
o.rotation!,
unittest.equals(42),
);
unittest.expect(
o.sensor!,
unittest.equals('foo'),
);
unittest.expect(
o.subjectDistance!,
unittest.equals(42),
);
unittest.expect(
o.time!,
unittest.equals('foo'),
);
unittest.expect(
o.whiteBalance!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42),
);
}
buildCounterFileImageMediaMetadata--;
}
core.List<api.Label> buildUnnamed16() => [
buildLabel(),
buildLabel(),
];
void checkUnnamed16(core.List<api.Label> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabel(o[0]);
checkLabel(o[1]);
}
core.int buildCounterFileLabelInfo = 0;
api.FileLabelInfo buildFileLabelInfo() {
final o = api.FileLabelInfo();
buildCounterFileLabelInfo++;
if (buildCounterFileLabelInfo < 3) {
o.labels = buildUnnamed16();
}
buildCounterFileLabelInfo--;
return o;
}
void checkFileLabelInfo(api.FileLabelInfo o) {
buildCounterFileLabelInfo++;
if (buildCounterFileLabelInfo < 3) {
checkUnnamed16(o.labels!);
}
buildCounterFileLabelInfo--;
}
core.int buildCounterFileLinkShareMetadata = 0;
api.FileLinkShareMetadata buildFileLinkShareMetadata() {
final o = api.FileLinkShareMetadata();
buildCounterFileLinkShareMetadata++;
if (buildCounterFileLinkShareMetadata < 3) {
o.securityUpdateEligible = true;
o.securityUpdateEnabled = true;
}
buildCounterFileLinkShareMetadata--;
return o;
}
void checkFileLinkShareMetadata(api.FileLinkShareMetadata o) {
buildCounterFileLinkShareMetadata++;
if (buildCounterFileLinkShareMetadata < 3) {
unittest.expect(o.securityUpdateEligible!, unittest.isTrue);
unittest.expect(o.securityUpdateEnabled!, unittest.isTrue);
}
buildCounterFileLinkShareMetadata--;
}
core.List<api.User> buildUnnamed17() => [
buildUser(),
buildUser(),
];
void checkUnnamed17(core.List<api.User> o) {
unittest.expect(o, unittest.hasLength(2));
checkUser(o[0]);
checkUser(o[1]);
}
core.List<core.String> buildUnnamed18() => [
'foo',
'foo',
];
void checkUnnamed18(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed19() => [
'foo',
'foo',
];
void checkUnnamed19(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.Permission> buildUnnamed20() => [
buildPermission(),
buildPermission(),
];
void checkUnnamed20(core.List<api.Permission> o) {
unittest.expect(o, unittest.hasLength(2));
checkPermission(o[0]);
checkPermission(o[1]);
}
core.Map<core.String, core.String?> buildUnnamed21() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed21(core.Map<core.String, core.String?> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterFileShortcutDetails = 0;
api.FileShortcutDetails buildFileShortcutDetails() {
final o = api.FileShortcutDetails();
buildCounterFileShortcutDetails++;
if (buildCounterFileShortcutDetails < 3) {
o.targetId = 'foo';
o.targetMimeType = 'foo';
o.targetResourceKey = 'foo';
}
buildCounterFileShortcutDetails--;
return o;
}
void checkFileShortcutDetails(api.FileShortcutDetails o) {
buildCounterFileShortcutDetails++;
if (buildCounterFileShortcutDetails < 3) {
unittest.expect(
o.targetId!,
unittest.equals('foo'),
);
unittest.expect(
o.targetMimeType!,
unittest.equals('foo'),
);
unittest.expect(
o.targetResourceKey!,
unittest.equals('foo'),
);
}
buildCounterFileShortcutDetails--;
}
core.List<core.String> buildUnnamed22() => [
'foo',
'foo',
];
void checkUnnamed22(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterFileVideoMediaMetadata = 0;
api.FileVideoMediaMetadata buildFileVideoMediaMetadata() {
final o = api.FileVideoMediaMetadata();
buildCounterFileVideoMediaMetadata++;
if (buildCounterFileVideoMediaMetadata < 3) {
o.durationMillis = 'foo';
o.height = 42;
o.width = 42;
}
buildCounterFileVideoMediaMetadata--;
return o;
}
void checkFileVideoMediaMetadata(api.FileVideoMediaMetadata o) {
buildCounterFileVideoMediaMetadata++;
if (buildCounterFileVideoMediaMetadata < 3) {
unittest.expect(
o.durationMillis!,
unittest.equals('foo'),
);
unittest.expect(
o.height!,
unittest.equals(42),
);
unittest.expect(
o.width!,
unittest.equals(42),
);
}
buildCounterFileVideoMediaMetadata--;
}
core.int buildCounterFile = 0;
api.File buildFile() {
final o = api.File();
buildCounterFile++;
if (buildCounterFile < 3) {
o.appProperties = buildUnnamed13();
o.capabilities = buildFileCapabilities();
o.contentHints = buildFileContentHints();
o.contentRestrictions = buildUnnamed14();
o.copyRequiresWriterPermission = true;
o.createdTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.description = 'foo';
o.driveId = 'foo';
o.explicitlyTrashed = true;
o.exportLinks = buildUnnamed15();
o.fileExtension = 'foo';
o.folderColorRgb = 'foo';
o.fullFileExtension = 'foo';
o.hasAugmentedPermissions = true;
o.hasThumbnail = true;
o.headRevisionId = 'foo';
o.iconLink = 'foo';
o.id = 'foo';
o.imageMediaMetadata = buildFileImageMediaMetadata();
o.isAppAuthorized = true;
o.kind = 'foo';
o.labelInfo = buildFileLabelInfo();
o.lastModifyingUser = buildUser();
o.linkShareMetadata = buildFileLinkShareMetadata();
o.md5Checksum = 'foo';
o.mimeType = 'foo';
o.modifiedByMe = true;
o.modifiedByMeTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.modifiedTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.name = 'foo';
o.originalFilename = 'foo';
o.ownedByMe = true;
o.owners = buildUnnamed17();
o.parents = buildUnnamed18();
o.permissionIds = buildUnnamed19();
o.permissions = buildUnnamed20();
o.properties = buildUnnamed21();
o.quotaBytesUsed = 'foo';
o.resourceKey = 'foo';
o.sha1Checksum = 'foo';
o.sha256Checksum = 'foo';
o.shared = true;
o.sharedWithMeTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.sharingUser = buildUser();
o.shortcutDetails = buildFileShortcutDetails();
o.size = 'foo';
o.spaces = buildUnnamed22();
o.starred = true;
o.teamDriveId = 'foo';
o.thumbnailLink = 'foo';
o.thumbnailVersion = 'foo';
o.trashed = true;
o.trashedTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.trashingUser = buildUser();
o.version = 'foo';
o.videoMediaMetadata = buildFileVideoMediaMetadata();
o.viewedByMe = true;
o.viewedByMeTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.viewersCanCopyContent = true;
o.webContentLink = 'foo';
o.webViewLink = 'foo';
o.writersCanShare = true;
}
buildCounterFile--;
return o;
}
void checkFile(api.File o) {
buildCounterFile++;
if (buildCounterFile < 3) {
checkUnnamed13(o.appProperties!);
checkFileCapabilities(o.capabilities!);
checkFileContentHints(o.contentHints!);
checkUnnamed14(o.contentRestrictions!);
unittest.expect(o.copyRequiresWriterPermission!, unittest.isTrue);
unittest.expect(
o.createdTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.driveId!,
unittest.equals('foo'),
);
unittest.expect(o.explicitlyTrashed!, unittest.isTrue);
checkUnnamed15(o.exportLinks!);
unittest.expect(
o.fileExtension!,
unittest.equals('foo'),
);
unittest.expect(
o.folderColorRgb!,
unittest.equals('foo'),
);
unittest.expect(
o.fullFileExtension!,
unittest.equals('foo'),
);
unittest.expect(o.hasAugmentedPermissions!, unittest.isTrue);
unittest.expect(o.hasThumbnail!, unittest.isTrue);
unittest.expect(
o.headRevisionId!,
unittest.equals('foo'),
);
unittest.expect(
o.iconLink!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkFileImageMediaMetadata(o.imageMediaMetadata!);
unittest.expect(o.isAppAuthorized!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkFileLabelInfo(o.labelInfo!);
checkUser(o.lastModifyingUser!);
checkFileLinkShareMetadata(o.linkShareMetadata!);
unittest.expect(
o.md5Checksum!,
unittest.equals('foo'),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
unittest.expect(o.modifiedByMe!, unittest.isTrue);
unittest.expect(
o.modifiedByMeTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.modifiedTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.originalFilename!,
unittest.equals('foo'),
);
unittest.expect(o.ownedByMe!, unittest.isTrue);
checkUnnamed17(o.owners!);
checkUnnamed18(o.parents!);
checkUnnamed19(o.permissionIds!);
checkUnnamed20(o.permissions!);
checkUnnamed21(o.properties!);
unittest.expect(
o.quotaBytesUsed!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceKey!,
unittest.equals('foo'),
);
unittest.expect(
o.sha1Checksum!,
unittest.equals('foo'),
);
unittest.expect(
o.sha256Checksum!,
unittest.equals('foo'),
);
unittest.expect(o.shared!, unittest.isTrue);
unittest.expect(
o.sharedWithMeTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkUser(o.sharingUser!);
checkFileShortcutDetails(o.shortcutDetails!);
unittest.expect(
o.size!,
unittest.equals('foo'),
);
checkUnnamed22(o.spaces!);
unittest.expect(o.starred!, unittest.isTrue);
unittest.expect(
o.teamDriveId!,
unittest.equals('foo'),
);
unittest.expect(
o.thumbnailLink!,
unittest.equals('foo'),
);
unittest.expect(
o.thumbnailVersion!,
unittest.equals('foo'),
);
unittest.expect(o.trashed!, unittest.isTrue);
unittest.expect(
o.trashedTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
checkUser(o.trashingUser!);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
checkFileVideoMediaMetadata(o.videoMediaMetadata!);
unittest.expect(o.viewedByMe!, unittest.isTrue);
unittest.expect(
o.viewedByMeTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(o.viewersCanCopyContent!, unittest.isTrue);
unittest.expect(
o.webContentLink!,
unittest.equals('foo'),
);
unittest.expect(
o.webViewLink!,
unittest.equals('foo'),
);
unittest.expect(o.writersCanShare!, unittest.isTrue);
}
buildCounterFile--;
}
core.List<api.File> buildUnnamed23() => [
buildFile(),
buildFile(),
];
void checkUnnamed23(core.List<api.File> o) {
unittest.expect(o, unittest.hasLength(2));
checkFile(o[0]);
checkFile(o[1]);
}
core.int buildCounterFileList = 0;
api.FileList buildFileList() {
final o = api.FileList();
buildCounterFileList++;
if (buildCounterFileList < 3) {
o.files = buildUnnamed23();
o.incompleteSearch = true;
o.kind = 'foo';
o.nextPageToken = 'foo';
}
buildCounterFileList--;
return o;
}
void checkFileList(api.FileList o) {
buildCounterFileList++;
if (buildCounterFileList < 3) {
checkUnnamed23(o.files!);
unittest.expect(o.incompleteSearch!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterFileList--;
}
core.List<core.String> buildUnnamed24() => [
'foo',
'foo',
];
void checkUnnamed24(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterGeneratedIds = 0;
api.GeneratedIds buildGeneratedIds() {
final o = api.GeneratedIds();
buildCounterGeneratedIds++;
if (buildCounterGeneratedIds < 3) {
o.ids = buildUnnamed24();
o.kind = 'foo';
o.space = 'foo';
}
buildCounterGeneratedIds--;
return o;
}
void checkGeneratedIds(api.GeneratedIds o) {
buildCounterGeneratedIds++;
if (buildCounterGeneratedIds < 3) {
checkUnnamed24(o.ids!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.space!,
unittest.equals('foo'),
);
}
buildCounterGeneratedIds--;
}
core.Map<core.String, api.LabelField> buildUnnamed25() => {
'x': buildLabelField(),
'y': buildLabelField(),
};
void checkUnnamed25(core.Map<core.String, api.LabelField> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabelField(o['x']!);
checkLabelField(o['y']!);
}
core.int buildCounterLabel = 0;
api.Label buildLabel() {
final o = api.Label();
buildCounterLabel++;
if (buildCounterLabel < 3) {
o.fields = buildUnnamed25();
o.id = 'foo';
o.kind = 'foo';
o.revisionId = 'foo';
}
buildCounterLabel--;
return o;
}
void checkLabel(api.Label o) {
buildCounterLabel++;
if (buildCounterLabel < 3) {
checkUnnamed25(o.fields!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.revisionId!,
unittest.equals('foo'),
);
}
buildCounterLabel--;
}
core.List<core.DateTime> buildUnnamed26() => [
core.DateTime.parse('2002-02-27T14:01:02Z'),
core.DateTime.parse('2002-02-27T14:01:02Z'),
];
void checkUnnamed26(core.List<core.DateTime> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o[1],
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
core.List<core.String> buildUnnamed27() => [
'foo',
'foo',
];
void checkUnnamed27(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed28() => [
'foo',
'foo',
];
void checkUnnamed28(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed29() => [
'foo',
'foo',
];
void checkUnnamed29(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<api.User> buildUnnamed30() => [
buildUser(),
buildUser(),
];
void checkUnnamed30(core.List<api.User> o) {
unittest.expect(o, unittest.hasLength(2));
checkUser(o[0]);
checkUser(o[1]);
}
core.int buildCounterLabelField = 0;
api.LabelField buildLabelField() {
final o = api.LabelField();
buildCounterLabelField++;
if (buildCounterLabelField < 3) {
o.dateString = buildUnnamed26();
o.id = 'foo';
o.integer = buildUnnamed27();
o.kind = 'foo';
o.selection = buildUnnamed28();
o.text = buildUnnamed29();
o.user = buildUnnamed30();
o.valueType = 'foo';
}
buildCounterLabelField--;
return o;
}
void checkLabelField(api.LabelField o) {
buildCounterLabelField++;
if (buildCounterLabelField < 3) {
checkUnnamed26(o.dateString!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
checkUnnamed27(o.integer!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed28(o.selection!);
checkUnnamed29(o.text!);
checkUnnamed30(o.user!);
unittest.expect(
o.valueType!,
unittest.equals('foo'),
);
}
buildCounterLabelField--;
}
core.List<core.DateTime> buildUnnamed31() => [
core.DateTime.parse('2002-02-27T14:01:02Z'),
core.DateTime.parse('2002-02-27T14:01:02Z'),
];
void checkUnnamed31(core.List<core.DateTime> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
unittest.expect(
o[1],
unittest.equals(core.DateTime.parse('2002-02-27T00:00:00')),
);
}
core.List<core.String> buildUnnamed32() => [
'foo',
'foo',
];
void checkUnnamed32(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed33() => [
'foo',
'foo',
];
void checkUnnamed33(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed34() => [
'foo',
'foo',
];
void checkUnnamed34(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed35() => [
'foo',
'foo',
];
void checkUnnamed35(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterLabelFieldModification = 0;
api.LabelFieldModification buildLabelFieldModification() {
final o = api.LabelFieldModification();
buildCounterLabelFieldModification++;
if (buildCounterLabelFieldModification < 3) {
o.fieldId = 'foo';
o.kind = 'foo';
o.setDateValues = buildUnnamed31();
o.setIntegerValues = buildUnnamed32();
o.setSelectionValues = buildUnnamed33();
o.setTextValues = buildUnnamed34();
o.setUserValues = buildUnnamed35();
o.unsetValues = true;
}
buildCounterLabelFieldModification--;
return o;
}
void checkLabelFieldModification(api.LabelFieldModification o) {
buildCounterLabelFieldModification++;
if (buildCounterLabelFieldModification < 3) {
unittest.expect(
o.fieldId!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed31(o.setDateValues!);
checkUnnamed32(o.setIntegerValues!);
checkUnnamed33(o.setSelectionValues!);
checkUnnamed34(o.setTextValues!);
checkUnnamed35(o.setUserValues!);
unittest.expect(o.unsetValues!, unittest.isTrue);
}
buildCounterLabelFieldModification--;
}
core.List<api.Label> buildUnnamed36() => [
buildLabel(),
buildLabel(),
];
void checkUnnamed36(core.List<api.Label> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabel(o[0]);
checkLabel(o[1]);
}
core.int buildCounterLabelList = 0;
api.LabelList buildLabelList() {
final o = api.LabelList();
buildCounterLabelList++;
if (buildCounterLabelList < 3) {
o.kind = 'foo';
o.labels = buildUnnamed36();
o.nextPageToken = 'foo';
}
buildCounterLabelList--;
return o;
}
void checkLabelList(api.LabelList o) {
buildCounterLabelList++;
if (buildCounterLabelList < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed36(o.labels!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterLabelList--;
}
core.List<api.LabelFieldModification> buildUnnamed37() => [
buildLabelFieldModification(),
buildLabelFieldModification(),
];
void checkUnnamed37(core.List<api.LabelFieldModification> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabelFieldModification(o[0]);
checkLabelFieldModification(o[1]);
}
core.int buildCounterLabelModification = 0;
api.LabelModification buildLabelModification() {
final o = api.LabelModification();
buildCounterLabelModification++;
if (buildCounterLabelModification < 3) {
o.fieldModifications = buildUnnamed37();
o.kind = 'foo';
o.labelId = 'foo';
o.removeLabel = true;
}
buildCounterLabelModification--;
return o;
}
void checkLabelModification(api.LabelModification o) {
buildCounterLabelModification++;
if (buildCounterLabelModification < 3) {
checkUnnamed37(o.fieldModifications!);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.labelId!,
unittest.equals('foo'),
);
unittest.expect(o.removeLabel!, unittest.isTrue);
}
buildCounterLabelModification--;
}
core.List<api.LabelModification> buildUnnamed38() => [
buildLabelModification(),
buildLabelModification(),
];
void checkUnnamed38(core.List<api.LabelModification> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabelModification(o[0]);
checkLabelModification(o[1]);
}
core.int buildCounterModifyLabelsRequest = 0;
api.ModifyLabelsRequest buildModifyLabelsRequest() {
final o = api.ModifyLabelsRequest();
buildCounterModifyLabelsRequest++;
if (buildCounterModifyLabelsRequest < 3) {
o.kind = 'foo';
o.labelModifications = buildUnnamed38();
}
buildCounterModifyLabelsRequest--;
return o;
}
void checkModifyLabelsRequest(api.ModifyLabelsRequest o) {
buildCounterModifyLabelsRequest++;
if (buildCounterModifyLabelsRequest < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed38(o.labelModifications!);
}
buildCounterModifyLabelsRequest--;
}
core.List<api.Label> buildUnnamed39() => [
buildLabel(),
buildLabel(),
];
void checkUnnamed39(core.List<api.Label> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabel(o[0]);
checkLabel(o[1]);
}
core.int buildCounterModifyLabelsResponse = 0;
api.ModifyLabelsResponse buildModifyLabelsResponse() {
final o = api.ModifyLabelsResponse();
buildCounterModifyLabelsResponse++;
if (buildCounterModifyLabelsResponse < 3) {
o.kind = 'foo';
o.modifiedLabels = buildUnnamed39();
}
buildCounterModifyLabelsResponse--;
return o;
}
void checkModifyLabelsResponse(api.ModifyLabelsResponse o) {
buildCounterModifyLabelsResponse++;
if (buildCounterModifyLabelsResponse < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUnnamed39(o.modifiedLabels!);
}
buildCounterModifyLabelsResponse--;
}
core.int buildCounterPermissionPermissionDetails = 0;
api.PermissionPermissionDetails buildPermissionPermissionDetails() {
final o = api.PermissionPermissionDetails();
buildCounterPermissionPermissionDetails++;
if (buildCounterPermissionPermissionDetails < 3) {
o.inherited = true;
o.inheritedFrom = 'foo';
o.permissionType = 'foo';
o.role = 'foo';
}
buildCounterPermissionPermissionDetails--;
return o;
}
void checkPermissionPermissionDetails(api.PermissionPermissionDetails o) {
buildCounterPermissionPermissionDetails++;
if (buildCounterPermissionPermissionDetails < 3) {
unittest.expect(o.inherited!, unittest.isTrue);
unittest.expect(
o.inheritedFrom!,
unittest.equals('foo'),
);
unittest.expect(
o.permissionType!,
unittest.equals('foo'),
);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
}
buildCounterPermissionPermissionDetails--;
}
core.List<api.PermissionPermissionDetails> buildUnnamed40() => [
buildPermissionPermissionDetails(),
buildPermissionPermissionDetails(),
];
void checkUnnamed40(core.List<api.PermissionPermissionDetails> o) {
unittest.expect(o, unittest.hasLength(2));
checkPermissionPermissionDetails(o[0]);
checkPermissionPermissionDetails(o[1]);
}
core.int buildCounterPermissionTeamDrivePermissionDetails = 0;
api.PermissionTeamDrivePermissionDetails
buildPermissionTeamDrivePermissionDetails() {
final o = api.PermissionTeamDrivePermissionDetails();
buildCounterPermissionTeamDrivePermissionDetails++;
if (buildCounterPermissionTeamDrivePermissionDetails < 3) {
o.inherited = true;
o.inheritedFrom = 'foo';
o.role = 'foo';
o.teamDrivePermissionType = 'foo';
}
buildCounterPermissionTeamDrivePermissionDetails--;
return o;
}
void checkPermissionTeamDrivePermissionDetails(
api.PermissionTeamDrivePermissionDetails o) {
buildCounterPermissionTeamDrivePermissionDetails++;
if (buildCounterPermissionTeamDrivePermissionDetails < 3) {
unittest.expect(o.inherited!, unittest.isTrue);
unittest.expect(
o.inheritedFrom!,
unittest.equals('foo'),
);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
unittest.expect(
o.teamDrivePermissionType!,
unittest.equals('foo'),
);
}
buildCounterPermissionTeamDrivePermissionDetails--;
}
core.List<api.PermissionTeamDrivePermissionDetails> buildUnnamed41() => [
buildPermissionTeamDrivePermissionDetails(),
buildPermissionTeamDrivePermissionDetails(),
];
void checkUnnamed41(core.List<api.PermissionTeamDrivePermissionDetails> o) {
unittest.expect(o, unittest.hasLength(2));
checkPermissionTeamDrivePermissionDetails(o[0]);
checkPermissionTeamDrivePermissionDetails(o[1]);
}
core.int buildCounterPermission = 0;
api.Permission buildPermission() {
final o = api.Permission();
buildCounterPermission++;
if (buildCounterPermission < 3) {
o.allowFileDiscovery = true;
o.deleted = true;
o.displayName = 'foo';
o.domain = 'foo';
o.emailAddress = 'foo';
o.expirationTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.id = 'foo';
o.kind = 'foo';
o.pendingOwner = true;
o.permissionDetails = buildUnnamed40();
o.photoLink = 'foo';
o.role = 'foo';
o.teamDrivePermissionDetails = buildUnnamed41();
o.type = 'foo';
o.view = 'foo';
}
buildCounterPermission--;
return o;
}
void checkPermission(api.Permission o) {
buildCounterPermission++;
if (buildCounterPermission < 3) {
unittest.expect(o.allowFileDiscovery!, unittest.isTrue);
unittest.expect(o.deleted!, unittest.isTrue);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.domain!,
unittest.equals('foo'),
);
unittest.expect(
o.emailAddress!,
unittest.equals('foo'),
);
unittest.expect(
o.expirationTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.pendingOwner!, unittest.isTrue);
checkUnnamed40(o.permissionDetails!);
unittest.expect(
o.photoLink!,
unittest.equals('foo'),
);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
checkUnnamed41(o.teamDrivePermissionDetails!);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.view!,
unittest.equals('foo'),
);
}
buildCounterPermission--;
}
core.List<api.Permission> buildUnnamed42() => [
buildPermission(),
buildPermission(),
];
void checkUnnamed42(core.List<api.Permission> o) {
unittest.expect(o, unittest.hasLength(2));
checkPermission(o[0]);
checkPermission(o[1]);
}
core.int buildCounterPermissionList = 0;
api.PermissionList buildPermissionList() {
final o = api.PermissionList();
buildCounterPermissionList++;
if (buildCounterPermissionList < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.permissions = buildUnnamed42();
}
buildCounterPermissionList--;
return o;
}
void checkPermissionList(api.PermissionList o) {
buildCounterPermissionList++;
if (buildCounterPermissionList < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed42(o.permissions!);
}
buildCounterPermissionList--;
}
core.int buildCounterReply = 0;
api.Reply buildReply() {
final o = api.Reply();
buildCounterReply++;
if (buildCounterReply < 3) {
o.action = 'foo';
o.author = buildUser();
o.content = 'foo';
o.createdTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.deleted = true;
o.htmlContent = 'foo';
o.id = 'foo';
o.kind = 'foo';
o.modifiedTime = core.DateTime.parse('2002-02-27T14:01:02Z');
}
buildCounterReply--;
return o;
}
void checkReply(api.Reply o) {
buildCounterReply++;
if (buildCounterReply < 3) {
unittest.expect(
o.action!,
unittest.equals('foo'),
);
checkUser(o.author!);
unittest.expect(
o.content!,
unittest.equals('foo'),
);
unittest.expect(
o.createdTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(o.deleted!, unittest.isTrue);
unittest.expect(
o.htmlContent!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.modifiedTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
}
buildCounterReply--;
}
core.List<api.Reply> buildUnnamed43() => [
buildReply(),
buildReply(),
];
void checkUnnamed43(core.List<api.Reply> o) {
unittest.expect(o, unittest.hasLength(2));
checkReply(o[0]);
checkReply(o[1]);
}
core.int buildCounterReplyList = 0;
api.ReplyList buildReplyList() {
final o = api.ReplyList();
buildCounterReplyList++;
if (buildCounterReplyList < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.replies = buildUnnamed43();
}
buildCounterReplyList--;
return o;
}
void checkReplyList(api.ReplyList o) {
buildCounterReplyList++;
if (buildCounterReplyList < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed43(o.replies!);
}
buildCounterReplyList--;
}
core.Map<core.String, core.String> buildUnnamed44() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed44(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterRevision = 0;
api.Revision buildRevision() {
final o = api.Revision();
buildCounterRevision++;
if (buildCounterRevision < 3) {
o.exportLinks = buildUnnamed44();
o.id = 'foo';
o.keepForever = true;
o.kind = 'foo';
o.lastModifyingUser = buildUser();
o.md5Checksum = 'foo';
o.mimeType = 'foo';
o.modifiedTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.originalFilename = 'foo';
o.publishAuto = true;
o.published = true;
o.publishedLink = 'foo';
o.publishedOutsideDomain = true;
o.size = 'foo';
}
buildCounterRevision--;
return o;
}
void checkRevision(api.Revision o) {
buildCounterRevision++;
if (buildCounterRevision < 3) {
checkUnnamed44(o.exportLinks!);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.keepForever!, unittest.isTrue);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
checkUser(o.lastModifyingUser!);
unittest.expect(
o.md5Checksum!,
unittest.equals('foo'),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
unittest.expect(
o.modifiedTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.originalFilename!,
unittest.equals('foo'),
);
unittest.expect(o.publishAuto!, unittest.isTrue);
unittest.expect(o.published!, unittest.isTrue);
unittest.expect(
o.publishedLink!,
unittest.equals('foo'),
);
unittest.expect(o.publishedOutsideDomain!, unittest.isTrue);
unittest.expect(
o.size!,
unittest.equals('foo'),
);
}
buildCounterRevision--;
}
core.List<api.Revision> buildUnnamed45() => [
buildRevision(),
buildRevision(),
];
void checkUnnamed45(core.List<api.Revision> o) {
unittest.expect(o, unittest.hasLength(2));
checkRevision(o[0]);
checkRevision(o[1]);
}
core.int buildCounterRevisionList = 0;
api.RevisionList buildRevisionList() {
final o = api.RevisionList();
buildCounterRevisionList++;
if (buildCounterRevisionList < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.revisions = buildUnnamed45();
}
buildCounterRevisionList--;
return o;
}
void checkRevisionList(api.RevisionList o) {
buildCounterRevisionList++;
if (buildCounterRevisionList < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed45(o.revisions!);
}
buildCounterRevisionList--;
}
core.int buildCounterStartPageToken = 0;
api.StartPageToken buildStartPageToken() {
final o = api.StartPageToken();
buildCounterStartPageToken++;
if (buildCounterStartPageToken < 3) {
o.kind = 'foo';
o.startPageToken = 'foo';
}
buildCounterStartPageToken--;
return o;
}
void checkStartPageToken(api.StartPageToken o) {
buildCounterStartPageToken++;
if (buildCounterStartPageToken < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.startPageToken!,
unittest.equals('foo'),
);
}
buildCounterStartPageToken--;
}
core.int buildCounterTeamDriveBackgroundImageFile = 0;
api.TeamDriveBackgroundImageFile buildTeamDriveBackgroundImageFile() {
final o = api.TeamDriveBackgroundImageFile();
buildCounterTeamDriveBackgroundImageFile++;
if (buildCounterTeamDriveBackgroundImageFile < 3) {
o.id = 'foo';
o.width = 42.0;
o.xCoordinate = 42.0;
o.yCoordinate = 42.0;
}
buildCounterTeamDriveBackgroundImageFile--;
return o;
}
void checkTeamDriveBackgroundImageFile(api.TeamDriveBackgroundImageFile o) {
buildCounterTeamDriveBackgroundImageFile++;
if (buildCounterTeamDriveBackgroundImageFile < 3) {
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42.0),
);
unittest.expect(
o.xCoordinate!,
unittest.equals(42.0),
);
unittest.expect(
o.yCoordinate!,
unittest.equals(42.0),
);
}
buildCounterTeamDriveBackgroundImageFile--;
}
core.int buildCounterTeamDriveCapabilities = 0;
api.TeamDriveCapabilities buildTeamDriveCapabilities() {
final o = api.TeamDriveCapabilities();
buildCounterTeamDriveCapabilities++;
if (buildCounterTeamDriveCapabilities < 3) {
o.canAddChildren = true;
o.canChangeCopyRequiresWriterPermissionRestriction = true;
o.canChangeDomainUsersOnlyRestriction = true;
o.canChangeSharingFoldersRequiresOrganizerPermissionRestriction = true;
o.canChangeTeamDriveBackground = true;
o.canChangeTeamMembersOnlyRestriction = true;
o.canComment = true;
o.canCopy = true;
o.canDeleteChildren = true;
o.canDeleteTeamDrive = true;
o.canDownload = true;
o.canEdit = true;
o.canListChildren = true;
o.canManageMembers = true;
o.canReadRevisions = true;
o.canRemoveChildren = true;
o.canRename = true;
o.canRenameTeamDrive = true;
o.canResetTeamDriveRestrictions = true;
o.canShare = true;
o.canTrashChildren = true;
}
buildCounterTeamDriveCapabilities--;
return o;
}
void checkTeamDriveCapabilities(api.TeamDriveCapabilities o) {
buildCounterTeamDriveCapabilities++;
if (buildCounterTeamDriveCapabilities < 3) {
unittest.expect(o.canAddChildren!, unittest.isTrue);
unittest.expect(
o.canChangeCopyRequiresWriterPermissionRestriction!, unittest.isTrue);
unittest.expect(o.canChangeDomainUsersOnlyRestriction!, unittest.isTrue);
unittest.expect(
o.canChangeSharingFoldersRequiresOrganizerPermissionRestriction!,
unittest.isTrue);
unittest.expect(o.canChangeTeamDriveBackground!, unittest.isTrue);
unittest.expect(o.canChangeTeamMembersOnlyRestriction!, unittest.isTrue);
unittest.expect(o.canComment!, unittest.isTrue);
unittest.expect(o.canCopy!, unittest.isTrue);
unittest.expect(o.canDeleteChildren!, unittest.isTrue);
unittest.expect(o.canDeleteTeamDrive!, unittest.isTrue);
unittest.expect(o.canDownload!, unittest.isTrue);
unittest.expect(o.canEdit!, unittest.isTrue);
unittest.expect(o.canListChildren!, unittest.isTrue);
unittest.expect(o.canManageMembers!, unittest.isTrue);
unittest.expect(o.canReadRevisions!, unittest.isTrue);
unittest.expect(o.canRemoveChildren!, unittest.isTrue);
unittest.expect(o.canRename!, unittest.isTrue);
unittest.expect(o.canRenameTeamDrive!, unittest.isTrue);
unittest.expect(o.canResetTeamDriveRestrictions!, unittest.isTrue);
unittest.expect(o.canShare!, unittest.isTrue);
unittest.expect(o.canTrashChildren!, unittest.isTrue);
}
buildCounterTeamDriveCapabilities--;
}
core.int buildCounterTeamDriveRestrictions = 0;
api.TeamDriveRestrictions buildTeamDriveRestrictions() {
final o = api.TeamDriveRestrictions();
buildCounterTeamDriveRestrictions++;
if (buildCounterTeamDriveRestrictions < 3) {
o.adminManagedRestrictions = true;
o.copyRequiresWriterPermission = true;
o.domainUsersOnly = true;
o.sharingFoldersRequiresOrganizerPermission = true;
o.teamMembersOnly = true;
}
buildCounterTeamDriveRestrictions--;
return o;
}
void checkTeamDriveRestrictions(api.TeamDriveRestrictions o) {
buildCounterTeamDriveRestrictions++;
if (buildCounterTeamDriveRestrictions < 3) {
unittest.expect(o.adminManagedRestrictions!, unittest.isTrue);
unittest.expect(o.copyRequiresWriterPermission!, unittest.isTrue);
unittest.expect(o.domainUsersOnly!, unittest.isTrue);
unittest.expect(
o.sharingFoldersRequiresOrganizerPermission!, unittest.isTrue);
unittest.expect(o.teamMembersOnly!, unittest.isTrue);
}
buildCounterTeamDriveRestrictions--;
}
core.int buildCounterTeamDrive = 0;
api.TeamDrive buildTeamDrive() {
final o = api.TeamDrive();
buildCounterTeamDrive++;
if (buildCounterTeamDrive < 3) {
o.backgroundImageFile = buildTeamDriveBackgroundImageFile();
o.backgroundImageLink = 'foo';
o.capabilities = buildTeamDriveCapabilities();
o.colorRgb = 'foo';
o.createdTime = core.DateTime.parse('2002-02-27T14:01:02Z');
o.id = 'foo';
o.kind = 'foo';
o.name = 'foo';
o.orgUnitId = 'foo';
o.restrictions = buildTeamDriveRestrictions();
o.themeId = 'foo';
}
buildCounterTeamDrive--;
return o;
}
void checkTeamDrive(api.TeamDrive o) {
buildCounterTeamDrive++;
if (buildCounterTeamDrive < 3) {
checkTeamDriveBackgroundImageFile(o.backgroundImageFile!);
unittest.expect(
o.backgroundImageLink!,
unittest.equals('foo'),
);
checkTeamDriveCapabilities(o.capabilities!);
unittest.expect(
o.colorRgb!,
unittest.equals('foo'),
);
unittest.expect(
o.createdTime!,
unittest.equals(core.DateTime.parse('2002-02-27T14:01:02Z')),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.orgUnitId!,
unittest.equals('foo'),
);
checkTeamDriveRestrictions(o.restrictions!);
unittest.expect(
o.themeId!,
unittest.equals('foo'),
);
}
buildCounterTeamDrive--;
}
core.List<api.TeamDrive> buildUnnamed46() => [
buildTeamDrive(),
buildTeamDrive(),
];
void checkUnnamed46(core.List<api.TeamDrive> o) {
unittest.expect(o, unittest.hasLength(2));
checkTeamDrive(o[0]);
checkTeamDrive(o[1]);
}
core.int buildCounterTeamDriveList = 0;
api.TeamDriveList buildTeamDriveList() {
final o = api.TeamDriveList();
buildCounterTeamDriveList++;
if (buildCounterTeamDriveList < 3) {
o.kind = 'foo';
o.nextPageToken = 'foo';
o.teamDrives = buildUnnamed46();
}
buildCounterTeamDriveList--;
return o;
}
void checkTeamDriveList(api.TeamDriveList o) {
buildCounterTeamDriveList++;
if (buildCounterTeamDriveList < 3) {
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed46(o.teamDrives!);
}
buildCounterTeamDriveList--;
}
core.int buildCounterUser = 0;
api.User buildUser() {
final o = api.User();
buildCounterUser++;
if (buildCounterUser < 3) {
o.displayName = 'foo';
o.emailAddress = 'foo';
o.kind = 'foo';
o.me = true;
o.permissionId = 'foo';
o.photoLink = 'foo';
}
buildCounterUser--;
return o;
}
void checkUser(api.User o) {
buildCounterUser++;
if (buildCounterUser < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.emailAddress!,
unittest.equals('foo'),
);
unittest.expect(
o.kind!,
unittest.equals('foo'),
);
unittest.expect(o.me!, unittest.isTrue);
unittest.expect(
o.permissionId!,
unittest.equals('foo'),
);
unittest.expect(
o.photoLink!,
unittest.equals('foo'),
);
}
buildCounterUser--;
}
void main() {
unittest.group('obj-schema-AboutDriveThemes', () {
unittest.test('to-json--from-json', () async {
final o = buildAboutDriveThemes();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AboutDriveThemes.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAboutDriveThemes(od);
});
});
unittest.group('obj-schema-AboutStorageQuota', () {
unittest.test('to-json--from-json', () async {
final o = buildAboutStorageQuota();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AboutStorageQuota.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAboutStorageQuota(od);
});
});
unittest.group('obj-schema-AboutTeamDriveThemes', () {
unittest.test('to-json--from-json', () async {
final o = buildAboutTeamDriveThemes();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AboutTeamDriveThemes.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAboutTeamDriveThemes(od);
});
});
unittest.group('obj-schema-About', () {
unittest.test('to-json--from-json', () async {
final o = buildAbout();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.About.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAbout(od);
});
});
unittest.group('obj-schema-Change', () {
unittest.test('to-json--from-json', () async {
final o = buildChange();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Change.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkChange(od);
});
});
unittest.group('obj-schema-ChangeList', () {
unittest.test('to-json--from-json', () async {
final o = buildChangeList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ChangeList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkChangeList(od);
});
});
unittest.group('obj-schema-Channel', () {
unittest.test('to-json--from-json', () async {
final o = buildChannel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Channel.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkChannel(od);
});
});
unittest.group('obj-schema-CommentQuotedFileContent', () {
unittest.test('to-json--from-json', () async {
final o = buildCommentQuotedFileContent();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CommentQuotedFileContent.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCommentQuotedFileContent(od);
});
});
unittest.group('obj-schema-Comment', () {
unittest.test('to-json--from-json', () async {
final o = buildComment();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Comment.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkComment(od);
});
});
unittest.group('obj-schema-CommentList', () {
unittest.test('to-json--from-json', () async {
final o = buildCommentList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CommentList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCommentList(od);
});
});
unittest.group('obj-schema-ContentRestriction', () {
unittest.test('to-json--from-json', () async {
final o = buildContentRestriction();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ContentRestriction.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkContentRestriction(od);
});
});
unittest.group('obj-schema-DriveBackgroundImageFile', () {
unittest.test('to-json--from-json', () async {
final o = buildDriveBackgroundImageFile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DriveBackgroundImageFile.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDriveBackgroundImageFile(od);
});
});
unittest.group('obj-schema-DriveCapabilities', () {
unittest.test('to-json--from-json', () async {
final o = buildDriveCapabilities();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DriveCapabilities.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDriveCapabilities(od);
});
});
unittest.group('obj-schema-DriveRestrictions', () {
unittest.test('to-json--from-json', () async {
final o = buildDriveRestrictions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DriveRestrictions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDriveRestrictions(od);
});
});
unittest.group('obj-schema-Drive', () {
unittest.test('to-json--from-json', () async {
final o = buildDrive();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Drive.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDrive(od);
});
});
unittest.group('obj-schema-DriveList', () {
unittest.test('to-json--from-json', () async {
final o = buildDriveList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.DriveList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDriveList(od);
});
});
unittest.group('obj-schema-FileCapabilities', () {
unittest.test('to-json--from-json', () async {
final o = buildFileCapabilities();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileCapabilities.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileCapabilities(od);
});
});
unittest.group('obj-schema-FileContentHintsThumbnail', () {
unittest.test('to-json--from-json', () async {
final o = buildFileContentHintsThumbnail();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileContentHintsThumbnail.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileContentHintsThumbnail(od);
});
});
unittest.group('obj-schema-FileContentHints', () {
unittest.test('to-json--from-json', () async {
final o = buildFileContentHints();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileContentHints.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileContentHints(od);
});
});
unittest.group('obj-schema-FileImageMediaMetadataLocation', () {
unittest.test('to-json--from-json', () async {
final o = buildFileImageMediaMetadataLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileImageMediaMetadataLocation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileImageMediaMetadataLocation(od);
});
});
unittest.group('obj-schema-FileImageMediaMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildFileImageMediaMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileImageMediaMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileImageMediaMetadata(od);
});
});
unittest.group('obj-schema-FileLabelInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildFileLabelInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileLabelInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileLabelInfo(od);
});
});
unittest.group('obj-schema-FileLinkShareMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildFileLinkShareMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileLinkShareMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileLinkShareMetadata(od);
});
});
unittest.group('obj-schema-FileShortcutDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildFileShortcutDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileShortcutDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileShortcutDetails(od);
});
});
unittest.group('obj-schema-FileVideoMediaMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildFileVideoMediaMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileVideoMediaMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileVideoMediaMetadata(od);
});
});
unittest.group('obj-schema-File', () {
unittest.test('to-json--from-json', () async {
final o = buildFile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.File.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFile(od);
});
});
unittest.group('obj-schema-FileList', () {
unittest.test('to-json--from-json', () async {
final o = buildFileList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.FileList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFileList(od);
});
});
unittest.group('obj-schema-GeneratedIds', () {
unittest.test('to-json--from-json', () async {
final o = buildGeneratedIds();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GeneratedIds.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGeneratedIds(od);
});
});
unittest.group('obj-schema-Label', () {
unittest.test('to-json--from-json', () async {
final o = buildLabel();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Label.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLabel(od);
});
});
unittest.group('obj-schema-LabelField', () {
unittest.test('to-json--from-json', () async {
final o = buildLabelField();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LabelField.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLabelField(od);
});
});
unittest.group('obj-schema-LabelFieldModification', () {
unittest.test('to-json--from-json', () async {
final o = buildLabelFieldModification();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LabelFieldModification.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLabelFieldModification(od);
});
});
unittest.group('obj-schema-LabelList', () {
unittest.test('to-json--from-json', () async {
final o = buildLabelList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LabelList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLabelList(od);
});
});
unittest.group('obj-schema-LabelModification', () {
unittest.test('to-json--from-json', () async {
final o = buildLabelModification();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LabelModification.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLabelModification(od);
});
});
unittest.group('obj-schema-ModifyLabelsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildModifyLabelsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ModifyLabelsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkModifyLabelsRequest(od);
});
});
unittest.group('obj-schema-ModifyLabelsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildModifyLabelsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ModifyLabelsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkModifyLabelsResponse(od);
});
});
unittest.group('obj-schema-PermissionPermissionDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildPermissionPermissionDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PermissionPermissionDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPermissionPermissionDetails(od);
});
});
unittest.group('obj-schema-PermissionTeamDrivePermissionDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildPermissionTeamDrivePermissionDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PermissionTeamDrivePermissionDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPermissionTeamDrivePermissionDetails(od);
});
});
unittest.group('obj-schema-Permission', () {
unittest.test('to-json--from-json', () async {
final o = buildPermission();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Permission.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPermission(od);
});
});
unittest.group('obj-schema-PermissionList', () {
unittest.test('to-json--from-json', () async {
final o = buildPermissionList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PermissionList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPermissionList(od);
});
});
unittest.group('obj-schema-Reply', () {
unittest.test('to-json--from-json', () async {
final o = buildReply();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Reply.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkReply(od);
});
});
unittest.group('obj-schema-ReplyList', () {
unittest.test('to-json--from-json', () async {
final o = buildReplyList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ReplyList.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkReplyList(od);
});
});
unittest.group('obj-schema-Revision', () {
unittest.test('to-json--from-json', () async {
final o = buildRevision();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Revision.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRevision(od);
});
});
unittest.group('obj-schema-RevisionList', () {
unittest.test('to-json--from-json', () async {
final o = buildRevisionList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RevisionList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRevisionList(od);
});
});
unittest.group('obj-schema-StartPageToken', () {
unittest.test('to-json--from-json', () async {
final o = buildStartPageToken();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.StartPageToken.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkStartPageToken(od);
});
});
unittest.group('obj-schema-TeamDriveBackgroundImageFile', () {
unittest.test('to-json--from-json', () async {
final o = buildTeamDriveBackgroundImageFile();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TeamDriveBackgroundImageFile.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTeamDriveBackgroundImageFile(od);
});
});
unittest.group('obj-schema-TeamDriveCapabilities', () {
unittest.test('to-json--from-json', () async {
final o = buildTeamDriveCapabilities();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TeamDriveCapabilities.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTeamDriveCapabilities(od);
});
});
unittest.group('obj-schema-TeamDriveRestrictions', () {
unittest.test('to-json--from-json', () async {
final o = buildTeamDriveRestrictions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TeamDriveRestrictions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTeamDriveRestrictions(od);
});
});
unittest.group('obj-schema-TeamDrive', () {
unittest.test('to-json--from-json', () async {
final o = buildTeamDrive();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TeamDrive.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTeamDrive(od);
});
});
unittest.group('obj-schema-TeamDriveList', () {
unittest.test('to-json--from-json', () async {
final o = buildTeamDriveList();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TeamDriveList.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTeamDriveList(od);
});
});
unittest.group('obj-schema-User', () {
unittest.test('to-json--from-json', () async {
final o = buildUser();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.User.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkUser(od);
});
});
unittest.group('resource-AboutResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).about;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('about'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildAbout());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get($fields: arg_$fields);
checkAbout(response as api.About);
});
});
unittest.group('resource-ChangesResource', () {
unittest.test('method--getStartPageToken', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).changes;
final arg_driveId = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_teamDriveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 22),
unittest.equals('changes/startPageToken'),
);
pathOffset += 22;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['driveId']!.first,
unittest.equals(arg_driveId),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['teamDriveId']!.first,
unittest.equals(arg_teamDriveId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildStartPageToken());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getStartPageToken(
driveId: arg_driveId,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
teamDriveId: arg_teamDriveId,
$fields: arg_$fields);
checkStartPageToken(response as api.StartPageToken);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).changes;
final arg_pageToken = 'foo';
final arg_driveId = 'foo';
final arg_includeCorpusRemovals = true;
final arg_includeItemsFromAllDrives = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_includeRemoved = true;
final arg_includeTeamDriveItems = true;
final arg_pageSize = 42;
final arg_restrictToMyDrive = true;
final arg_spaces = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_teamDriveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('changes'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['driveId']!.first,
unittest.equals(arg_driveId),
);
unittest.expect(
queryMap['includeCorpusRemovals']!.first,
unittest.equals('$arg_includeCorpusRemovals'),
);
unittest.expect(
queryMap['includeItemsFromAllDrives']!.first,
unittest.equals('$arg_includeItemsFromAllDrives'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['includeRemoved']!.first,
unittest.equals('$arg_includeRemoved'),
);
unittest.expect(
queryMap['includeTeamDriveItems']!.first,
unittest.equals('$arg_includeTeamDriveItems'),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['restrictToMyDrive']!.first,
unittest.equals('$arg_restrictToMyDrive'),
);
unittest.expect(
queryMap['spaces']!.first,
unittest.equals(arg_spaces),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['teamDriveId']!.first,
unittest.equals(arg_teamDriveId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChangeList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_pageToken,
driveId: arg_driveId,
includeCorpusRemovals: arg_includeCorpusRemovals,
includeItemsFromAllDrives: arg_includeItemsFromAllDrives,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
includeRemoved: arg_includeRemoved,
includeTeamDriveItems: arg_includeTeamDriveItems,
pageSize: arg_pageSize,
restrictToMyDrive: arg_restrictToMyDrive,
spaces: arg_spaces,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
teamDriveId: arg_teamDriveId,
$fields: arg_$fields);
checkChangeList(response as api.ChangeList);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).changes;
final arg_request = buildChannel();
final arg_pageToken = 'foo';
final arg_driveId = 'foo';
final arg_includeCorpusRemovals = true;
final arg_includeItemsFromAllDrives = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_includeRemoved = true;
final arg_includeTeamDriveItems = true;
final arg_pageSize = 42;
final arg_restrictToMyDrive = true;
final arg_spaces = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_teamDriveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('changes/watch'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['driveId']!.first,
unittest.equals(arg_driveId),
);
unittest.expect(
queryMap['includeCorpusRemovals']!.first,
unittest.equals('$arg_includeCorpusRemovals'),
);
unittest.expect(
queryMap['includeItemsFromAllDrives']!.first,
unittest.equals('$arg_includeItemsFromAllDrives'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['includeRemoved']!.first,
unittest.equals('$arg_includeRemoved'),
);
unittest.expect(
queryMap['includeTeamDriveItems']!.first,
unittest.equals('$arg_includeTeamDriveItems'),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['restrictToMyDrive']!.first,
unittest.equals('$arg_restrictToMyDrive'),
);
unittest.expect(
queryMap['spaces']!.first,
unittest.equals(arg_spaces),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['teamDriveId']!.first,
unittest.equals(arg_teamDriveId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request, arg_pageToken,
driveId: arg_driveId,
includeCorpusRemovals: arg_includeCorpusRemovals,
includeItemsFromAllDrives: arg_includeItemsFromAllDrives,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
includeRemoved: arg_includeRemoved,
includeTeamDriveItems: arg_includeTeamDriveItems,
pageSize: arg_pageSize,
restrictToMyDrive: arg_restrictToMyDrive,
spaces: arg_spaces,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
teamDriveId: arg_teamDriveId,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
unittest.group('resource-ChannelsResource', () {
unittest.test('method--stop', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).channels;
final arg_request = buildChannel();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('channels/stop'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.stop(arg_request, $fields: arg_$fields);
});
});
unittest.group('resource-CommentsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).comments;
final arg_request = buildComment();
final arg_fileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Comment.fromJson(json as core.Map<core.String, core.dynamic>);
checkComment(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/comments'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildComment());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_fileId, $fields: arg_$fields);
checkComment(response as api.Comment);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).comments;
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_fileId, arg_commentId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).comments;
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_includeDeleted = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['includeDeleted']!.first,
unittest.equals('$arg_includeDeleted'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildComment());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_fileId, arg_commentId,
includeDeleted: arg_includeDeleted, $fields: arg_$fields);
checkComment(response as api.Comment);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).comments;
final arg_fileId = 'foo';
final arg_includeDeleted = true;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_startModifiedTime = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/comments'),
);
pathOffset += 9;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['includeDeleted']!.first,
unittest.equals('$arg_includeDeleted'),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['startModifiedTime']!.first,
unittest.equals(arg_startModifiedTime),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCommentList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_fileId,
includeDeleted: arg_includeDeleted,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
startModifiedTime: arg_startModifiedTime,
$fields: arg_$fields);
checkCommentList(response as api.CommentList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).comments;
final arg_request = buildComment();
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Comment.fromJson(json as core.Map<core.String, core.dynamic>);
checkComment(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildComment());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_fileId, arg_commentId,
$fields: arg_$fields);
checkComment(response as api.Comment);
});
});
unittest.group('resource-DrivesResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_request = buildDrive();
final arg_requestId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Drive.fromJson(json as core.Map<core.String, core.dynamic>);
checkDrive(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('drives'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['requestId']!.first,
unittest.equals(arg_requestId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_requestId, $fields: arg_$fields);
checkDrive(response as api.Drive);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_driveId = 'foo';
final arg_allowItemDeletion = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('drives/'),
);
pathOffset += 7;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_driveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['allowItemDeletion']!.first,
unittest.equals('$arg_allowItemDeletion'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_driveId,
allowItemDeletion: arg_allowItemDeletion,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_driveId = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('drives/'),
);
pathOffset += 7;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_driveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_driveId,
useDomainAdminAccess: arg_useDomainAdminAccess, $fields: arg_$fields);
checkDrive(response as api.Drive);
});
unittest.test('method--hide', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_driveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('drives/'),
);
pathOffset += 7;
index = path.indexOf('/hide', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_driveId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/hide'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.hide(arg_driveId, $fields: arg_$fields);
checkDrive(response as api.Drive);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_q = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('drives'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['q']!.first,
unittest.equals(arg_q),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDriveList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
pageSize: arg_pageSize,
pageToken: arg_pageToken,
q: arg_q,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkDriveList(response as api.DriveList);
});
unittest.test('method--unhide', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_driveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('drives/'),
);
pathOffset += 7;
index = path.indexOf('/unhide', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_driveId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/unhide'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.unhide(arg_driveId, $fields: arg_$fields);
checkDrive(response as api.Drive);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).drives;
final arg_request = buildDrive();
final arg_driveId = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Drive.fromJson(json as core.Map<core.String, core.dynamic>);
checkDrive(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('drives/'),
);
pathOffset += 7;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_driveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_driveId,
useDomainAdminAccess: arg_useDomainAdminAccess, $fields: arg_$fields);
checkDrive(response as api.Drive);
});
});
unittest.group('resource-FilesResource', () {
unittest.test('method--copy', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_request = buildFile();
final arg_fileId = 'foo';
final arg_enforceSingleParent = true;
final arg_ignoreDefaultVisibility = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_keepRevisionForever = true;
final arg_ocrLanguage = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.File.fromJson(json as core.Map<core.String, core.dynamic>);
checkFile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/copy', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('/copy'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['ignoreDefaultVisibility']!.first,
unittest.equals('$arg_ignoreDefaultVisibility'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['keepRevisionForever']!.first,
unittest.equals('$arg_keepRevisionForever'),
);
unittest.expect(
queryMap['ocrLanguage']!.first,
unittest.equals(arg_ocrLanguage),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.copy(arg_request, arg_fileId,
enforceSingleParent: arg_enforceSingleParent,
ignoreDefaultVisibility: arg_ignoreDefaultVisibility,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
keepRevisionForever: arg_keepRevisionForever,
ocrLanguage: arg_ocrLanguage,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
$fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--create', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_request = buildFile();
final arg_enforceSingleParent = true;
final arg_ignoreDefaultVisibility = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_keepRevisionForever = true;
final arg_ocrLanguage = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_useContentAsIndexableText = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.File.fromJson(json as core.Map<core.String, core.dynamic>);
checkFile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('files'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['ignoreDefaultVisibility']!.first,
unittest.equals('$arg_ignoreDefaultVisibility'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['keepRevisionForever']!.first,
unittest.equals('$arg_keepRevisionForever'),
);
unittest.expect(
queryMap['ocrLanguage']!.first,
unittest.equals(arg_ocrLanguage),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['useContentAsIndexableText']!.first,
unittest.equals('$arg_useContentAsIndexableText'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request,
enforceSingleParent: arg_enforceSingleParent,
ignoreDefaultVisibility: arg_ignoreDefaultVisibility,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
keepRevisionForever: arg_keepRevisionForever,
ocrLanguage: arg_ocrLanguage,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
useContentAsIndexableText: arg_useContentAsIndexableText,
$fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_fileId = 'foo';
final arg_enforceSingleParent = true;
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_fileId,
enforceSingleParent: arg_enforceSingleParent,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
$fields: arg_$fields);
});
unittest.test('method--emptyTrash', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_driveId = 'foo';
final arg_enforceSingleParent = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('files/trash'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['driveId']!.first,
unittest.equals(arg_driveId),
);
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.emptyTrash(
driveId: arg_driveId,
enforceSingleParent: arg_enforceSingleParent,
$fields: arg_$fields);
});
unittest.test('method--export', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_fileId = 'foo';
final arg_mimeType = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/export', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 7),
unittest.equals('/export'),
);
pathOffset += 7;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['mimeType']!.first,
unittest.equals(arg_mimeType),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.export(arg_fileId, arg_mimeType, $fields: arg_$fields);
});
unittest.test('method--generateIds', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_count = 42;
final arg_space = 'foo';
final arg_type = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 17),
unittest.equals('files/generateIds'),
);
pathOffset += 17;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['count']!.first),
unittest.equals(arg_count),
);
unittest.expect(
queryMap['space']!.first,
unittest.equals(arg_space),
);
unittest.expect(
queryMap['type']!.first,
unittest.equals(arg_type),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGeneratedIds());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateIds(
count: arg_count,
space: arg_space,
type: arg_type,
$fields: arg_$fields);
checkGeneratedIds(response as api.GeneratedIds);
});
unittest.test('method--get', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_fileId = 'foo';
final arg_acknowledgeAbuse = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['acknowledgeAbuse']!.first,
unittest.equals('$arg_acknowledgeAbuse'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_fileId,
acknowledgeAbuse: arg_acknowledgeAbuse,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
$fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_corpora = 'foo';
final arg_corpus = 'foo';
final arg_driveId = 'foo';
final arg_includeItemsFromAllDrives = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_includeTeamDriveItems = true;
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_q = 'foo';
final arg_spaces = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_teamDriveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 5),
unittest.equals('files'),
);
pathOffset += 5;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['corpora']!.first,
unittest.equals(arg_corpora),
);
unittest.expect(
queryMap['corpus']!.first,
unittest.equals(arg_corpus),
);
unittest.expect(
queryMap['driveId']!.first,
unittest.equals(arg_driveId),
);
unittest.expect(
queryMap['includeItemsFromAllDrives']!.first,
unittest.equals('$arg_includeItemsFromAllDrives'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['includeTeamDriveItems']!.first,
unittest.equals('$arg_includeTeamDriveItems'),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['q']!.first,
unittest.equals(arg_q),
);
unittest.expect(
queryMap['spaces']!.first,
unittest.equals(arg_spaces),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['teamDriveId']!.first,
unittest.equals(arg_teamDriveId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFileList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
corpora: arg_corpora,
corpus: arg_corpus,
driveId: arg_driveId,
includeItemsFromAllDrives: arg_includeItemsFromAllDrives,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
includeTeamDriveItems: arg_includeTeamDriveItems,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
q: arg_q,
spaces: arg_spaces,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
teamDriveId: arg_teamDriveId,
$fields: arg_$fields);
checkFileList(response as api.FileList);
});
unittest.test('method--listLabels', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_fileId = 'foo';
final arg_maxResults = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/listLabels', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/listLabels'),
);
pathOffset += 11;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['maxResults']!.first),
unittest.equals(arg_maxResults),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLabelList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.listLabels(arg_fileId,
maxResults: arg_maxResults,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkLabelList(response as api.LabelList);
});
unittest.test('method--modifyLabels', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_request = buildModifyLabelsRequest();
final arg_fileId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ModifyLabelsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkModifyLabelsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/modifyLabels', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/modifyLabels'),
);
pathOffset += 13;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildModifyLabelsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.modifyLabels(arg_request, arg_fileId, $fields: arg_$fields);
checkModifyLabelsResponse(response as api.ModifyLabelsResponse);
});
unittest.test('method--update', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_request = buildFile();
final arg_fileId = 'foo';
final arg_addParents = 'foo';
final arg_enforceSingleParent = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_keepRevisionForever = true;
final arg_ocrLanguage = 'foo';
final arg_removeParents = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_useContentAsIndexableText = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.File.fromJson(json as core.Map<core.String, core.dynamic>);
checkFile(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['addParents']!.first,
unittest.equals(arg_addParents),
);
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['keepRevisionForever']!.first,
unittest.equals('$arg_keepRevisionForever'),
);
unittest.expect(
queryMap['ocrLanguage']!.first,
unittest.equals(arg_ocrLanguage),
);
unittest.expect(
queryMap['removeParents']!.first,
unittest.equals(arg_removeParents),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['useContentAsIndexableText']!.first,
unittest.equals('$arg_useContentAsIndexableText'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFile());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_fileId,
addParents: arg_addParents,
enforceSingleParent: arg_enforceSingleParent,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
keepRevisionForever: arg_keepRevisionForever,
ocrLanguage: arg_ocrLanguage,
removeParents: arg_removeParents,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
useContentAsIndexableText: arg_useContentAsIndexableText,
$fields: arg_$fields);
checkFile(response as api.File);
});
unittest.test('method--watch', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).files;
final arg_request = buildChannel();
final arg_fileId = 'foo';
final arg_acknowledgeAbuse = true;
final arg_includeLabels = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Channel.fromJson(json as core.Map<core.String, core.dynamic>);
checkChannel(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/watch', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('/watch'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['acknowledgeAbuse']!.first,
unittest.equals('$arg_acknowledgeAbuse'),
);
unittest.expect(
queryMap['includeLabels']!.first,
unittest.equals(arg_includeLabels),
);
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildChannel());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.watch(arg_request, arg_fileId,
acknowledgeAbuse: arg_acknowledgeAbuse,
includeLabels: arg_includeLabels,
includePermissionsForView: arg_includePermissionsForView,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
$fields: arg_$fields);
checkChannel(response as api.Channel);
});
});
unittest.group('resource-PermissionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).permissions;
final arg_request = buildPermission();
final arg_fileId = 'foo';
final arg_emailMessage = 'foo';
final arg_enforceSingleParent = true;
final arg_moveToNewOwnersRoot = true;
final arg_sendNotificationEmail = true;
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_transferOwnership = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Permission.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPermission(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/permissions', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('/permissions'),
);
pathOffset += 12;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['emailMessage']!.first,
unittest.equals(arg_emailMessage),
);
unittest.expect(
queryMap['enforceSingleParent']!.first,
unittest.equals('$arg_enforceSingleParent'),
);
unittest.expect(
queryMap['moveToNewOwnersRoot']!.first,
unittest.equals('$arg_moveToNewOwnersRoot'),
);
unittest.expect(
queryMap['sendNotificationEmail']!.first,
unittest.equals('$arg_sendNotificationEmail'),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['transferOwnership']!.first,
unittest.equals('$arg_transferOwnership'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPermission());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_fileId,
emailMessage: arg_emailMessage,
enforceSingleParent: arg_enforceSingleParent,
moveToNewOwnersRoot: arg_moveToNewOwnersRoot,
sendNotificationEmail: arg_sendNotificationEmail,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
transferOwnership: arg_transferOwnership,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkPermission(response as api.Permission);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).permissions;
final arg_fileId = 'foo';
final arg_permissionId = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/permissions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/permissions/'),
);
pathOffset += 13;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_permissionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_fileId, arg_permissionId,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).permissions;
final arg_fileId = 'foo';
final arg_permissionId = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/permissions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/permissions/'),
);
pathOffset += 13;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_permissionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPermission());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_fileId, arg_permissionId,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkPermission(response as api.Permission);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).permissions;
final arg_fileId = 'foo';
final arg_includePermissionsForView = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/permissions', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals('/permissions'),
);
pathOffset += 12;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['includePermissionsForView']!.first,
unittest.equals(arg_includePermissionsForView),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPermissionList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_fileId,
includePermissionsForView: arg_includePermissionsForView,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkPermissionList(response as api.PermissionList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).permissions;
final arg_request = buildPermission();
final arg_fileId = 'foo';
final arg_permissionId = 'foo';
final arg_removeExpiration = true;
final arg_supportsAllDrives = true;
final arg_supportsTeamDrives = true;
final arg_transferOwnership = true;
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.Permission.fromJson(
json as core.Map<core.String, core.dynamic>);
checkPermission(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/permissions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 13),
unittest.equals('/permissions/'),
);
pathOffset += 13;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_permissionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['removeExpiration']!.first,
unittest.equals('$arg_removeExpiration'),
);
unittest.expect(
queryMap['supportsAllDrives']!.first,
unittest.equals('$arg_supportsAllDrives'),
);
unittest.expect(
queryMap['supportsTeamDrives']!.first,
unittest.equals('$arg_supportsTeamDrives'),
);
unittest.expect(
queryMap['transferOwnership']!.first,
unittest.equals('$arg_transferOwnership'),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPermission());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_fileId, arg_permissionId,
removeExpiration: arg_removeExpiration,
supportsAllDrives: arg_supportsAllDrives,
supportsTeamDrives: arg_supportsTeamDrives,
transferOwnership: arg_transferOwnership,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkPermission(response as api.Permission);
});
});
unittest.group('resource-RepliesResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).replies;
final arg_request = buildReply();
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Reply.fromJson(json as core.Map<core.String, core.dynamic>);
checkReply(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
index = path.indexOf('/replies', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/replies'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReply());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_fileId, arg_commentId,
$fields: arg_$fields);
checkReply(response as api.Reply);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).replies;
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_replyId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
index = path.indexOf('/replies/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/replies/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_replyId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_fileId, arg_commentId, arg_replyId,
$fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).replies;
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_replyId = 'foo';
final arg_includeDeleted = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
index = path.indexOf('/replies/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/replies/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_replyId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['includeDeleted']!.first,
unittest.equals('$arg_includeDeleted'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReply());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_fileId, arg_commentId, arg_replyId,
includeDeleted: arg_includeDeleted, $fields: arg_$fields);
checkReply(response as api.Reply);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).replies;
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_includeDeleted = true;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
index = path.indexOf('/replies', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/replies'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['includeDeleted']!.first,
unittest.equals('$arg_includeDeleted'),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReplyList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_fileId, arg_commentId,
includeDeleted: arg_includeDeleted,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkReplyList(response as api.ReplyList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).replies;
final arg_request = buildReply();
final arg_fileId = 'foo';
final arg_commentId = 'foo';
final arg_replyId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Reply.fromJson(json as core.Map<core.String, core.dynamic>);
checkReply(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/comments/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/comments/'),
);
pathOffset += 10;
index = path.indexOf('/replies/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_commentId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/replies/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_replyId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildReply());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(
arg_request, arg_fileId, arg_commentId, arg_replyId,
$fields: arg_$fields);
checkReply(response as api.Reply);
});
});
unittest.group('resource-RevisionsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).revisions;
final arg_fileId = 'foo';
final arg_revisionId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/revisions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/revisions/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_revisionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_fileId, arg_revisionId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
// TODO: Implement tests for media upload;
// TODO: Implement tests for media download;
final mock = HttpServerMock();
final res = api.DriveApi(mock).revisions;
final arg_fileId = 'foo';
final arg_revisionId = 'foo';
final arg_acknowledgeAbuse = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/revisions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/revisions/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_revisionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['acknowledgeAbuse']!.first,
unittest.equals('$arg_acknowledgeAbuse'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRevision());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_fileId, arg_revisionId,
acknowledgeAbuse: arg_acknowledgeAbuse, $fields: arg_$fields);
checkRevision(response as api.Revision);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).revisions;
final arg_fileId = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/revisions', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/revisions'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRevisionList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_fileId,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkRevisionList(response as api.RevisionList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).revisions;
final arg_request = buildRevision();
final arg_fileId = 'foo';
final arg_revisionId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Revision.fromJson(json as core.Map<core.String, core.dynamic>);
checkRevision(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals('files/'),
);
pathOffset += 6;
index = path.indexOf('/revisions/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_fileId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/revisions/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_revisionId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildRevision());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_fileId, arg_revisionId,
$fields: arg_$fields);
checkRevision(response as api.Revision);
});
});
unittest.group('resource-TeamdrivesResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).teamdrives;
final arg_request = buildTeamDrive();
final arg_requestId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.TeamDrive.fromJson(json as core.Map<core.String, core.dynamic>);
checkTeamDrive(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('teamdrives'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['requestId']!.first,
unittest.equals(arg_requestId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTeamDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_requestId, $fields: arg_$fields);
checkTeamDrive(response as api.TeamDrive);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).teamdrives;
final arg_teamDriveId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('teamdrives/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_teamDriveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = '';
return async.Future.value(stringResponse(200, h, resp));
}), true);
await res.delete(arg_teamDriveId, $fields: arg_$fields);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).teamdrives;
final arg_teamDriveId = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('teamdrives/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_teamDriveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTeamDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_teamDriveId,
useDomainAdminAccess: arg_useDomainAdminAccess, $fields: arg_$fields);
checkTeamDrive(response as api.TeamDrive);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).teamdrives;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_q = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('teamdrives'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['q']!.first,
unittest.equals(arg_q),
);
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTeamDriveList());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
pageSize: arg_pageSize,
pageToken: arg_pageToken,
q: arg_q,
useDomainAdminAccess: arg_useDomainAdminAccess,
$fields: arg_$fields);
checkTeamDriveList(response as api.TeamDriveList);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.DriveApi(mock).teamdrives;
final arg_request = buildTeamDrive();
final arg_teamDriveId = 'foo';
final arg_useDomainAdminAccess = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.TeamDrive.fromJson(json as core.Map<core.String, core.dynamic>);
checkTeamDrive(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('drive/v3/'),
);
pathOffset += 9;
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('teamdrives/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_teamDriveId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['useDomainAdminAccess']!.first,
unittest.equals('$arg_useDomainAdminAccess'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTeamDrive());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_teamDriveId,
useDomainAdminAccess: arg_useDomainAdminAccess, $fields: arg_$fields);
checkTeamDrive(response as api.TeamDrive);
});
});
}
|
googleapis.dart/generated/googleapis/test/drive/v3_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/drive/v3_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 109971}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/forms/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterAnswer = 0;
api.Answer buildAnswer() {
final o = api.Answer();
buildCounterAnswer++;
if (buildCounterAnswer < 3) {
o.fileUploadAnswers = buildFileUploadAnswers();
o.grade = buildGrade();
o.questionId = 'foo';
o.textAnswers = buildTextAnswers();
}
buildCounterAnswer--;
return o;
}
void checkAnswer(api.Answer o) {
buildCounterAnswer++;
if (buildCounterAnswer < 3) {
checkFileUploadAnswers(o.fileUploadAnswers!);
checkGrade(o.grade!);
unittest.expect(
o.questionId!,
unittest.equals('foo'),
);
checkTextAnswers(o.textAnswers!);
}
buildCounterAnswer--;
}
core.List<api.Request> buildUnnamed0() => [
buildRequest(),
buildRequest(),
];
void checkUnnamed0(core.List<api.Request> o) {
unittest.expect(o, unittest.hasLength(2));
checkRequest(o[0]);
checkRequest(o[1]);
}
core.int buildCounterBatchUpdateFormRequest = 0;
api.BatchUpdateFormRequest buildBatchUpdateFormRequest() {
final o = api.BatchUpdateFormRequest();
buildCounterBatchUpdateFormRequest++;
if (buildCounterBatchUpdateFormRequest < 3) {
o.includeFormInResponse = true;
o.requests = buildUnnamed0();
o.writeControl = buildWriteControl();
}
buildCounterBatchUpdateFormRequest--;
return o;
}
void checkBatchUpdateFormRequest(api.BatchUpdateFormRequest o) {
buildCounterBatchUpdateFormRequest++;
if (buildCounterBatchUpdateFormRequest < 3) {
unittest.expect(o.includeFormInResponse!, unittest.isTrue);
checkUnnamed0(o.requests!);
checkWriteControl(o.writeControl!);
}
buildCounterBatchUpdateFormRequest--;
}
core.List<api.Response> buildUnnamed1() => [
buildResponse(),
buildResponse(),
];
void checkUnnamed1(core.List<api.Response> o) {
unittest.expect(o, unittest.hasLength(2));
checkResponse(o[0]);
checkResponse(o[1]);
}
core.int buildCounterBatchUpdateFormResponse = 0;
api.BatchUpdateFormResponse buildBatchUpdateFormResponse() {
final o = api.BatchUpdateFormResponse();
buildCounterBatchUpdateFormResponse++;
if (buildCounterBatchUpdateFormResponse < 3) {
o.form = buildForm();
o.replies = buildUnnamed1();
o.writeControl = buildWriteControl();
}
buildCounterBatchUpdateFormResponse--;
return o;
}
void checkBatchUpdateFormResponse(api.BatchUpdateFormResponse o) {
buildCounterBatchUpdateFormResponse++;
if (buildCounterBatchUpdateFormResponse < 3) {
checkForm(o.form!);
checkUnnamed1(o.replies!);
checkWriteControl(o.writeControl!);
}
buildCounterBatchUpdateFormResponse--;
}
core.List<api.Option> buildUnnamed2() => [
buildOption(),
buildOption(),
];
void checkUnnamed2(core.List<api.Option> o) {
unittest.expect(o, unittest.hasLength(2));
checkOption(o[0]);
checkOption(o[1]);
}
core.int buildCounterChoiceQuestion = 0;
api.ChoiceQuestion buildChoiceQuestion() {
final o = api.ChoiceQuestion();
buildCounterChoiceQuestion++;
if (buildCounterChoiceQuestion < 3) {
o.options = buildUnnamed2();
o.shuffle = true;
o.type = 'foo';
}
buildCounterChoiceQuestion--;
return o;
}
void checkChoiceQuestion(api.ChoiceQuestion o) {
buildCounterChoiceQuestion++;
if (buildCounterChoiceQuestion < 3) {
checkUnnamed2(o.options!);
unittest.expect(o.shuffle!, unittest.isTrue);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterChoiceQuestion--;
}
core.int buildCounterCloudPubsubTopic = 0;
api.CloudPubsubTopic buildCloudPubsubTopic() {
final o = api.CloudPubsubTopic();
buildCounterCloudPubsubTopic++;
if (buildCounterCloudPubsubTopic < 3) {
o.topicName = 'foo';
}
buildCounterCloudPubsubTopic--;
return o;
}
void checkCloudPubsubTopic(api.CloudPubsubTopic o) {
buildCounterCloudPubsubTopic++;
if (buildCounterCloudPubsubTopic < 3) {
unittest.expect(
o.topicName!,
unittest.equals('foo'),
);
}
buildCounterCloudPubsubTopic--;
}
core.int buildCounterCorrectAnswer = 0;
api.CorrectAnswer buildCorrectAnswer() {
final o = api.CorrectAnswer();
buildCounterCorrectAnswer++;
if (buildCounterCorrectAnswer < 3) {
o.value = 'foo';
}
buildCounterCorrectAnswer--;
return o;
}
void checkCorrectAnswer(api.CorrectAnswer o) {
buildCounterCorrectAnswer++;
if (buildCounterCorrectAnswer < 3) {
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterCorrectAnswer--;
}
core.List<api.CorrectAnswer> buildUnnamed3() => [
buildCorrectAnswer(),
buildCorrectAnswer(),
];
void checkUnnamed3(core.List<api.CorrectAnswer> o) {
unittest.expect(o, unittest.hasLength(2));
checkCorrectAnswer(o[0]);
checkCorrectAnswer(o[1]);
}
core.int buildCounterCorrectAnswers = 0;
api.CorrectAnswers buildCorrectAnswers() {
final o = api.CorrectAnswers();
buildCounterCorrectAnswers++;
if (buildCounterCorrectAnswers < 3) {
o.answers = buildUnnamed3();
}
buildCounterCorrectAnswers--;
return o;
}
void checkCorrectAnswers(api.CorrectAnswers o) {
buildCounterCorrectAnswers++;
if (buildCounterCorrectAnswers < 3) {
checkUnnamed3(o.answers!);
}
buildCounterCorrectAnswers--;
}
core.int buildCounterCreateItemRequest = 0;
api.CreateItemRequest buildCreateItemRequest() {
final o = api.CreateItemRequest();
buildCounterCreateItemRequest++;
if (buildCounterCreateItemRequest < 3) {
o.item = buildItem();
o.location = buildLocation();
}
buildCounterCreateItemRequest--;
return o;
}
void checkCreateItemRequest(api.CreateItemRequest o) {
buildCounterCreateItemRequest++;
if (buildCounterCreateItemRequest < 3) {
checkItem(o.item!);
checkLocation(o.location!);
}
buildCounterCreateItemRequest--;
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterCreateItemResponse = 0;
api.CreateItemResponse buildCreateItemResponse() {
final o = api.CreateItemResponse();
buildCounterCreateItemResponse++;
if (buildCounterCreateItemResponse < 3) {
o.itemId = 'foo';
o.questionId = buildUnnamed4();
}
buildCounterCreateItemResponse--;
return o;
}
void checkCreateItemResponse(api.CreateItemResponse o) {
buildCounterCreateItemResponse++;
if (buildCounterCreateItemResponse < 3) {
unittest.expect(
o.itemId!,
unittest.equals('foo'),
);
checkUnnamed4(o.questionId!);
}
buildCounterCreateItemResponse--;
}
core.int buildCounterCreateWatchRequest = 0;
api.CreateWatchRequest buildCreateWatchRequest() {
final o = api.CreateWatchRequest();
buildCounterCreateWatchRequest++;
if (buildCounterCreateWatchRequest < 3) {
o.watch = buildWatch();
o.watchId = 'foo';
}
buildCounterCreateWatchRequest--;
return o;
}
void checkCreateWatchRequest(api.CreateWatchRequest o) {
buildCounterCreateWatchRequest++;
if (buildCounterCreateWatchRequest < 3) {
checkWatch(o.watch!);
unittest.expect(
o.watchId!,
unittest.equals('foo'),
);
}
buildCounterCreateWatchRequest--;
}
core.int buildCounterDateQuestion = 0;
api.DateQuestion buildDateQuestion() {
final o = api.DateQuestion();
buildCounterDateQuestion++;
if (buildCounterDateQuestion < 3) {
o.includeTime = true;
o.includeYear = true;
}
buildCounterDateQuestion--;
return o;
}
void checkDateQuestion(api.DateQuestion o) {
buildCounterDateQuestion++;
if (buildCounterDateQuestion < 3) {
unittest.expect(o.includeTime!, unittest.isTrue);
unittest.expect(o.includeYear!, unittest.isTrue);
}
buildCounterDateQuestion--;
}
core.int buildCounterDeleteItemRequest = 0;
api.DeleteItemRequest buildDeleteItemRequest() {
final o = api.DeleteItemRequest();
buildCounterDeleteItemRequest++;
if (buildCounterDeleteItemRequest < 3) {
o.location = buildLocation();
}
buildCounterDeleteItemRequest--;
return o;
}
void checkDeleteItemRequest(api.DeleteItemRequest o) {
buildCounterDeleteItemRequest++;
if (buildCounterDeleteItemRequest < 3) {
checkLocation(o.location!);
}
buildCounterDeleteItemRequest--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.int buildCounterExtraMaterial = 0;
api.ExtraMaterial buildExtraMaterial() {
final o = api.ExtraMaterial();
buildCounterExtraMaterial++;
if (buildCounterExtraMaterial < 3) {
o.link = buildTextLink();
o.video = buildVideoLink();
}
buildCounterExtraMaterial--;
return o;
}
void checkExtraMaterial(api.ExtraMaterial o) {
buildCounterExtraMaterial++;
if (buildCounterExtraMaterial < 3) {
checkTextLink(o.link!);
checkVideoLink(o.video!);
}
buildCounterExtraMaterial--;
}
core.List<api.ExtraMaterial> buildUnnamed5() => [
buildExtraMaterial(),
buildExtraMaterial(),
];
void checkUnnamed5(core.List<api.ExtraMaterial> o) {
unittest.expect(o, unittest.hasLength(2));
checkExtraMaterial(o[0]);
checkExtraMaterial(o[1]);
}
core.int buildCounterFeedback = 0;
api.Feedback buildFeedback() {
final o = api.Feedback();
buildCounterFeedback++;
if (buildCounterFeedback < 3) {
o.material = buildUnnamed5();
o.text = 'foo';
}
buildCounterFeedback--;
return o;
}
void checkFeedback(api.Feedback o) {
buildCounterFeedback++;
if (buildCounterFeedback < 3) {
checkUnnamed5(o.material!);
unittest.expect(
o.text!,
unittest.equals('foo'),
);
}
buildCounterFeedback--;
}
core.int buildCounterFileUploadAnswer = 0;
api.FileUploadAnswer buildFileUploadAnswer() {
final o = api.FileUploadAnswer();
buildCounterFileUploadAnswer++;
if (buildCounterFileUploadAnswer < 3) {
o.fileId = 'foo';
o.fileName = 'foo';
o.mimeType = 'foo';
}
buildCounterFileUploadAnswer--;
return o;
}
void checkFileUploadAnswer(api.FileUploadAnswer o) {
buildCounterFileUploadAnswer++;
if (buildCounterFileUploadAnswer < 3) {
unittest.expect(
o.fileId!,
unittest.equals('foo'),
);
unittest.expect(
o.fileName!,
unittest.equals('foo'),
);
unittest.expect(
o.mimeType!,
unittest.equals('foo'),
);
}
buildCounterFileUploadAnswer--;
}
core.List<api.FileUploadAnswer> buildUnnamed6() => [
buildFileUploadAnswer(),
buildFileUploadAnswer(),
];
void checkUnnamed6(core.List<api.FileUploadAnswer> o) {
unittest.expect(o, unittest.hasLength(2));
checkFileUploadAnswer(o[0]);
checkFileUploadAnswer(o[1]);
}
core.int buildCounterFileUploadAnswers = 0;
api.FileUploadAnswers buildFileUploadAnswers() {
final o = api.FileUploadAnswers();
buildCounterFileUploadAnswers++;
if (buildCounterFileUploadAnswers < 3) {
o.answers = buildUnnamed6();
}
buildCounterFileUploadAnswers--;
return o;
}
void checkFileUploadAnswers(api.FileUploadAnswers o) {
buildCounterFileUploadAnswers++;
if (buildCounterFileUploadAnswers < 3) {
checkUnnamed6(o.answers!);
}
buildCounterFileUploadAnswers--;
}
core.List<core.String> buildUnnamed7() => [
'foo',
'foo',
];
void checkUnnamed7(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterFileUploadQuestion = 0;
api.FileUploadQuestion buildFileUploadQuestion() {
final o = api.FileUploadQuestion();
buildCounterFileUploadQuestion++;
if (buildCounterFileUploadQuestion < 3) {
o.folderId = 'foo';
o.maxFileSize = 'foo';
o.maxFiles = 42;
o.types = buildUnnamed7();
}
buildCounterFileUploadQuestion--;
return o;
}
void checkFileUploadQuestion(api.FileUploadQuestion o) {
buildCounterFileUploadQuestion++;
if (buildCounterFileUploadQuestion < 3) {
unittest.expect(
o.folderId!,
unittest.equals('foo'),
);
unittest.expect(
o.maxFileSize!,
unittest.equals('foo'),
);
unittest.expect(
o.maxFiles!,
unittest.equals(42),
);
checkUnnamed7(o.types!);
}
buildCounterFileUploadQuestion--;
}
core.List<api.Item> buildUnnamed8() => [
buildItem(),
buildItem(),
];
void checkUnnamed8(core.List<api.Item> o) {
unittest.expect(o, unittest.hasLength(2));
checkItem(o[0]);
checkItem(o[1]);
}
core.int buildCounterForm = 0;
api.Form buildForm() {
final o = api.Form();
buildCounterForm++;
if (buildCounterForm < 3) {
o.formId = 'foo';
o.info = buildInfo();
o.items = buildUnnamed8();
o.linkedSheetId = 'foo';
o.responderUri = 'foo';
o.revisionId = 'foo';
o.settings = buildFormSettings();
}
buildCounterForm--;
return o;
}
void checkForm(api.Form o) {
buildCounterForm++;
if (buildCounterForm < 3) {
unittest.expect(
o.formId!,
unittest.equals('foo'),
);
checkInfo(o.info!);
checkUnnamed8(o.items!);
unittest.expect(
o.linkedSheetId!,
unittest.equals('foo'),
);
unittest.expect(
o.responderUri!,
unittest.equals('foo'),
);
unittest.expect(
o.revisionId!,
unittest.equals('foo'),
);
checkFormSettings(o.settings!);
}
buildCounterForm--;
}
core.Map<core.String, api.Answer> buildUnnamed9() => {
'x': buildAnswer(),
'y': buildAnswer(),
};
void checkUnnamed9(core.Map<core.String, api.Answer> o) {
unittest.expect(o, unittest.hasLength(2));
checkAnswer(o['x']!);
checkAnswer(o['y']!);
}
core.int buildCounterFormResponse = 0;
api.FormResponse buildFormResponse() {
final o = api.FormResponse();
buildCounterFormResponse++;
if (buildCounterFormResponse < 3) {
o.answers = buildUnnamed9();
o.createTime = 'foo';
o.formId = 'foo';
o.lastSubmittedTime = 'foo';
o.respondentEmail = 'foo';
o.responseId = 'foo';
o.totalScore = 42.0;
}
buildCounterFormResponse--;
return o;
}
void checkFormResponse(api.FormResponse o) {
buildCounterFormResponse++;
if (buildCounterFormResponse < 3) {
checkUnnamed9(o.answers!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.formId!,
unittest.equals('foo'),
);
unittest.expect(
o.lastSubmittedTime!,
unittest.equals('foo'),
);
unittest.expect(
o.respondentEmail!,
unittest.equals('foo'),
);
unittest.expect(
o.responseId!,
unittest.equals('foo'),
);
unittest.expect(
o.totalScore!,
unittest.equals(42.0),
);
}
buildCounterFormResponse--;
}
core.int buildCounterFormSettings = 0;
api.FormSettings buildFormSettings() {
final o = api.FormSettings();
buildCounterFormSettings++;
if (buildCounterFormSettings < 3) {
o.quizSettings = buildQuizSettings();
}
buildCounterFormSettings--;
return o;
}
void checkFormSettings(api.FormSettings o) {
buildCounterFormSettings++;
if (buildCounterFormSettings < 3) {
checkQuizSettings(o.quizSettings!);
}
buildCounterFormSettings--;
}
core.int buildCounterGrade = 0;
api.Grade buildGrade() {
final o = api.Grade();
buildCounterGrade++;
if (buildCounterGrade < 3) {
o.correct = true;
o.feedback = buildFeedback();
o.score = 42.0;
}
buildCounterGrade--;
return o;
}
void checkGrade(api.Grade o) {
buildCounterGrade++;
if (buildCounterGrade < 3) {
unittest.expect(o.correct!, unittest.isTrue);
checkFeedback(o.feedback!);
unittest.expect(
o.score!,
unittest.equals(42.0),
);
}
buildCounterGrade--;
}
core.int buildCounterGrading = 0;
api.Grading buildGrading() {
final o = api.Grading();
buildCounterGrading++;
if (buildCounterGrading < 3) {
o.correctAnswers = buildCorrectAnswers();
o.generalFeedback = buildFeedback();
o.pointValue = 42;
o.whenRight = buildFeedback();
o.whenWrong = buildFeedback();
}
buildCounterGrading--;
return o;
}
void checkGrading(api.Grading o) {
buildCounterGrading++;
if (buildCounterGrading < 3) {
checkCorrectAnswers(o.correctAnswers!);
checkFeedback(o.generalFeedback!);
unittest.expect(
o.pointValue!,
unittest.equals(42),
);
checkFeedback(o.whenRight!);
checkFeedback(o.whenWrong!);
}
buildCounterGrading--;
}
core.int buildCounterGrid = 0;
api.Grid buildGrid() {
final o = api.Grid();
buildCounterGrid++;
if (buildCounterGrid < 3) {
o.columns = buildChoiceQuestion();
o.shuffleQuestions = true;
}
buildCounterGrid--;
return o;
}
void checkGrid(api.Grid o) {
buildCounterGrid++;
if (buildCounterGrid < 3) {
checkChoiceQuestion(o.columns!);
unittest.expect(o.shuffleQuestions!, unittest.isTrue);
}
buildCounterGrid--;
}
core.int buildCounterImage = 0;
api.Image buildImage() {
final o = api.Image();
buildCounterImage++;
if (buildCounterImage < 3) {
o.altText = 'foo';
o.contentUri = 'foo';
o.properties = buildMediaProperties();
o.sourceUri = 'foo';
}
buildCounterImage--;
return o;
}
void checkImage(api.Image o) {
buildCounterImage++;
if (buildCounterImage < 3) {
unittest.expect(
o.altText!,
unittest.equals('foo'),
);
unittest.expect(
o.contentUri!,
unittest.equals('foo'),
);
checkMediaProperties(o.properties!);
unittest.expect(
o.sourceUri!,
unittest.equals('foo'),
);
}
buildCounterImage--;
}
core.int buildCounterImageItem = 0;
api.ImageItem buildImageItem() {
final o = api.ImageItem();
buildCounterImageItem++;
if (buildCounterImageItem < 3) {
o.image = buildImage();
}
buildCounterImageItem--;
return o;
}
void checkImageItem(api.ImageItem o) {
buildCounterImageItem++;
if (buildCounterImageItem < 3) {
checkImage(o.image!);
}
buildCounterImageItem--;
}
core.int buildCounterInfo = 0;
api.Info buildInfo() {
final o = api.Info();
buildCounterInfo++;
if (buildCounterInfo < 3) {
o.description = 'foo';
o.documentTitle = 'foo';
o.title = 'foo';
}
buildCounterInfo--;
return o;
}
void checkInfo(api.Info o) {
buildCounterInfo++;
if (buildCounterInfo < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.documentTitle!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterInfo--;
}
core.int buildCounterItem = 0;
api.Item buildItem() {
final o = api.Item();
buildCounterItem++;
if (buildCounterItem < 3) {
o.description = 'foo';
o.imageItem = buildImageItem();
o.itemId = 'foo';
o.pageBreakItem = buildPageBreakItem();
o.questionGroupItem = buildQuestionGroupItem();
o.questionItem = buildQuestionItem();
o.textItem = buildTextItem();
o.title = 'foo';
o.videoItem = buildVideoItem();
}
buildCounterItem--;
return o;
}
void checkItem(api.Item o) {
buildCounterItem++;
if (buildCounterItem < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkImageItem(o.imageItem!);
unittest.expect(
o.itemId!,
unittest.equals('foo'),
);
checkPageBreakItem(o.pageBreakItem!);
checkQuestionGroupItem(o.questionGroupItem!);
checkQuestionItem(o.questionItem!);
checkTextItem(o.textItem!);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
checkVideoItem(o.videoItem!);
}
buildCounterItem--;
}
core.List<api.FormResponse> buildUnnamed10() => [
buildFormResponse(),
buildFormResponse(),
];
void checkUnnamed10(core.List<api.FormResponse> o) {
unittest.expect(o, unittest.hasLength(2));
checkFormResponse(o[0]);
checkFormResponse(o[1]);
}
core.int buildCounterListFormResponsesResponse = 0;
api.ListFormResponsesResponse buildListFormResponsesResponse() {
final o = api.ListFormResponsesResponse();
buildCounterListFormResponsesResponse++;
if (buildCounterListFormResponsesResponse < 3) {
o.nextPageToken = 'foo';
o.responses = buildUnnamed10();
}
buildCounterListFormResponsesResponse--;
return o;
}
void checkListFormResponsesResponse(api.ListFormResponsesResponse o) {
buildCounterListFormResponsesResponse++;
if (buildCounterListFormResponsesResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed10(o.responses!);
}
buildCounterListFormResponsesResponse--;
}
core.List<api.Watch> buildUnnamed11() => [
buildWatch(),
buildWatch(),
];
void checkUnnamed11(core.List<api.Watch> o) {
unittest.expect(o, unittest.hasLength(2));
checkWatch(o[0]);
checkWatch(o[1]);
}
core.int buildCounterListWatchesResponse = 0;
api.ListWatchesResponse buildListWatchesResponse() {
final o = api.ListWatchesResponse();
buildCounterListWatchesResponse++;
if (buildCounterListWatchesResponse < 3) {
o.watches = buildUnnamed11();
}
buildCounterListWatchesResponse--;
return o;
}
void checkListWatchesResponse(api.ListWatchesResponse o) {
buildCounterListWatchesResponse++;
if (buildCounterListWatchesResponse < 3) {
checkUnnamed11(o.watches!);
}
buildCounterListWatchesResponse--;
}
core.int buildCounterLocation = 0;
api.Location buildLocation() {
final o = api.Location();
buildCounterLocation++;
if (buildCounterLocation < 3) {
o.index = 42;
}
buildCounterLocation--;
return o;
}
void checkLocation(api.Location o) {
buildCounterLocation++;
if (buildCounterLocation < 3) {
unittest.expect(
o.index!,
unittest.equals(42),
);
}
buildCounterLocation--;
}
core.int buildCounterMediaProperties = 0;
api.MediaProperties buildMediaProperties() {
final o = api.MediaProperties();
buildCounterMediaProperties++;
if (buildCounterMediaProperties < 3) {
o.alignment = 'foo';
o.width = 42;
}
buildCounterMediaProperties--;
return o;
}
void checkMediaProperties(api.MediaProperties o) {
buildCounterMediaProperties++;
if (buildCounterMediaProperties < 3) {
unittest.expect(
o.alignment!,
unittest.equals('foo'),
);
unittest.expect(
o.width!,
unittest.equals(42),
);
}
buildCounterMediaProperties--;
}
core.int buildCounterMoveItemRequest = 0;
api.MoveItemRequest buildMoveItemRequest() {
final o = api.MoveItemRequest();
buildCounterMoveItemRequest++;
if (buildCounterMoveItemRequest < 3) {
o.newLocation = buildLocation();
o.originalLocation = buildLocation();
}
buildCounterMoveItemRequest--;
return o;
}
void checkMoveItemRequest(api.MoveItemRequest o) {
buildCounterMoveItemRequest++;
if (buildCounterMoveItemRequest < 3) {
checkLocation(o.newLocation!);
checkLocation(o.originalLocation!);
}
buildCounterMoveItemRequest--;
}
core.int buildCounterOption = 0;
api.Option buildOption() {
final o = api.Option();
buildCounterOption++;
if (buildCounterOption < 3) {
o.goToAction = 'foo';
o.goToSectionId = 'foo';
o.image = buildImage();
o.isOther = true;
o.value = 'foo';
}
buildCounterOption--;
return o;
}
void checkOption(api.Option o) {
buildCounterOption++;
if (buildCounterOption < 3) {
unittest.expect(
o.goToAction!,
unittest.equals('foo'),
);
unittest.expect(
o.goToSectionId!,
unittest.equals('foo'),
);
checkImage(o.image!);
unittest.expect(o.isOther!, unittest.isTrue);
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterOption--;
}
core.int buildCounterPageBreakItem = 0;
api.PageBreakItem buildPageBreakItem() {
final o = api.PageBreakItem();
buildCounterPageBreakItem++;
if (buildCounterPageBreakItem < 3) {}
buildCounterPageBreakItem--;
return o;
}
void checkPageBreakItem(api.PageBreakItem o) {
buildCounterPageBreakItem++;
if (buildCounterPageBreakItem < 3) {}
buildCounterPageBreakItem--;
}
core.int buildCounterQuestion = 0;
api.Question buildQuestion() {
final o = api.Question();
buildCounterQuestion++;
if (buildCounterQuestion < 3) {
o.choiceQuestion = buildChoiceQuestion();
o.dateQuestion = buildDateQuestion();
o.fileUploadQuestion = buildFileUploadQuestion();
o.grading = buildGrading();
o.questionId = 'foo';
o.required = true;
o.rowQuestion = buildRowQuestion();
o.scaleQuestion = buildScaleQuestion();
o.textQuestion = buildTextQuestion();
o.timeQuestion = buildTimeQuestion();
}
buildCounterQuestion--;
return o;
}
void checkQuestion(api.Question o) {
buildCounterQuestion++;
if (buildCounterQuestion < 3) {
checkChoiceQuestion(o.choiceQuestion!);
checkDateQuestion(o.dateQuestion!);
checkFileUploadQuestion(o.fileUploadQuestion!);
checkGrading(o.grading!);
unittest.expect(
o.questionId!,
unittest.equals('foo'),
);
unittest.expect(o.required!, unittest.isTrue);
checkRowQuestion(o.rowQuestion!);
checkScaleQuestion(o.scaleQuestion!);
checkTextQuestion(o.textQuestion!);
checkTimeQuestion(o.timeQuestion!);
}
buildCounterQuestion--;
}
core.List<api.Question> buildUnnamed12() => [
buildQuestion(),
buildQuestion(),
];
void checkUnnamed12(core.List<api.Question> o) {
unittest.expect(o, unittest.hasLength(2));
checkQuestion(o[0]);
checkQuestion(o[1]);
}
core.int buildCounterQuestionGroupItem = 0;
api.QuestionGroupItem buildQuestionGroupItem() {
final o = api.QuestionGroupItem();
buildCounterQuestionGroupItem++;
if (buildCounterQuestionGroupItem < 3) {
o.grid = buildGrid();
o.image = buildImage();
o.questions = buildUnnamed12();
}
buildCounterQuestionGroupItem--;
return o;
}
void checkQuestionGroupItem(api.QuestionGroupItem o) {
buildCounterQuestionGroupItem++;
if (buildCounterQuestionGroupItem < 3) {
checkGrid(o.grid!);
checkImage(o.image!);
checkUnnamed12(o.questions!);
}
buildCounterQuestionGroupItem--;
}
core.int buildCounterQuestionItem = 0;
api.QuestionItem buildQuestionItem() {
final o = api.QuestionItem();
buildCounterQuestionItem++;
if (buildCounterQuestionItem < 3) {
o.image = buildImage();
o.question = buildQuestion();
}
buildCounterQuestionItem--;
return o;
}
void checkQuestionItem(api.QuestionItem o) {
buildCounterQuestionItem++;
if (buildCounterQuestionItem < 3) {
checkImage(o.image!);
checkQuestion(o.question!);
}
buildCounterQuestionItem--;
}
core.int buildCounterQuizSettings = 0;
api.QuizSettings buildQuizSettings() {
final o = api.QuizSettings();
buildCounterQuizSettings++;
if (buildCounterQuizSettings < 3) {
o.isQuiz = true;
}
buildCounterQuizSettings--;
return o;
}
void checkQuizSettings(api.QuizSettings o) {
buildCounterQuizSettings++;
if (buildCounterQuizSettings < 3) {
unittest.expect(o.isQuiz!, unittest.isTrue);
}
buildCounterQuizSettings--;
}
core.int buildCounterRenewWatchRequest = 0;
api.RenewWatchRequest buildRenewWatchRequest() {
final o = api.RenewWatchRequest();
buildCounterRenewWatchRequest++;
if (buildCounterRenewWatchRequest < 3) {}
buildCounterRenewWatchRequest--;
return o;
}
void checkRenewWatchRequest(api.RenewWatchRequest o) {
buildCounterRenewWatchRequest++;
if (buildCounterRenewWatchRequest < 3) {}
buildCounterRenewWatchRequest--;
}
core.int buildCounterRequest = 0;
api.Request buildRequest() {
final o = api.Request();
buildCounterRequest++;
if (buildCounterRequest < 3) {
o.createItem = buildCreateItemRequest();
o.deleteItem = buildDeleteItemRequest();
o.moveItem = buildMoveItemRequest();
o.updateFormInfo = buildUpdateFormInfoRequest();
o.updateItem = buildUpdateItemRequest();
o.updateSettings = buildUpdateSettingsRequest();
}
buildCounterRequest--;
return o;
}
void checkRequest(api.Request o) {
buildCounterRequest++;
if (buildCounterRequest < 3) {
checkCreateItemRequest(o.createItem!);
checkDeleteItemRequest(o.deleteItem!);
checkMoveItemRequest(o.moveItem!);
checkUpdateFormInfoRequest(o.updateFormInfo!);
checkUpdateItemRequest(o.updateItem!);
checkUpdateSettingsRequest(o.updateSettings!);
}
buildCounterRequest--;
}
core.int buildCounterResponse = 0;
api.Response buildResponse() {
final o = api.Response();
buildCounterResponse++;
if (buildCounterResponse < 3) {
o.createItem = buildCreateItemResponse();
}
buildCounterResponse--;
return o;
}
void checkResponse(api.Response o) {
buildCounterResponse++;
if (buildCounterResponse < 3) {
checkCreateItemResponse(o.createItem!);
}
buildCounterResponse--;
}
core.int buildCounterRowQuestion = 0;
api.RowQuestion buildRowQuestion() {
final o = api.RowQuestion();
buildCounterRowQuestion++;
if (buildCounterRowQuestion < 3) {
o.title = 'foo';
}
buildCounterRowQuestion--;
return o;
}
void checkRowQuestion(api.RowQuestion o) {
buildCounterRowQuestion++;
if (buildCounterRowQuestion < 3) {
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterRowQuestion--;
}
core.int buildCounterScaleQuestion = 0;
api.ScaleQuestion buildScaleQuestion() {
final o = api.ScaleQuestion();
buildCounterScaleQuestion++;
if (buildCounterScaleQuestion < 3) {
o.high = 42;
o.highLabel = 'foo';
o.low = 42;
o.lowLabel = 'foo';
}
buildCounterScaleQuestion--;
return o;
}
void checkScaleQuestion(api.ScaleQuestion o) {
buildCounterScaleQuestion++;
if (buildCounterScaleQuestion < 3) {
unittest.expect(
o.high!,
unittest.equals(42),
);
unittest.expect(
o.highLabel!,
unittest.equals('foo'),
);
unittest.expect(
o.low!,
unittest.equals(42),
);
unittest.expect(
o.lowLabel!,
unittest.equals('foo'),
);
}
buildCounterScaleQuestion--;
}
core.int buildCounterTextAnswer = 0;
api.TextAnswer buildTextAnswer() {
final o = api.TextAnswer();
buildCounterTextAnswer++;
if (buildCounterTextAnswer < 3) {
o.value = 'foo';
}
buildCounterTextAnswer--;
return o;
}
void checkTextAnswer(api.TextAnswer o) {
buildCounterTextAnswer++;
if (buildCounterTextAnswer < 3) {
unittest.expect(
o.value!,
unittest.equals('foo'),
);
}
buildCounterTextAnswer--;
}
core.List<api.TextAnswer> buildUnnamed13() => [
buildTextAnswer(),
buildTextAnswer(),
];
void checkUnnamed13(core.List<api.TextAnswer> o) {
unittest.expect(o, unittest.hasLength(2));
checkTextAnswer(o[0]);
checkTextAnswer(o[1]);
}
core.int buildCounterTextAnswers = 0;
api.TextAnswers buildTextAnswers() {
final o = api.TextAnswers();
buildCounterTextAnswers++;
if (buildCounterTextAnswers < 3) {
o.answers = buildUnnamed13();
}
buildCounterTextAnswers--;
return o;
}
void checkTextAnswers(api.TextAnswers o) {
buildCounterTextAnswers++;
if (buildCounterTextAnswers < 3) {
checkUnnamed13(o.answers!);
}
buildCounterTextAnswers--;
}
core.int buildCounterTextItem = 0;
api.TextItem buildTextItem() {
final o = api.TextItem();
buildCounterTextItem++;
if (buildCounterTextItem < 3) {}
buildCounterTextItem--;
return o;
}
void checkTextItem(api.TextItem o) {
buildCounterTextItem++;
if (buildCounterTextItem < 3) {}
buildCounterTextItem--;
}
core.int buildCounterTextLink = 0;
api.TextLink buildTextLink() {
final o = api.TextLink();
buildCounterTextLink++;
if (buildCounterTextLink < 3) {
o.displayText = 'foo';
o.uri = 'foo';
}
buildCounterTextLink--;
return o;
}
void checkTextLink(api.TextLink o) {
buildCounterTextLink++;
if (buildCounterTextLink < 3) {
unittest.expect(
o.displayText!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterTextLink--;
}
core.int buildCounterTextQuestion = 0;
api.TextQuestion buildTextQuestion() {
final o = api.TextQuestion();
buildCounterTextQuestion++;
if (buildCounterTextQuestion < 3) {
o.paragraph = true;
}
buildCounterTextQuestion--;
return o;
}
void checkTextQuestion(api.TextQuestion o) {
buildCounterTextQuestion++;
if (buildCounterTextQuestion < 3) {
unittest.expect(o.paragraph!, unittest.isTrue);
}
buildCounterTextQuestion--;
}
core.int buildCounterTimeQuestion = 0;
api.TimeQuestion buildTimeQuestion() {
final o = api.TimeQuestion();
buildCounterTimeQuestion++;
if (buildCounterTimeQuestion < 3) {
o.duration = true;
}
buildCounterTimeQuestion--;
return o;
}
void checkTimeQuestion(api.TimeQuestion o) {
buildCounterTimeQuestion++;
if (buildCounterTimeQuestion < 3) {
unittest.expect(o.duration!, unittest.isTrue);
}
buildCounterTimeQuestion--;
}
core.int buildCounterUpdateFormInfoRequest = 0;
api.UpdateFormInfoRequest buildUpdateFormInfoRequest() {
final o = api.UpdateFormInfoRequest();
buildCounterUpdateFormInfoRequest++;
if (buildCounterUpdateFormInfoRequest < 3) {
o.info = buildInfo();
o.updateMask = 'foo';
}
buildCounterUpdateFormInfoRequest--;
return o;
}
void checkUpdateFormInfoRequest(api.UpdateFormInfoRequest o) {
buildCounterUpdateFormInfoRequest++;
if (buildCounterUpdateFormInfoRequest < 3) {
checkInfo(o.info!);
unittest.expect(
o.updateMask!,
unittest.equals('foo'),
);
}
buildCounterUpdateFormInfoRequest--;
}
core.int buildCounterUpdateItemRequest = 0;
api.UpdateItemRequest buildUpdateItemRequest() {
final o = api.UpdateItemRequest();
buildCounterUpdateItemRequest++;
if (buildCounterUpdateItemRequest < 3) {
o.item = buildItem();
o.location = buildLocation();
o.updateMask = 'foo';
}
buildCounterUpdateItemRequest--;
return o;
}
void checkUpdateItemRequest(api.UpdateItemRequest o) {
buildCounterUpdateItemRequest++;
if (buildCounterUpdateItemRequest < 3) {
checkItem(o.item!);
checkLocation(o.location!);
unittest.expect(
o.updateMask!,
unittest.equals('foo'),
);
}
buildCounterUpdateItemRequest--;
}
core.int buildCounterUpdateSettingsRequest = 0;
api.UpdateSettingsRequest buildUpdateSettingsRequest() {
final o = api.UpdateSettingsRequest();
buildCounterUpdateSettingsRequest++;
if (buildCounterUpdateSettingsRequest < 3) {
o.settings = buildFormSettings();
o.updateMask = 'foo';
}
buildCounterUpdateSettingsRequest--;
return o;
}
void checkUpdateSettingsRequest(api.UpdateSettingsRequest o) {
buildCounterUpdateSettingsRequest++;
if (buildCounterUpdateSettingsRequest < 3) {
checkFormSettings(o.settings!);
unittest.expect(
o.updateMask!,
unittest.equals('foo'),
);
}
buildCounterUpdateSettingsRequest--;
}
core.int buildCounterVideo = 0;
api.Video buildVideo() {
final o = api.Video();
buildCounterVideo++;
if (buildCounterVideo < 3) {
o.properties = buildMediaProperties();
o.youtubeUri = 'foo';
}
buildCounterVideo--;
return o;
}
void checkVideo(api.Video o) {
buildCounterVideo++;
if (buildCounterVideo < 3) {
checkMediaProperties(o.properties!);
unittest.expect(
o.youtubeUri!,
unittest.equals('foo'),
);
}
buildCounterVideo--;
}
core.int buildCounterVideoItem = 0;
api.VideoItem buildVideoItem() {
final o = api.VideoItem();
buildCounterVideoItem++;
if (buildCounterVideoItem < 3) {
o.caption = 'foo';
o.video = buildVideo();
}
buildCounterVideoItem--;
return o;
}
void checkVideoItem(api.VideoItem o) {
buildCounterVideoItem++;
if (buildCounterVideoItem < 3) {
unittest.expect(
o.caption!,
unittest.equals('foo'),
);
checkVideo(o.video!);
}
buildCounterVideoItem--;
}
core.int buildCounterVideoLink = 0;
api.VideoLink buildVideoLink() {
final o = api.VideoLink();
buildCounterVideoLink++;
if (buildCounterVideoLink < 3) {
o.displayText = 'foo';
o.youtubeUri = 'foo';
}
buildCounterVideoLink--;
return o;
}
void checkVideoLink(api.VideoLink o) {
buildCounterVideoLink++;
if (buildCounterVideoLink < 3) {
unittest.expect(
o.displayText!,
unittest.equals('foo'),
);
unittest.expect(
o.youtubeUri!,
unittest.equals('foo'),
);
}
buildCounterVideoLink--;
}
core.int buildCounterWatch = 0;
api.Watch buildWatch() {
final o = api.Watch();
buildCounterWatch++;
if (buildCounterWatch < 3) {
o.createTime = 'foo';
o.errorType = 'foo';
o.eventType = 'foo';
o.expireTime = 'foo';
o.id = 'foo';
o.state = 'foo';
o.target = buildWatchTarget();
}
buildCounterWatch--;
return o;
}
void checkWatch(api.Watch o) {
buildCounterWatch++;
if (buildCounterWatch < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.errorType!,
unittest.equals('foo'),
);
unittest.expect(
o.eventType!,
unittest.equals('foo'),
);
unittest.expect(
o.expireTime!,
unittest.equals('foo'),
);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
checkWatchTarget(o.target!);
}
buildCounterWatch--;
}
core.int buildCounterWatchTarget = 0;
api.WatchTarget buildWatchTarget() {
final o = api.WatchTarget();
buildCounterWatchTarget++;
if (buildCounterWatchTarget < 3) {
o.topic = buildCloudPubsubTopic();
}
buildCounterWatchTarget--;
return o;
}
void checkWatchTarget(api.WatchTarget o) {
buildCounterWatchTarget++;
if (buildCounterWatchTarget < 3) {
checkCloudPubsubTopic(o.topic!);
}
buildCounterWatchTarget--;
}
core.int buildCounterWriteControl = 0;
api.WriteControl buildWriteControl() {
final o = api.WriteControl();
buildCounterWriteControl++;
if (buildCounterWriteControl < 3) {
o.requiredRevisionId = 'foo';
o.targetRevisionId = 'foo';
}
buildCounterWriteControl--;
return o;
}
void checkWriteControl(api.WriteControl o) {
buildCounterWriteControl++;
if (buildCounterWriteControl < 3) {
unittest.expect(
o.requiredRevisionId!,
unittest.equals('foo'),
);
unittest.expect(
o.targetRevisionId!,
unittest.equals('foo'),
);
}
buildCounterWriteControl--;
}
void main() {
unittest.group('obj-schema-Answer', () {
unittest.test('to-json--from-json', () async {
final o = buildAnswer();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Answer.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAnswer(od);
});
});
unittest.group('obj-schema-BatchUpdateFormRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildBatchUpdateFormRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BatchUpdateFormRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBatchUpdateFormRequest(od);
});
});
unittest.group('obj-schema-BatchUpdateFormResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildBatchUpdateFormResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BatchUpdateFormResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBatchUpdateFormResponse(od);
});
});
unittest.group('obj-schema-ChoiceQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildChoiceQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ChoiceQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkChoiceQuestion(od);
});
});
unittest.group('obj-schema-CloudPubsubTopic', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudPubsubTopic();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudPubsubTopic.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudPubsubTopic(od);
});
});
unittest.group('obj-schema-CorrectAnswer', () {
unittest.test('to-json--from-json', () async {
final o = buildCorrectAnswer();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CorrectAnswer.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCorrectAnswer(od);
});
});
unittest.group('obj-schema-CorrectAnswers', () {
unittest.test('to-json--from-json', () async {
final o = buildCorrectAnswers();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CorrectAnswers.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCorrectAnswers(od);
});
});
unittest.group('obj-schema-CreateItemRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateItemRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateItemRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateItemRequest(od);
});
});
unittest.group('obj-schema-CreateItemResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateItemResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateItemResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateItemResponse(od);
});
});
unittest.group('obj-schema-CreateWatchRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCreateWatchRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CreateWatchRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCreateWatchRequest(od);
});
});
unittest.group('obj-schema-DateQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildDateQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DateQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDateQuestion(od);
});
});
unittest.group('obj-schema-DeleteItemRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildDeleteItemRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DeleteItemRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDeleteItemRequest(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-ExtraMaterial', () {
unittest.test('to-json--from-json', () async {
final o = buildExtraMaterial();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ExtraMaterial.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkExtraMaterial(od);
});
});
unittest.group('obj-schema-Feedback', () {
unittest.test('to-json--from-json', () async {
final o = buildFeedback();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Feedback.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkFeedback(od);
});
});
unittest.group('obj-schema-FileUploadAnswer', () {
unittest.test('to-json--from-json', () async {
final o = buildFileUploadAnswer();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileUploadAnswer.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileUploadAnswer(od);
});
});
unittest.group('obj-schema-FileUploadAnswers', () {
unittest.test('to-json--from-json', () async {
final o = buildFileUploadAnswers();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileUploadAnswers.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileUploadAnswers(od);
});
});
unittest.group('obj-schema-FileUploadQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildFileUploadQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FileUploadQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFileUploadQuestion(od);
});
});
unittest.group('obj-schema-Form', () {
unittest.test('to-json--from-json', () async {
final o = buildForm();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Form.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkForm(od);
});
});
unittest.group('obj-schema-FormResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildFormResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FormResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFormResponse(od);
});
});
unittest.group('obj-schema-FormSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildFormSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FormSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFormSettings(od);
});
});
unittest.group('obj-schema-Grade', () {
unittest.test('to-json--from-json', () async {
final o = buildGrade();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Grade.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkGrade(od);
});
});
unittest.group('obj-schema-Grading', () {
unittest.test('to-json--from-json', () async {
final o = buildGrading();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Grading.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkGrading(od);
});
});
unittest.group('obj-schema-Grid', () {
unittest.test('to-json--from-json', () async {
final o = buildGrid();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Grid.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkGrid(od);
});
});
unittest.group('obj-schema-Image', () {
unittest.test('to-json--from-json', () async {
final o = buildImage();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Image.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkImage(od);
});
});
unittest.group('obj-schema-ImageItem', () {
unittest.test('to-json--from-json', () async {
final o = buildImageItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.ImageItem.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkImageItem(od);
});
});
unittest.group('obj-schema-Info', () {
unittest.test('to-json--from-json', () async {
final o = buildInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Info.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkInfo(od);
});
});
unittest.group('obj-schema-Item', () {
unittest.test('to-json--from-json', () async {
final o = buildItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Item.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkItem(od);
});
});
unittest.group('obj-schema-ListFormResponsesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListFormResponsesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListFormResponsesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListFormResponsesResponse(od);
});
});
unittest.group('obj-schema-ListWatchesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListWatchesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListWatchesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListWatchesResponse(od);
});
});
unittest.group('obj-schema-Location', () {
unittest.test('to-json--from-json', () async {
final o = buildLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Location.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLocation(od);
});
});
unittest.group('obj-schema-MediaProperties', () {
unittest.test('to-json--from-json', () async {
final o = buildMediaProperties();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MediaProperties.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMediaProperties(od);
});
});
unittest.group('obj-schema-MoveItemRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildMoveItemRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MoveItemRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMoveItemRequest(od);
});
});
unittest.group('obj-schema-Option', () {
unittest.test('to-json--from-json', () async {
final o = buildOption();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Option.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOption(od);
});
});
unittest.group('obj-schema-PageBreakItem', () {
unittest.test('to-json--from-json', () async {
final o = buildPageBreakItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.PageBreakItem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkPageBreakItem(od);
});
});
unittest.group('obj-schema-Question', () {
unittest.test('to-json--from-json', () async {
final o = buildQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Question.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkQuestion(od);
});
});
unittest.group('obj-schema-QuestionGroupItem', () {
unittest.test('to-json--from-json', () async {
final o = buildQuestionGroupItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.QuestionGroupItem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkQuestionGroupItem(od);
});
});
unittest.group('obj-schema-QuestionItem', () {
unittest.test('to-json--from-json', () async {
final o = buildQuestionItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.QuestionItem.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkQuestionItem(od);
});
});
unittest.group('obj-schema-QuizSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildQuizSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.QuizSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkQuizSettings(od);
});
});
unittest.group('obj-schema-RenewWatchRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRenewWatchRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RenewWatchRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRenewWatchRequest(od);
});
});
unittest.group('obj-schema-Request', () {
unittest.test('to-json--from-json', () async {
final o = buildRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Request.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRequest(od);
});
});
unittest.group('obj-schema-Response', () {
unittest.test('to-json--from-json', () async {
final o = buildResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Response.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkResponse(od);
});
});
unittest.group('obj-schema-RowQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildRowQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RowQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRowQuestion(od);
});
});
unittest.group('obj-schema-ScaleQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildScaleQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ScaleQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkScaleQuestion(od);
});
});
unittest.group('obj-schema-TextAnswer', () {
unittest.test('to-json--from-json', () async {
final o = buildTextAnswer();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TextAnswer.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTextAnswer(od);
});
});
unittest.group('obj-schema-TextAnswers', () {
unittest.test('to-json--from-json', () async {
final o = buildTextAnswers();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TextAnswers.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTextAnswers(od);
});
});
unittest.group('obj-schema-TextItem', () {
unittest.test('to-json--from-json', () async {
final o = buildTextItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TextItem.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTextItem(od);
});
});
unittest.group('obj-schema-TextLink', () {
unittest.test('to-json--from-json', () async {
final o = buildTextLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.TextLink.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTextLink(od);
});
});
unittest.group('obj-schema-TextQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildTextQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TextQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTextQuestion(od);
});
});
unittest.group('obj-schema-TimeQuestion', () {
unittest.test('to-json--from-json', () async {
final o = buildTimeQuestion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TimeQuestion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTimeQuestion(od);
});
});
unittest.group('obj-schema-UpdateFormInfoRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateFormInfoRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateFormInfoRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateFormInfoRequest(od);
});
});
unittest.group('obj-schema-UpdateItemRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateItemRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateItemRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateItemRequest(od);
});
});
unittest.group('obj-schema-UpdateSettingsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUpdateSettingsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UpdateSettingsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUpdateSettingsRequest(od);
});
});
unittest.group('obj-schema-Video', () {
unittest.test('to-json--from-json', () async {
final o = buildVideo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Video.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkVideo(od);
});
});
unittest.group('obj-schema-VideoItem', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoItem();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.VideoItem.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkVideoItem(od);
});
});
unittest.group('obj-schema-VideoLink', () {
unittest.test('to-json--from-json', () async {
final o = buildVideoLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.VideoLink.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkVideoLink(od);
});
});
unittest.group('obj-schema-Watch', () {
unittest.test('to-json--from-json', () async {
final o = buildWatch();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Watch.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkWatch(od);
});
});
unittest.group('obj-schema-WatchTarget', () {
unittest.test('to-json--from-json', () async {
final o = buildWatchTarget();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WatchTarget.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWatchTarget(od);
});
});
unittest.group('obj-schema-WriteControl', () {
unittest.test('to-json--from-json', () async {
final o = buildWriteControl();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WriteControl.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWriteControl(od);
});
});
unittest.group('resource-FormsResource', () {
unittest.test('method--batchUpdate', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms;
final arg_request = buildBatchUpdateFormRequest();
final arg_formId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.BatchUpdateFormRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkBatchUpdateFormRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf(':batchUpdate', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 12),
unittest.equals(':batchUpdate'),
);
pathOffset += 12;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildBatchUpdateFormResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.batchUpdate(arg_request, arg_formId, $fields: arg_$fields);
checkBatchUpdateFormResponse(response as api.BatchUpdateFormResponse);
});
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms;
final arg_request = buildForm();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Form.fromJson(json as core.Map<core.String, core.dynamic>);
checkForm(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('v1/forms'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildForm());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, $fields: arg_$fields);
checkForm(response as api.Form);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms;
final arg_formId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildForm());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_formId, $fields: arg_$fields);
checkForm(response as api.Form);
});
});
unittest.group('resource-FormsResponsesResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.responses;
final arg_formId = 'foo';
final arg_responseId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/responses/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 11),
unittest.equals('/responses/'),
);
pathOffset += 11;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_responseId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildFormResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.get(arg_formId, arg_responseId, $fields: arg_$fields);
checkFormResponse(response as api.FormResponse);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.responses;
final arg_formId = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/responses', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 10),
unittest.equals('/responses'),
);
pathOffset += 10;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListFormResponsesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_formId,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListFormResponsesResponse(response as api.ListFormResponsesResponse);
});
});
unittest.group('resource-FormsWatchesResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.watches;
final arg_request = buildCreateWatchRequest();
final arg_formId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CreateWatchRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCreateWatchRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/watches', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/watches'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildWatch());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_formId, $fields: arg_$fields);
checkWatch(response as api.Watch);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.watches;
final arg_formId = 'foo';
final arg_watchId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/watches/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/watches/'),
);
pathOffset += 9;
subPart = core.Uri.decodeQueryComponent(path.substring(pathOffset));
pathOffset = path.length;
unittest.expect(
subPart,
unittest.equals('$arg_watchId'),
);
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.delete(arg_formId, arg_watchId, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.watches;
final arg_formId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/watches', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 8),
unittest.equals('/watches'),
);
pathOffset += 8;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListWatchesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_formId, $fields: arg_$fields);
checkListWatchesResponse(response as api.ListWatchesResponse);
});
unittest.test('method--renew', () async {
final mock = HttpServerMock();
final res = api.FormsApi(mock).forms.watches;
final arg_request = buildRenewWatchRequest();
final arg_formId = 'foo';
final arg_watchId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RenewWatchRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRenewWatchRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('v1/forms/'),
);
pathOffset += 9;
index = path.indexOf('/watches/', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_formId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 9),
unittest.equals('/watches/'),
);
pathOffset += 9;
index = path.indexOf(':renew', pathOffset);
unittest.expect(index >= 0, unittest.isTrue);
subPart =
core.Uri.decodeQueryComponent(path.substring(pathOffset, index));
pathOffset = index;
unittest.expect(
subPart,
unittest.equals('$arg_watchId'),
);
unittest.expect(
path.substring(pathOffset, pathOffset + 6),
unittest.equals(':renew'),
);
pathOffset += 6;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildWatch());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.renew(arg_request, arg_formId, arg_watchId,
$fields: arg_$fields);
checkWatch(response as api.Watch);
});
});
}
|
googleapis.dart/generated/googleapis/test/forms/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/forms/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 33892}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/iamcredentials/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterGenerateAccessTokenRequest = 0;
api.GenerateAccessTokenRequest buildGenerateAccessTokenRequest() {
final o = api.GenerateAccessTokenRequest();
buildCounterGenerateAccessTokenRequest++;
if (buildCounterGenerateAccessTokenRequest < 3) {
o.delegates = buildUnnamed0();
o.lifetime = 'foo';
o.scope = buildUnnamed1();
}
buildCounterGenerateAccessTokenRequest--;
return o;
}
void checkGenerateAccessTokenRequest(api.GenerateAccessTokenRequest o) {
buildCounterGenerateAccessTokenRequest++;
if (buildCounterGenerateAccessTokenRequest < 3) {
checkUnnamed0(o.delegates!);
unittest.expect(
o.lifetime!,
unittest.equals('foo'),
);
checkUnnamed1(o.scope!);
}
buildCounterGenerateAccessTokenRequest--;
}
core.int buildCounterGenerateAccessTokenResponse = 0;
api.GenerateAccessTokenResponse buildGenerateAccessTokenResponse() {
final o = api.GenerateAccessTokenResponse();
buildCounterGenerateAccessTokenResponse++;
if (buildCounterGenerateAccessTokenResponse < 3) {
o.accessToken = 'foo';
o.expireTime = 'foo';
}
buildCounterGenerateAccessTokenResponse--;
return o;
}
void checkGenerateAccessTokenResponse(api.GenerateAccessTokenResponse o) {
buildCounterGenerateAccessTokenResponse++;
if (buildCounterGenerateAccessTokenResponse < 3) {
unittest.expect(
o.accessToken!,
unittest.equals('foo'),
);
unittest.expect(
o.expireTime!,
unittest.equals('foo'),
);
}
buildCounterGenerateAccessTokenResponse--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterGenerateIdTokenRequest = 0;
api.GenerateIdTokenRequest buildGenerateIdTokenRequest() {
final o = api.GenerateIdTokenRequest();
buildCounterGenerateIdTokenRequest++;
if (buildCounterGenerateIdTokenRequest < 3) {
o.audience = 'foo';
o.delegates = buildUnnamed2();
o.includeEmail = true;
}
buildCounterGenerateIdTokenRequest--;
return o;
}
void checkGenerateIdTokenRequest(api.GenerateIdTokenRequest o) {
buildCounterGenerateIdTokenRequest++;
if (buildCounterGenerateIdTokenRequest < 3) {
unittest.expect(
o.audience!,
unittest.equals('foo'),
);
checkUnnamed2(o.delegates!);
unittest.expect(o.includeEmail!, unittest.isTrue);
}
buildCounterGenerateIdTokenRequest--;
}
core.int buildCounterGenerateIdTokenResponse = 0;
api.GenerateIdTokenResponse buildGenerateIdTokenResponse() {
final o = api.GenerateIdTokenResponse();
buildCounterGenerateIdTokenResponse++;
if (buildCounterGenerateIdTokenResponse < 3) {
o.token = 'foo';
}
buildCounterGenerateIdTokenResponse--;
return o;
}
void checkGenerateIdTokenResponse(api.GenerateIdTokenResponse o) {
buildCounterGenerateIdTokenResponse++;
if (buildCounterGenerateIdTokenResponse < 3) {
unittest.expect(
o.token!,
unittest.equals('foo'),
);
}
buildCounterGenerateIdTokenResponse--;
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterSignBlobRequest = 0;
api.SignBlobRequest buildSignBlobRequest() {
final o = api.SignBlobRequest();
buildCounterSignBlobRequest++;
if (buildCounterSignBlobRequest < 3) {
o.delegates = buildUnnamed3();
o.payload = 'foo';
}
buildCounterSignBlobRequest--;
return o;
}
void checkSignBlobRequest(api.SignBlobRequest o) {
buildCounterSignBlobRequest++;
if (buildCounterSignBlobRequest < 3) {
checkUnnamed3(o.delegates!);
unittest.expect(
o.payload!,
unittest.equals('foo'),
);
}
buildCounterSignBlobRequest--;
}
core.int buildCounterSignBlobResponse = 0;
api.SignBlobResponse buildSignBlobResponse() {
final o = api.SignBlobResponse();
buildCounterSignBlobResponse++;
if (buildCounterSignBlobResponse < 3) {
o.keyId = 'foo';
o.signedBlob = 'foo';
}
buildCounterSignBlobResponse--;
return o;
}
void checkSignBlobResponse(api.SignBlobResponse o) {
buildCounterSignBlobResponse++;
if (buildCounterSignBlobResponse < 3) {
unittest.expect(
o.keyId!,
unittest.equals('foo'),
);
unittest.expect(
o.signedBlob!,
unittest.equals('foo'),
);
}
buildCounterSignBlobResponse--;
}
core.List<core.String> buildUnnamed4() => [
'foo',
'foo',
];
void checkUnnamed4(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterSignJwtRequest = 0;
api.SignJwtRequest buildSignJwtRequest() {
final o = api.SignJwtRequest();
buildCounterSignJwtRequest++;
if (buildCounterSignJwtRequest < 3) {
o.delegates = buildUnnamed4();
o.payload = 'foo';
}
buildCounterSignJwtRequest--;
return o;
}
void checkSignJwtRequest(api.SignJwtRequest o) {
buildCounterSignJwtRequest++;
if (buildCounterSignJwtRequest < 3) {
checkUnnamed4(o.delegates!);
unittest.expect(
o.payload!,
unittest.equals('foo'),
);
}
buildCounterSignJwtRequest--;
}
core.int buildCounterSignJwtResponse = 0;
api.SignJwtResponse buildSignJwtResponse() {
final o = api.SignJwtResponse();
buildCounterSignJwtResponse++;
if (buildCounterSignJwtResponse < 3) {
o.keyId = 'foo';
o.signedJwt = 'foo';
}
buildCounterSignJwtResponse--;
return o;
}
void checkSignJwtResponse(api.SignJwtResponse o) {
buildCounterSignJwtResponse++;
if (buildCounterSignJwtResponse < 3) {
unittest.expect(
o.keyId!,
unittest.equals('foo'),
);
unittest.expect(
o.signedJwt!,
unittest.equals('foo'),
);
}
buildCounterSignJwtResponse--;
}
void main() {
unittest.group('obj-schema-GenerateAccessTokenRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateAccessTokenRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateAccessTokenRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateAccessTokenRequest(od);
});
});
unittest.group('obj-schema-GenerateAccessTokenResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateAccessTokenResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateAccessTokenResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateAccessTokenResponse(od);
});
});
unittest.group('obj-schema-GenerateIdTokenRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateIdTokenRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateIdTokenRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateIdTokenRequest(od);
});
});
unittest.group('obj-schema-GenerateIdTokenResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildGenerateIdTokenResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GenerateIdTokenResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGenerateIdTokenResponse(od);
});
});
unittest.group('obj-schema-SignBlobRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSignBlobRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SignBlobRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSignBlobRequest(od);
});
});
unittest.group('obj-schema-SignBlobResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildSignBlobResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SignBlobResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSignBlobResponse(od);
});
});
unittest.group('obj-schema-SignJwtRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSignJwtRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SignJwtRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSignJwtRequest(od);
});
});
unittest.group('obj-schema-SignJwtResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildSignJwtResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SignJwtResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSignJwtResponse(od);
});
});
unittest.group('resource-ProjectsServiceAccountsResource', () {
unittest.test('method--generateAccessToken', () async {
final mock = HttpServerMock();
final res = api.IAMCredentialsApi(mock).projects.serviceAccounts;
final arg_request = buildGenerateAccessTokenRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.GenerateAccessTokenRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkGenerateAccessTokenRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGenerateAccessTokenResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateAccessToken(arg_request, arg_name,
$fields: arg_$fields);
checkGenerateAccessTokenResponse(
response as api.GenerateAccessTokenResponse);
});
unittest.test('method--generateIdToken', () async {
final mock = HttpServerMock();
final res = api.IAMCredentialsApi(mock).projects.serviceAccounts;
final arg_request = buildGenerateIdTokenRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.GenerateIdTokenRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkGenerateIdTokenRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildGenerateIdTokenResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.generateIdToken(arg_request, arg_name,
$fields: arg_$fields);
checkGenerateIdTokenResponse(response as api.GenerateIdTokenResponse);
});
unittest.test('method--signBlob', () async {
final mock = HttpServerMock();
final res = api.IAMCredentialsApi(mock).projects.serviceAccounts;
final arg_request = buildSignBlobRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SignBlobRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSignBlobRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSignBlobResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.signBlob(arg_request, arg_name, $fields: arg_$fields);
checkSignBlobResponse(response as api.SignBlobResponse);
});
unittest.test('method--signJwt', () async {
final mock = HttpServerMock();
final res = api.IAMCredentialsApi(mock).projects.serviceAccounts;
final arg_request = buildSignJwtRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SignJwtRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSignJwtRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSignJwtResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.signJwt(arg_request, arg_name, $fields: arg_$fields);
checkSignJwtResponse(response as api.SignJwtResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/iamcredentials/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/iamcredentials/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 8160}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/logging/v2.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterBigQueryDataset = 0;
api.BigQueryDataset buildBigQueryDataset() {
final o = api.BigQueryDataset();
buildCounterBigQueryDataset++;
if (buildCounterBigQueryDataset < 3) {
o.datasetId = 'foo';
}
buildCounterBigQueryDataset--;
return o;
}
void checkBigQueryDataset(api.BigQueryDataset o) {
buildCounterBigQueryDataset++;
if (buildCounterBigQueryDataset < 3) {
unittest.expect(
o.datasetId!,
unittest.equals('foo'),
);
}
buildCounterBigQueryDataset--;
}
core.int buildCounterBigQueryOptions = 0;
api.BigQueryOptions buildBigQueryOptions() {
final o = api.BigQueryOptions();
buildCounterBigQueryOptions++;
if (buildCounterBigQueryOptions < 3) {
o.usePartitionedTables = true;
o.usesTimestampColumnPartitioning = true;
}
buildCounterBigQueryOptions--;
return o;
}
void checkBigQueryOptions(api.BigQueryOptions o) {
buildCounterBigQueryOptions++;
if (buildCounterBigQueryOptions < 3) {
unittest.expect(o.usePartitionedTables!, unittest.isTrue);
unittest.expect(o.usesTimestampColumnPartitioning!, unittest.isTrue);
}
buildCounterBigQueryOptions--;
}
core.int buildCounterBucketOptions = 0;
api.BucketOptions buildBucketOptions() {
final o = api.BucketOptions();
buildCounterBucketOptions++;
if (buildCounterBucketOptions < 3) {
o.explicitBuckets = buildExplicit();
o.exponentialBuckets = buildExponential();
o.linearBuckets = buildLinear();
}
buildCounterBucketOptions--;
return o;
}
void checkBucketOptions(api.BucketOptions o) {
buildCounterBucketOptions++;
if (buildCounterBucketOptions < 3) {
checkExplicit(o.explicitBuckets!);
checkExponential(o.exponentialBuckets!);
checkLinear(o.linearBuckets!);
}
buildCounterBucketOptions--;
}
core.int buildCounterCancelOperationRequest = 0;
api.CancelOperationRequest buildCancelOperationRequest() {
final o = api.CancelOperationRequest();
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {}
buildCounterCancelOperationRequest--;
return o;
}
void checkCancelOperationRequest(api.CancelOperationRequest o) {
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {}
buildCounterCancelOperationRequest--;
}
core.int buildCounterCmekSettings = 0;
api.CmekSettings buildCmekSettings() {
final o = api.CmekSettings();
buildCounterCmekSettings++;
if (buildCounterCmekSettings < 3) {
o.kmsKeyName = 'foo';
o.kmsKeyVersionName = 'foo';
o.name = 'foo';
o.serviceAccountId = 'foo';
}
buildCounterCmekSettings--;
return o;
}
void checkCmekSettings(api.CmekSettings o) {
buildCounterCmekSettings++;
if (buildCounterCmekSettings < 3) {
unittest.expect(
o.kmsKeyName!,
unittest.equals('foo'),
);
unittest.expect(
o.kmsKeyVersionName!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.serviceAccountId!,
unittest.equals('foo'),
);
}
buildCounterCmekSettings--;
}
core.int buildCounterCopyLogEntriesRequest = 0;
api.CopyLogEntriesRequest buildCopyLogEntriesRequest() {
final o = api.CopyLogEntriesRequest();
buildCounterCopyLogEntriesRequest++;
if (buildCounterCopyLogEntriesRequest < 3) {
o.destination = 'foo';
o.filter = 'foo';
o.name = 'foo';
}
buildCounterCopyLogEntriesRequest--;
return o;
}
void checkCopyLogEntriesRequest(api.CopyLogEntriesRequest o) {
buildCounterCopyLogEntriesRequest++;
if (buildCounterCopyLogEntriesRequest < 3) {
unittest.expect(
o.destination!,
unittest.equals('foo'),
);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterCopyLogEntriesRequest--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.List<core.double> buildUnnamed0() => [
42.0,
42.0,
];
void checkUnnamed0(core.List<core.double> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals(42.0),
);
unittest.expect(
o[1],
unittest.equals(42.0),
);
}
core.int buildCounterExplicit = 0;
api.Explicit buildExplicit() {
final o = api.Explicit();
buildCounterExplicit++;
if (buildCounterExplicit < 3) {
o.bounds = buildUnnamed0();
}
buildCounterExplicit--;
return o;
}
void checkExplicit(api.Explicit o) {
buildCounterExplicit++;
if (buildCounterExplicit < 3) {
checkUnnamed0(o.bounds!);
}
buildCounterExplicit--;
}
core.int buildCounterExponential = 0;
api.Exponential buildExponential() {
final o = api.Exponential();
buildCounterExponential++;
if (buildCounterExponential < 3) {
o.growthFactor = 42.0;
o.numFiniteBuckets = 42;
o.scale = 42.0;
}
buildCounterExponential--;
return o;
}
void checkExponential(api.Exponential o) {
buildCounterExponential++;
if (buildCounterExponential < 3) {
unittest.expect(
o.growthFactor!,
unittest.equals(42.0),
);
unittest.expect(
o.numFiniteBuckets!,
unittest.equals(42),
);
unittest.expect(
o.scale!,
unittest.equals(42.0),
);
}
buildCounterExponential--;
}
core.int buildCounterHttpRequest = 0;
api.HttpRequest buildHttpRequest() {
final o = api.HttpRequest();
buildCounterHttpRequest++;
if (buildCounterHttpRequest < 3) {
o.cacheFillBytes = 'foo';
o.cacheHit = true;
o.cacheLookup = true;
o.cacheValidatedWithOriginServer = true;
o.latency = 'foo';
o.protocol = 'foo';
o.referer = 'foo';
o.remoteIp = 'foo';
o.requestMethod = 'foo';
o.requestSize = 'foo';
o.requestUrl = 'foo';
o.responseSize = 'foo';
o.serverIp = 'foo';
o.status = 42;
o.userAgent = 'foo';
}
buildCounterHttpRequest--;
return o;
}
void checkHttpRequest(api.HttpRequest o) {
buildCounterHttpRequest++;
if (buildCounterHttpRequest < 3) {
unittest.expect(
o.cacheFillBytes!,
unittest.equals('foo'),
);
unittest.expect(o.cacheHit!, unittest.isTrue);
unittest.expect(o.cacheLookup!, unittest.isTrue);
unittest.expect(o.cacheValidatedWithOriginServer!, unittest.isTrue);
unittest.expect(
o.latency!,
unittest.equals('foo'),
);
unittest.expect(
o.protocol!,
unittest.equals('foo'),
);
unittest.expect(
o.referer!,
unittest.equals('foo'),
);
unittest.expect(
o.remoteIp!,
unittest.equals('foo'),
);
unittest.expect(
o.requestMethod!,
unittest.equals('foo'),
);
unittest.expect(
o.requestSize!,
unittest.equals('foo'),
);
unittest.expect(
o.requestUrl!,
unittest.equals('foo'),
);
unittest.expect(
o.responseSize!,
unittest.equals('foo'),
);
unittest.expect(
o.serverIp!,
unittest.equals('foo'),
);
unittest.expect(
o.status!,
unittest.equals(42),
);
unittest.expect(
o.userAgent!,
unittest.equals('foo'),
);
}
buildCounterHttpRequest--;
}
core.int buildCounterIndexConfig = 0;
api.IndexConfig buildIndexConfig() {
final o = api.IndexConfig();
buildCounterIndexConfig++;
if (buildCounterIndexConfig < 3) {
o.createTime = 'foo';
o.fieldPath = 'foo';
o.type = 'foo';
}
buildCounterIndexConfig--;
return o;
}
void checkIndexConfig(api.IndexConfig o) {
buildCounterIndexConfig++;
if (buildCounterIndexConfig < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.fieldPath!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterIndexConfig--;
}
core.int buildCounterLabelDescriptor = 0;
api.LabelDescriptor buildLabelDescriptor() {
final o = api.LabelDescriptor();
buildCounterLabelDescriptor++;
if (buildCounterLabelDescriptor < 3) {
o.description = 'foo';
o.key = 'foo';
o.valueType = 'foo';
}
buildCounterLabelDescriptor--;
return o;
}
void checkLabelDescriptor(api.LabelDescriptor o) {
buildCounterLabelDescriptor++;
if (buildCounterLabelDescriptor < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.key!,
unittest.equals('foo'),
);
unittest.expect(
o.valueType!,
unittest.equals('foo'),
);
}
buildCounterLabelDescriptor--;
}
core.int buildCounterLinear = 0;
api.Linear buildLinear() {
final o = api.Linear();
buildCounterLinear++;
if (buildCounterLinear < 3) {
o.numFiniteBuckets = 42;
o.offset = 42.0;
o.width = 42.0;
}
buildCounterLinear--;
return o;
}
void checkLinear(api.Linear o) {
buildCounterLinear++;
if (buildCounterLinear < 3) {
unittest.expect(
o.numFiniteBuckets!,
unittest.equals(42),
);
unittest.expect(
o.offset!,
unittest.equals(42.0),
);
unittest.expect(
o.width!,
unittest.equals(42.0),
);
}
buildCounterLinear--;
}
core.int buildCounterLink = 0;
api.Link buildLink() {
final o = api.Link();
buildCounterLink++;
if (buildCounterLink < 3) {
o.bigqueryDataset = buildBigQueryDataset();
o.createTime = 'foo';
o.description = 'foo';
o.lifecycleState = 'foo';
o.name = 'foo';
}
buildCounterLink--;
return o;
}
void checkLink(api.Link o) {
buildCounterLink++;
if (buildCounterLink < 3) {
checkBigQueryDataset(o.bigqueryDataset!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.lifecycleState!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLink--;
}
core.List<api.LogBucket> buildUnnamed1() => [
buildLogBucket(),
buildLogBucket(),
];
void checkUnnamed1(core.List<api.LogBucket> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogBucket(o[0]);
checkLogBucket(o[1]);
}
core.int buildCounterListBucketsResponse = 0;
api.ListBucketsResponse buildListBucketsResponse() {
final o = api.ListBucketsResponse();
buildCounterListBucketsResponse++;
if (buildCounterListBucketsResponse < 3) {
o.buckets = buildUnnamed1();
o.nextPageToken = 'foo';
}
buildCounterListBucketsResponse--;
return o;
}
void checkListBucketsResponse(api.ListBucketsResponse o) {
buildCounterListBucketsResponse++;
if (buildCounterListBucketsResponse < 3) {
checkUnnamed1(o.buckets!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListBucketsResponse--;
}
core.List<api.LogExclusion> buildUnnamed2() => [
buildLogExclusion(),
buildLogExclusion(),
];
void checkUnnamed2(core.List<api.LogExclusion> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogExclusion(o[0]);
checkLogExclusion(o[1]);
}
core.int buildCounterListExclusionsResponse = 0;
api.ListExclusionsResponse buildListExclusionsResponse() {
final o = api.ListExclusionsResponse();
buildCounterListExclusionsResponse++;
if (buildCounterListExclusionsResponse < 3) {
o.exclusions = buildUnnamed2();
o.nextPageToken = 'foo';
}
buildCounterListExclusionsResponse--;
return o;
}
void checkListExclusionsResponse(api.ListExclusionsResponse o) {
buildCounterListExclusionsResponse++;
if (buildCounterListExclusionsResponse < 3) {
checkUnnamed2(o.exclusions!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListExclusionsResponse--;
}
core.List<api.Link> buildUnnamed3() => [
buildLink(),
buildLink(),
];
void checkUnnamed3(core.List<api.Link> o) {
unittest.expect(o, unittest.hasLength(2));
checkLink(o[0]);
checkLink(o[1]);
}
core.int buildCounterListLinksResponse = 0;
api.ListLinksResponse buildListLinksResponse() {
final o = api.ListLinksResponse();
buildCounterListLinksResponse++;
if (buildCounterListLinksResponse < 3) {
o.links = buildUnnamed3();
o.nextPageToken = 'foo';
}
buildCounterListLinksResponse--;
return o;
}
void checkListLinksResponse(api.ListLinksResponse o) {
buildCounterListLinksResponse++;
if (buildCounterListLinksResponse < 3) {
checkUnnamed3(o.links!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLinksResponse--;
}
core.List<api.Location> buildUnnamed4() => [
buildLocation(),
buildLocation(),
];
void checkUnnamed4(core.List<api.Location> o) {
unittest.expect(o, unittest.hasLength(2));
checkLocation(o[0]);
checkLocation(o[1]);
}
core.int buildCounterListLocationsResponse = 0;
api.ListLocationsResponse buildListLocationsResponse() {
final o = api.ListLocationsResponse();
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
o.locations = buildUnnamed4();
o.nextPageToken = 'foo';
}
buildCounterListLocationsResponse--;
return o;
}
void checkListLocationsResponse(api.ListLocationsResponse o) {
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
checkUnnamed4(o.locations!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLocationsResponse--;
}
core.List<core.String> buildUnnamed5() => [
'foo',
'foo',
];
void checkUnnamed5(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed6() => [
'foo',
'foo',
];
void checkUnnamed6(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterListLogEntriesRequest = 0;
api.ListLogEntriesRequest buildListLogEntriesRequest() {
final o = api.ListLogEntriesRequest();
buildCounterListLogEntriesRequest++;
if (buildCounterListLogEntriesRequest < 3) {
o.filter = 'foo';
o.orderBy = 'foo';
o.pageSize = 42;
o.pageToken = 'foo';
o.projectIds = buildUnnamed5();
o.resourceNames = buildUnnamed6();
}
buildCounterListLogEntriesRequest--;
return o;
}
void checkListLogEntriesRequest(api.ListLogEntriesRequest o) {
buildCounterListLogEntriesRequest++;
if (buildCounterListLogEntriesRequest < 3) {
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
unittest.expect(
o.orderBy!,
unittest.equals('foo'),
);
unittest.expect(
o.pageSize!,
unittest.equals(42),
);
unittest.expect(
o.pageToken!,
unittest.equals('foo'),
);
checkUnnamed5(o.projectIds!);
checkUnnamed6(o.resourceNames!);
}
buildCounterListLogEntriesRequest--;
}
core.List<api.LogEntry> buildUnnamed7() => [
buildLogEntry(),
buildLogEntry(),
];
void checkUnnamed7(core.List<api.LogEntry> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogEntry(o[0]);
checkLogEntry(o[1]);
}
core.int buildCounterListLogEntriesResponse = 0;
api.ListLogEntriesResponse buildListLogEntriesResponse() {
final o = api.ListLogEntriesResponse();
buildCounterListLogEntriesResponse++;
if (buildCounterListLogEntriesResponse < 3) {
o.entries = buildUnnamed7();
o.nextPageToken = 'foo';
}
buildCounterListLogEntriesResponse--;
return o;
}
void checkListLogEntriesResponse(api.ListLogEntriesResponse o) {
buildCounterListLogEntriesResponse++;
if (buildCounterListLogEntriesResponse < 3) {
checkUnnamed7(o.entries!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLogEntriesResponse--;
}
core.List<api.LogMetric> buildUnnamed8() => [
buildLogMetric(),
buildLogMetric(),
];
void checkUnnamed8(core.List<api.LogMetric> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogMetric(o[0]);
checkLogMetric(o[1]);
}
core.int buildCounterListLogMetricsResponse = 0;
api.ListLogMetricsResponse buildListLogMetricsResponse() {
final o = api.ListLogMetricsResponse();
buildCounterListLogMetricsResponse++;
if (buildCounterListLogMetricsResponse < 3) {
o.metrics = buildUnnamed8();
o.nextPageToken = 'foo';
}
buildCounterListLogMetricsResponse--;
return o;
}
void checkListLogMetricsResponse(api.ListLogMetricsResponse o) {
buildCounterListLogMetricsResponse++;
if (buildCounterListLogMetricsResponse < 3) {
checkUnnamed8(o.metrics!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLogMetricsResponse--;
}
core.List<core.String> buildUnnamed9() => [
'foo',
'foo',
];
void checkUnnamed9(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterListLogsResponse = 0;
api.ListLogsResponse buildListLogsResponse() {
final o = api.ListLogsResponse();
buildCounterListLogsResponse++;
if (buildCounterListLogsResponse < 3) {
o.logNames = buildUnnamed9();
o.nextPageToken = 'foo';
}
buildCounterListLogsResponse--;
return o;
}
void checkListLogsResponse(api.ListLogsResponse o) {
buildCounterListLogsResponse++;
if (buildCounterListLogsResponse < 3) {
checkUnnamed9(o.logNames!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLogsResponse--;
}
core.List<api.MonitoredResourceDescriptor> buildUnnamed10() => [
buildMonitoredResourceDescriptor(),
buildMonitoredResourceDescriptor(),
];
void checkUnnamed10(core.List<api.MonitoredResourceDescriptor> o) {
unittest.expect(o, unittest.hasLength(2));
checkMonitoredResourceDescriptor(o[0]);
checkMonitoredResourceDescriptor(o[1]);
}
core.int buildCounterListMonitoredResourceDescriptorsResponse = 0;
api.ListMonitoredResourceDescriptorsResponse
buildListMonitoredResourceDescriptorsResponse() {
final o = api.ListMonitoredResourceDescriptorsResponse();
buildCounterListMonitoredResourceDescriptorsResponse++;
if (buildCounterListMonitoredResourceDescriptorsResponse < 3) {
o.nextPageToken = 'foo';
o.resourceDescriptors = buildUnnamed10();
}
buildCounterListMonitoredResourceDescriptorsResponse--;
return o;
}
void checkListMonitoredResourceDescriptorsResponse(
api.ListMonitoredResourceDescriptorsResponse o) {
buildCounterListMonitoredResourceDescriptorsResponse++;
if (buildCounterListMonitoredResourceDescriptorsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed10(o.resourceDescriptors!);
}
buildCounterListMonitoredResourceDescriptorsResponse--;
}
core.List<api.Operation> buildUnnamed11() => [
buildOperation(),
buildOperation(),
];
void checkUnnamed11(core.List<api.Operation> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperation(o[0]);
checkOperation(o[1]);
}
core.int buildCounterListOperationsResponse = 0;
api.ListOperationsResponse buildListOperationsResponse() {
final o = api.ListOperationsResponse();
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
o.nextPageToken = 'foo';
o.operations = buildUnnamed11();
}
buildCounterListOperationsResponse--;
return o;
}
void checkListOperationsResponse(api.ListOperationsResponse o) {
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed11(o.operations!);
}
buildCounterListOperationsResponse--;
}
core.List<api.LogSink> buildUnnamed12() => [
buildLogSink(),
buildLogSink(),
];
void checkUnnamed12(core.List<api.LogSink> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogSink(o[0]);
checkLogSink(o[1]);
}
core.int buildCounterListSinksResponse = 0;
api.ListSinksResponse buildListSinksResponse() {
final o = api.ListSinksResponse();
buildCounterListSinksResponse++;
if (buildCounterListSinksResponse < 3) {
o.nextPageToken = 'foo';
o.sinks = buildUnnamed12();
}
buildCounterListSinksResponse--;
return o;
}
void checkListSinksResponse(api.ListSinksResponse o) {
buildCounterListSinksResponse++;
if (buildCounterListSinksResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed12(o.sinks!);
}
buildCounterListSinksResponse--;
}
core.List<api.LogView> buildUnnamed13() => [
buildLogView(),
buildLogView(),
];
void checkUnnamed13(core.List<api.LogView> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogView(o[0]);
checkLogView(o[1]);
}
core.int buildCounterListViewsResponse = 0;
api.ListViewsResponse buildListViewsResponse() {
final o = api.ListViewsResponse();
buildCounterListViewsResponse++;
if (buildCounterListViewsResponse < 3) {
o.nextPageToken = 'foo';
o.views = buildUnnamed13();
}
buildCounterListViewsResponse--;
return o;
}
void checkListViewsResponse(api.ListViewsResponse o) {
buildCounterListViewsResponse++;
if (buildCounterListViewsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed13(o.views!);
}
buildCounterListViewsResponse--;
}
core.Map<core.String, core.String> buildUnnamed14() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed14(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed15() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed15(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.int buildCounterLocation = 0;
api.Location buildLocation() {
final o = api.Location();
buildCounterLocation++;
if (buildCounterLocation < 3) {
o.displayName = 'foo';
o.labels = buildUnnamed14();
o.locationId = 'foo';
o.metadata = buildUnnamed15();
o.name = 'foo';
}
buildCounterLocation--;
return o;
}
void checkLocation(api.Location o) {
buildCounterLocation++;
if (buildCounterLocation < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed14(o.labels!);
unittest.expect(
o.locationId!,
unittest.equals('foo'),
);
checkUnnamed15(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLocation--;
}
core.List<api.IndexConfig> buildUnnamed16() => [
buildIndexConfig(),
buildIndexConfig(),
];
void checkUnnamed16(core.List<api.IndexConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkIndexConfig(o[0]);
checkIndexConfig(o[1]);
}
core.List<core.String> buildUnnamed17() => [
'foo',
'foo',
];
void checkUnnamed17(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterLogBucket = 0;
api.LogBucket buildLogBucket() {
final o = api.LogBucket();
buildCounterLogBucket++;
if (buildCounterLogBucket < 3) {
o.analyticsEnabled = true;
o.cmekSettings = buildCmekSettings();
o.createTime = 'foo';
o.description = 'foo';
o.indexConfigs = buildUnnamed16();
o.lifecycleState = 'foo';
o.locked = true;
o.name = 'foo';
o.restrictedFields = buildUnnamed17();
o.retentionDays = 42;
o.updateTime = 'foo';
}
buildCounterLogBucket--;
return o;
}
void checkLogBucket(api.LogBucket o) {
buildCounterLogBucket++;
if (buildCounterLogBucket < 3) {
unittest.expect(o.analyticsEnabled!, unittest.isTrue);
checkCmekSettings(o.cmekSettings!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkUnnamed16(o.indexConfigs!);
unittest.expect(
o.lifecycleState!,
unittest.equals('foo'),
);
unittest.expect(o.locked!, unittest.isTrue);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed17(o.restrictedFields!);
unittest.expect(
o.retentionDays!,
unittest.equals(42),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterLogBucket--;
}
core.Map<core.String, core.Object?> buildUnnamed18() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed18(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted3 = (o['x']!) as core.Map;
unittest.expect(casted3, unittest.hasLength(3));
unittest.expect(
casted3['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted3['bool'],
unittest.equals(true),
);
unittest.expect(
casted3['string'],
unittest.equals('foo'),
);
var casted4 = (o['y']!) as core.Map;
unittest.expect(casted4, unittest.hasLength(3));
unittest.expect(
casted4['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted4['bool'],
unittest.equals(true),
);
unittest.expect(
casted4['string'],
unittest.equals('foo'),
);
}
core.Map<core.String, core.String> buildUnnamed19() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed19(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed20() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed20(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted5 = (o['x']!) as core.Map;
unittest.expect(casted5, unittest.hasLength(3));
unittest.expect(
casted5['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted5['bool'],
unittest.equals(true),
);
unittest.expect(
casted5['string'],
unittest.equals('foo'),
);
var casted6 = (o['y']!) as core.Map;
unittest.expect(casted6, unittest.hasLength(3));
unittest.expect(
casted6['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted6['bool'],
unittest.equals(true),
);
unittest.expect(
casted6['string'],
unittest.equals('foo'),
);
}
core.int buildCounterLogEntry = 0;
api.LogEntry buildLogEntry() {
final o = api.LogEntry();
buildCounterLogEntry++;
if (buildCounterLogEntry < 3) {
o.httpRequest = buildHttpRequest();
o.insertId = 'foo';
o.jsonPayload = buildUnnamed18();
o.labels = buildUnnamed19();
o.logName = 'foo';
o.metadata = buildMonitoredResourceMetadata();
o.operation = buildLogEntryOperation();
o.protoPayload = buildUnnamed20();
o.receiveTimestamp = 'foo';
o.resource = buildMonitoredResource();
o.severity = 'foo';
o.sourceLocation = buildLogEntrySourceLocation();
o.spanId = 'foo';
o.split = buildLogSplit();
o.textPayload = 'foo';
o.timestamp = 'foo';
o.trace = 'foo';
o.traceSampled = true;
}
buildCounterLogEntry--;
return o;
}
void checkLogEntry(api.LogEntry o) {
buildCounterLogEntry++;
if (buildCounterLogEntry < 3) {
checkHttpRequest(o.httpRequest!);
unittest.expect(
o.insertId!,
unittest.equals('foo'),
);
checkUnnamed18(o.jsonPayload!);
checkUnnamed19(o.labels!);
unittest.expect(
o.logName!,
unittest.equals('foo'),
);
checkMonitoredResourceMetadata(o.metadata!);
checkLogEntryOperation(o.operation!);
checkUnnamed20(o.protoPayload!);
unittest.expect(
o.receiveTimestamp!,
unittest.equals('foo'),
);
checkMonitoredResource(o.resource!);
unittest.expect(
o.severity!,
unittest.equals('foo'),
);
checkLogEntrySourceLocation(o.sourceLocation!);
unittest.expect(
o.spanId!,
unittest.equals('foo'),
);
checkLogSplit(o.split!);
unittest.expect(
o.textPayload!,
unittest.equals('foo'),
);
unittest.expect(
o.timestamp!,
unittest.equals('foo'),
);
unittest.expect(
o.trace!,
unittest.equals('foo'),
);
unittest.expect(o.traceSampled!, unittest.isTrue);
}
buildCounterLogEntry--;
}
core.int buildCounterLogEntryOperation = 0;
api.LogEntryOperation buildLogEntryOperation() {
final o = api.LogEntryOperation();
buildCounterLogEntryOperation++;
if (buildCounterLogEntryOperation < 3) {
o.first = true;
o.id = 'foo';
o.last = true;
o.producer = 'foo';
}
buildCounterLogEntryOperation--;
return o;
}
void checkLogEntryOperation(api.LogEntryOperation o) {
buildCounterLogEntryOperation++;
if (buildCounterLogEntryOperation < 3) {
unittest.expect(o.first!, unittest.isTrue);
unittest.expect(
o.id!,
unittest.equals('foo'),
);
unittest.expect(o.last!, unittest.isTrue);
unittest.expect(
o.producer!,
unittest.equals('foo'),
);
}
buildCounterLogEntryOperation--;
}
core.int buildCounterLogEntrySourceLocation = 0;
api.LogEntrySourceLocation buildLogEntrySourceLocation() {
final o = api.LogEntrySourceLocation();
buildCounterLogEntrySourceLocation++;
if (buildCounterLogEntrySourceLocation < 3) {
o.file = 'foo';
o.function = 'foo';
o.line = 'foo';
}
buildCounterLogEntrySourceLocation--;
return o;
}
void checkLogEntrySourceLocation(api.LogEntrySourceLocation o) {
buildCounterLogEntrySourceLocation++;
if (buildCounterLogEntrySourceLocation < 3) {
unittest.expect(
o.file!,
unittest.equals('foo'),
);
unittest.expect(
o.function!,
unittest.equals('foo'),
);
unittest.expect(
o.line!,
unittest.equals('foo'),
);
}
buildCounterLogEntrySourceLocation--;
}
core.int buildCounterLogExclusion = 0;
api.LogExclusion buildLogExclusion() {
final o = api.LogExclusion();
buildCounterLogExclusion++;
if (buildCounterLogExclusion < 3) {
o.createTime = 'foo';
o.description = 'foo';
o.disabled = true;
o.filter = 'foo';
o.name = 'foo';
o.updateTime = 'foo';
}
buildCounterLogExclusion--;
return o;
}
void checkLogExclusion(api.LogExclusion o) {
buildCounterLogExclusion++;
if (buildCounterLogExclusion < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(o.disabled!, unittest.isTrue);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterLogExclusion--;
}
core.Map<core.String, core.String> buildUnnamed21() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed21(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterLogMetric = 0;
api.LogMetric buildLogMetric() {
final o = api.LogMetric();
buildCounterLogMetric++;
if (buildCounterLogMetric < 3) {
o.bucketName = 'foo';
o.bucketOptions = buildBucketOptions();
o.createTime = 'foo';
o.description = 'foo';
o.disabled = true;
o.filter = 'foo';
o.labelExtractors = buildUnnamed21();
o.metricDescriptor = buildMetricDescriptor();
o.name = 'foo';
o.updateTime = 'foo';
o.valueExtractor = 'foo';
o.version = 'foo';
}
buildCounterLogMetric--;
return o;
}
void checkLogMetric(api.LogMetric o) {
buildCounterLogMetric++;
if (buildCounterLogMetric < 3) {
unittest.expect(
o.bucketName!,
unittest.equals('foo'),
);
checkBucketOptions(o.bucketOptions!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(o.disabled!, unittest.isTrue);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
checkUnnamed21(o.labelExtractors!);
checkMetricDescriptor(o.metricDescriptor!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.valueExtractor!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals('foo'),
);
}
buildCounterLogMetric--;
}
core.List<api.LogExclusion> buildUnnamed22() => [
buildLogExclusion(),
buildLogExclusion(),
];
void checkUnnamed22(core.List<api.LogExclusion> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogExclusion(o[0]);
checkLogExclusion(o[1]);
}
core.int buildCounterLogSink = 0;
api.LogSink buildLogSink() {
final o = api.LogSink();
buildCounterLogSink++;
if (buildCounterLogSink < 3) {
o.bigqueryOptions = buildBigQueryOptions();
o.createTime = 'foo';
o.description = 'foo';
o.destination = 'foo';
o.disabled = true;
o.exclusions = buildUnnamed22();
o.filter = 'foo';
o.includeChildren = true;
o.name = 'foo';
o.outputVersionFormat = 'foo';
o.updateTime = 'foo';
o.writerIdentity = 'foo';
}
buildCounterLogSink--;
return o;
}
void checkLogSink(api.LogSink o) {
buildCounterLogSink++;
if (buildCounterLogSink < 3) {
checkBigQueryOptions(o.bigqueryOptions!);
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.destination!,
unittest.equals('foo'),
);
unittest.expect(o.disabled!, unittest.isTrue);
checkUnnamed22(o.exclusions!);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
unittest.expect(o.includeChildren!, unittest.isTrue);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.outputVersionFormat!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
unittest.expect(
o.writerIdentity!,
unittest.equals('foo'),
);
}
buildCounterLogSink--;
}
core.int buildCounterLogSplit = 0;
api.LogSplit buildLogSplit() {
final o = api.LogSplit();
buildCounterLogSplit++;
if (buildCounterLogSplit < 3) {
o.index = 42;
o.totalSplits = 42;
o.uid = 'foo';
}
buildCounterLogSplit--;
return o;
}
void checkLogSplit(api.LogSplit o) {
buildCounterLogSplit++;
if (buildCounterLogSplit < 3) {
unittest.expect(
o.index!,
unittest.equals(42),
);
unittest.expect(
o.totalSplits!,
unittest.equals(42),
);
unittest.expect(
o.uid!,
unittest.equals('foo'),
);
}
buildCounterLogSplit--;
}
core.int buildCounterLogView = 0;
api.LogView buildLogView() {
final o = api.LogView();
buildCounterLogView++;
if (buildCounterLogView < 3) {
o.createTime = 'foo';
o.description = 'foo';
o.filter = 'foo';
o.name = 'foo';
o.updateTime = 'foo';
}
buildCounterLogView--;
return o;
}
void checkLogView(api.LogView o) {
buildCounterLogView++;
if (buildCounterLogView < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterLogView--;
}
core.List<api.LabelDescriptor> buildUnnamed23() => [
buildLabelDescriptor(),
buildLabelDescriptor(),
];
void checkUnnamed23(core.List<api.LabelDescriptor> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabelDescriptor(o[0]);
checkLabelDescriptor(o[1]);
}
core.List<core.String> buildUnnamed24() => [
'foo',
'foo',
];
void checkUnnamed24(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterMetricDescriptor = 0;
api.MetricDescriptor buildMetricDescriptor() {
final o = api.MetricDescriptor();
buildCounterMetricDescriptor++;
if (buildCounterMetricDescriptor < 3) {
o.description = 'foo';
o.displayName = 'foo';
o.labels = buildUnnamed23();
o.launchStage = 'foo';
o.metadata = buildMetricDescriptorMetadata();
o.metricKind = 'foo';
o.monitoredResourceTypes = buildUnnamed24();
o.name = 'foo';
o.type = 'foo';
o.unit = 'foo';
o.valueType = 'foo';
}
buildCounterMetricDescriptor--;
return o;
}
void checkMetricDescriptor(api.MetricDescriptor o) {
buildCounterMetricDescriptor++;
if (buildCounterMetricDescriptor < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed23(o.labels!);
unittest.expect(
o.launchStage!,
unittest.equals('foo'),
);
checkMetricDescriptorMetadata(o.metadata!);
unittest.expect(
o.metricKind!,
unittest.equals('foo'),
);
checkUnnamed24(o.monitoredResourceTypes!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
unittest.expect(
o.unit!,
unittest.equals('foo'),
);
unittest.expect(
o.valueType!,
unittest.equals('foo'),
);
}
buildCounterMetricDescriptor--;
}
core.int buildCounterMetricDescriptorMetadata = 0;
api.MetricDescriptorMetadata buildMetricDescriptorMetadata() {
final o = api.MetricDescriptorMetadata();
buildCounterMetricDescriptorMetadata++;
if (buildCounterMetricDescriptorMetadata < 3) {
o.ingestDelay = 'foo';
o.launchStage = 'foo';
o.samplePeriod = 'foo';
}
buildCounterMetricDescriptorMetadata--;
return o;
}
void checkMetricDescriptorMetadata(api.MetricDescriptorMetadata o) {
buildCounterMetricDescriptorMetadata++;
if (buildCounterMetricDescriptorMetadata < 3) {
unittest.expect(
o.ingestDelay!,
unittest.equals('foo'),
);
unittest.expect(
o.launchStage!,
unittest.equals('foo'),
);
unittest.expect(
o.samplePeriod!,
unittest.equals('foo'),
);
}
buildCounterMetricDescriptorMetadata--;
}
core.Map<core.String, core.String> buildUnnamed25() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed25(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterMonitoredResource = 0;
api.MonitoredResource buildMonitoredResource() {
final o = api.MonitoredResource();
buildCounterMonitoredResource++;
if (buildCounterMonitoredResource < 3) {
o.labels = buildUnnamed25();
o.type = 'foo';
}
buildCounterMonitoredResource--;
return o;
}
void checkMonitoredResource(api.MonitoredResource o) {
buildCounterMonitoredResource++;
if (buildCounterMonitoredResource < 3) {
checkUnnamed25(o.labels!);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterMonitoredResource--;
}
core.List<api.LabelDescriptor> buildUnnamed26() => [
buildLabelDescriptor(),
buildLabelDescriptor(),
];
void checkUnnamed26(core.List<api.LabelDescriptor> o) {
unittest.expect(o, unittest.hasLength(2));
checkLabelDescriptor(o[0]);
checkLabelDescriptor(o[1]);
}
core.int buildCounterMonitoredResourceDescriptor = 0;
api.MonitoredResourceDescriptor buildMonitoredResourceDescriptor() {
final o = api.MonitoredResourceDescriptor();
buildCounterMonitoredResourceDescriptor++;
if (buildCounterMonitoredResourceDescriptor < 3) {
o.description = 'foo';
o.displayName = 'foo';
o.labels = buildUnnamed26();
o.launchStage = 'foo';
o.name = 'foo';
o.type = 'foo';
}
buildCounterMonitoredResourceDescriptor--;
return o;
}
void checkMonitoredResourceDescriptor(api.MonitoredResourceDescriptor o) {
buildCounterMonitoredResourceDescriptor++;
if (buildCounterMonitoredResourceDescriptor < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed26(o.labels!);
unittest.expect(
o.launchStage!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.type!,
unittest.equals('foo'),
);
}
buildCounterMonitoredResourceDescriptor--;
}
core.Map<core.String, core.Object?> buildUnnamed27() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed27(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted7 = (o['x']!) as core.Map;
unittest.expect(casted7, unittest.hasLength(3));
unittest.expect(
casted7['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted7['bool'],
unittest.equals(true),
);
unittest.expect(
casted7['string'],
unittest.equals('foo'),
);
var casted8 = (o['y']!) as core.Map;
unittest.expect(casted8, unittest.hasLength(3));
unittest.expect(
casted8['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted8['bool'],
unittest.equals(true),
);
unittest.expect(
casted8['string'],
unittest.equals('foo'),
);
}
core.Map<core.String, core.String> buildUnnamed28() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed28(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterMonitoredResourceMetadata = 0;
api.MonitoredResourceMetadata buildMonitoredResourceMetadata() {
final o = api.MonitoredResourceMetadata();
buildCounterMonitoredResourceMetadata++;
if (buildCounterMonitoredResourceMetadata < 3) {
o.systemLabels = buildUnnamed27();
o.userLabels = buildUnnamed28();
}
buildCounterMonitoredResourceMetadata--;
return o;
}
void checkMonitoredResourceMetadata(api.MonitoredResourceMetadata o) {
buildCounterMonitoredResourceMetadata++;
if (buildCounterMonitoredResourceMetadata < 3) {
checkUnnamed27(o.systemLabels!);
checkUnnamed28(o.userLabels!);
}
buildCounterMonitoredResourceMetadata--;
}
core.Map<core.String, core.Object?> buildUnnamed29() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed29(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted9 = (o['x']!) as core.Map;
unittest.expect(casted9, unittest.hasLength(3));
unittest.expect(
casted9['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted9['bool'],
unittest.equals(true),
);
unittest.expect(
casted9['string'],
unittest.equals('foo'),
);
var casted10 = (o['y']!) as core.Map;
unittest.expect(casted10, unittest.hasLength(3));
unittest.expect(
casted10['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted10['bool'],
unittest.equals(true),
);
unittest.expect(
casted10['string'],
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed30() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed30(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted11 = (o['x']!) as core.Map;
unittest.expect(casted11, unittest.hasLength(3));
unittest.expect(
casted11['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted11['bool'],
unittest.equals(true),
);
unittest.expect(
casted11['string'],
unittest.equals('foo'),
);
var casted12 = (o['y']!) as core.Map;
unittest.expect(casted12, unittest.hasLength(3));
unittest.expect(
casted12['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted12['bool'],
unittest.equals(true),
);
unittest.expect(
casted12['string'],
unittest.equals('foo'),
);
}
core.int buildCounterOperation = 0;
api.Operation buildOperation() {
final o = api.Operation();
buildCounterOperation++;
if (buildCounterOperation < 3) {
o.done = true;
o.error = buildStatus();
o.metadata = buildUnnamed29();
o.name = 'foo';
o.response = buildUnnamed30();
}
buildCounterOperation--;
return o;
}
void checkOperation(api.Operation o) {
buildCounterOperation++;
if (buildCounterOperation < 3) {
unittest.expect(o.done!, unittest.isTrue);
checkStatus(o.error!);
checkUnnamed29(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed30(o.response!);
}
buildCounterOperation--;
}
core.int buildCounterSettings = 0;
api.Settings buildSettings() {
final o = api.Settings();
buildCounterSettings++;
if (buildCounterSettings < 3) {
o.disableDefaultSink = true;
o.kmsKeyName = 'foo';
o.kmsServiceAccountId = 'foo';
o.loggingServiceAccountId = 'foo';
o.name = 'foo';
o.storageLocation = 'foo';
}
buildCounterSettings--;
return o;
}
void checkSettings(api.Settings o) {
buildCounterSettings++;
if (buildCounterSettings < 3) {
unittest.expect(o.disableDefaultSink!, unittest.isTrue);
unittest.expect(
o.kmsKeyName!,
unittest.equals('foo'),
);
unittest.expect(
o.kmsServiceAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.loggingServiceAccountId!,
unittest.equals('foo'),
);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.storageLocation!,
unittest.equals('foo'),
);
}
buildCounterSettings--;
}
core.Map<core.String, core.Object?> buildUnnamed31() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed31(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted13 = (o['x']!) as core.Map;
unittest.expect(casted13, unittest.hasLength(3));
unittest.expect(
casted13['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted13['bool'],
unittest.equals(true),
);
unittest.expect(
casted13['string'],
unittest.equals('foo'),
);
var casted14 = (o['y']!) as core.Map;
unittest.expect(casted14, unittest.hasLength(3));
unittest.expect(
casted14['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted14['bool'],
unittest.equals(true),
);
unittest.expect(
casted14['string'],
unittest.equals('foo'),
);
}
core.List<core.Map<core.String, core.Object?>> buildUnnamed32() => [
buildUnnamed31(),
buildUnnamed31(),
];
void checkUnnamed32(core.List<core.Map<core.String, core.Object?>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed31(o[0]);
checkUnnamed31(o[1]);
}
core.int buildCounterStatus = 0;
api.Status buildStatus() {
final o = api.Status();
buildCounterStatus++;
if (buildCounterStatus < 3) {
o.code = 42;
o.details = buildUnnamed32();
o.message = 'foo';
}
buildCounterStatus--;
return o;
}
void checkStatus(api.Status o) {
buildCounterStatus++;
if (buildCounterStatus < 3) {
unittest.expect(
o.code!,
unittest.equals(42),
);
checkUnnamed32(o.details!);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterStatus--;
}
core.int buildCounterSuppressionInfo = 0;
api.SuppressionInfo buildSuppressionInfo() {
final o = api.SuppressionInfo();
buildCounterSuppressionInfo++;
if (buildCounterSuppressionInfo < 3) {
o.reason = 'foo';
o.suppressedCount = 42;
}
buildCounterSuppressionInfo--;
return o;
}
void checkSuppressionInfo(api.SuppressionInfo o) {
buildCounterSuppressionInfo++;
if (buildCounterSuppressionInfo < 3) {
unittest.expect(
o.reason!,
unittest.equals('foo'),
);
unittest.expect(
o.suppressedCount!,
unittest.equals(42),
);
}
buildCounterSuppressionInfo--;
}
core.List<core.String> buildUnnamed33() => [
'foo',
'foo',
];
void checkUnnamed33(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTailLogEntriesRequest = 0;
api.TailLogEntriesRequest buildTailLogEntriesRequest() {
final o = api.TailLogEntriesRequest();
buildCounterTailLogEntriesRequest++;
if (buildCounterTailLogEntriesRequest < 3) {
o.bufferWindow = 'foo';
o.filter = 'foo';
o.resourceNames = buildUnnamed33();
}
buildCounterTailLogEntriesRequest--;
return o;
}
void checkTailLogEntriesRequest(api.TailLogEntriesRequest o) {
buildCounterTailLogEntriesRequest++;
if (buildCounterTailLogEntriesRequest < 3) {
unittest.expect(
o.bufferWindow!,
unittest.equals('foo'),
);
unittest.expect(
o.filter!,
unittest.equals('foo'),
);
checkUnnamed33(o.resourceNames!);
}
buildCounterTailLogEntriesRequest--;
}
core.List<api.LogEntry> buildUnnamed34() => [
buildLogEntry(),
buildLogEntry(),
];
void checkUnnamed34(core.List<api.LogEntry> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogEntry(o[0]);
checkLogEntry(o[1]);
}
core.List<api.SuppressionInfo> buildUnnamed35() => [
buildSuppressionInfo(),
buildSuppressionInfo(),
];
void checkUnnamed35(core.List<api.SuppressionInfo> o) {
unittest.expect(o, unittest.hasLength(2));
checkSuppressionInfo(o[0]);
checkSuppressionInfo(o[1]);
}
core.int buildCounterTailLogEntriesResponse = 0;
api.TailLogEntriesResponse buildTailLogEntriesResponse() {
final o = api.TailLogEntriesResponse();
buildCounterTailLogEntriesResponse++;
if (buildCounterTailLogEntriesResponse < 3) {
o.entries = buildUnnamed34();
o.suppressionInfo = buildUnnamed35();
}
buildCounterTailLogEntriesResponse--;
return o;
}
void checkTailLogEntriesResponse(api.TailLogEntriesResponse o) {
buildCounterTailLogEntriesResponse++;
if (buildCounterTailLogEntriesResponse < 3) {
checkUnnamed34(o.entries!);
checkUnnamed35(o.suppressionInfo!);
}
buildCounterTailLogEntriesResponse--;
}
core.int buildCounterUndeleteBucketRequest = 0;
api.UndeleteBucketRequest buildUndeleteBucketRequest() {
final o = api.UndeleteBucketRequest();
buildCounterUndeleteBucketRequest++;
if (buildCounterUndeleteBucketRequest < 3) {}
buildCounterUndeleteBucketRequest--;
return o;
}
void checkUndeleteBucketRequest(api.UndeleteBucketRequest o) {
buildCounterUndeleteBucketRequest++;
if (buildCounterUndeleteBucketRequest < 3) {}
buildCounterUndeleteBucketRequest--;
}
core.List<api.LogEntry> buildUnnamed36() => [
buildLogEntry(),
buildLogEntry(),
];
void checkUnnamed36(core.List<api.LogEntry> o) {
unittest.expect(o, unittest.hasLength(2));
checkLogEntry(o[0]);
checkLogEntry(o[1]);
}
core.Map<core.String, core.String> buildUnnamed37() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed37(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.int buildCounterWriteLogEntriesRequest = 0;
api.WriteLogEntriesRequest buildWriteLogEntriesRequest() {
final o = api.WriteLogEntriesRequest();
buildCounterWriteLogEntriesRequest++;
if (buildCounterWriteLogEntriesRequest < 3) {
o.dryRun = true;
o.entries = buildUnnamed36();
o.labels = buildUnnamed37();
o.logName = 'foo';
o.partialSuccess = true;
o.resource = buildMonitoredResource();
}
buildCounterWriteLogEntriesRequest--;
return o;
}
void checkWriteLogEntriesRequest(api.WriteLogEntriesRequest o) {
buildCounterWriteLogEntriesRequest++;
if (buildCounterWriteLogEntriesRequest < 3) {
unittest.expect(o.dryRun!, unittest.isTrue);
checkUnnamed36(o.entries!);
checkUnnamed37(o.labels!);
unittest.expect(
o.logName!,
unittest.equals('foo'),
);
unittest.expect(o.partialSuccess!, unittest.isTrue);
checkMonitoredResource(o.resource!);
}
buildCounterWriteLogEntriesRequest--;
}
core.int buildCounterWriteLogEntriesResponse = 0;
api.WriteLogEntriesResponse buildWriteLogEntriesResponse() {
final o = api.WriteLogEntriesResponse();
buildCounterWriteLogEntriesResponse++;
if (buildCounterWriteLogEntriesResponse < 3) {}
buildCounterWriteLogEntriesResponse--;
return o;
}
void checkWriteLogEntriesResponse(api.WriteLogEntriesResponse o) {
buildCounterWriteLogEntriesResponse++;
if (buildCounterWriteLogEntriesResponse < 3) {}
buildCounterWriteLogEntriesResponse--;
}
core.List<core.String> buildUnnamed38() => [
'foo',
'foo',
];
void checkUnnamed38(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed39() => [
'foo',
'foo',
];
void checkUnnamed39(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed40() => [
'foo',
'foo',
];
void checkUnnamed40(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed41() => [
'foo',
'foo',
];
void checkUnnamed41(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed42() => [
'foo',
'foo',
];
void checkUnnamed42(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed43() => [
'foo',
'foo',
];
void checkUnnamed43(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed44() => [
'foo',
'foo',
];
void checkUnnamed44(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed45() => [
'foo',
'foo',
];
void checkUnnamed45(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed46() => [
'foo',
'foo',
];
void checkUnnamed46(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
void main() {
unittest.group('obj-schema-BigQueryDataset', () {
unittest.test('to-json--from-json', () async {
final o = buildBigQueryDataset();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BigQueryDataset.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBigQueryDataset(od);
});
});
unittest.group('obj-schema-BigQueryOptions', () {
unittest.test('to-json--from-json', () async {
final o = buildBigQueryOptions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BigQueryOptions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBigQueryOptions(od);
});
});
unittest.group('obj-schema-BucketOptions', () {
unittest.test('to-json--from-json', () async {
final o = buildBucketOptions();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.BucketOptions.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkBucketOptions(od);
});
});
unittest.group('obj-schema-CancelOperationRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCancelOperationRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CancelOperationRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(od);
});
});
unittest.group('obj-schema-CmekSettings', () {
unittest.test('to-json--from-json', () async {
final o = buildCmekSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CmekSettings.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCmekSettings(od);
});
});
unittest.group('obj-schema-CopyLogEntriesRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCopyLogEntriesRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CopyLogEntriesRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCopyLogEntriesRequest(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-Explicit', () {
unittest.test('to-json--from-json', () async {
final o = buildExplicit();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Explicit.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkExplicit(od);
});
});
unittest.group('obj-schema-Exponential', () {
unittest.test('to-json--from-json', () async {
final o = buildExponential();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.Exponential.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkExponential(od);
});
});
unittest.group('obj-schema-HttpRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildHttpRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.HttpRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkHttpRequest(od);
});
});
unittest.group('obj-schema-IndexConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildIndexConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.IndexConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkIndexConfig(od);
});
});
unittest.group('obj-schema-LabelDescriptor', () {
unittest.test('to-json--from-json', () async {
final o = buildLabelDescriptor();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LabelDescriptor.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLabelDescriptor(od);
});
});
unittest.group('obj-schema-Linear', () {
unittest.test('to-json--from-json', () async {
final o = buildLinear();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Linear.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLinear(od);
});
});
unittest.group('obj-schema-Link', () {
unittest.test('to-json--from-json', () async {
final o = buildLink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Link.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLink(od);
});
});
unittest.group('obj-schema-ListBucketsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListBucketsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListBucketsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListBucketsResponse(od);
});
});
unittest.group('obj-schema-ListExclusionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListExclusionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListExclusionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListExclusionsResponse(od);
});
});
unittest.group('obj-schema-ListLinksResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLinksResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLinksResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLinksResponse(od);
});
});
unittest.group('obj-schema-ListLocationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLocationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLocationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLocationsResponse(od);
});
});
unittest.group('obj-schema-ListLogEntriesRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildListLogEntriesRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLogEntriesRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLogEntriesRequest(od);
});
});
unittest.group('obj-schema-ListLogEntriesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLogEntriesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLogEntriesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLogEntriesResponse(od);
});
});
unittest.group('obj-schema-ListLogMetricsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLogMetricsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLogMetricsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLogMetricsResponse(od);
});
});
unittest.group('obj-schema-ListLogsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLogsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLogsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLogsResponse(od);
});
});
unittest.group('obj-schema-ListMonitoredResourceDescriptorsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListMonitoredResourceDescriptorsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListMonitoredResourceDescriptorsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListMonitoredResourceDescriptorsResponse(od);
});
});
unittest.group('obj-schema-ListOperationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListOperationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListOperationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListOperationsResponse(od);
});
});
unittest.group('obj-schema-ListSinksResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListSinksResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListSinksResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListSinksResponse(od);
});
});
unittest.group('obj-schema-ListViewsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListViewsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListViewsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListViewsResponse(od);
});
});
unittest.group('obj-schema-Location', () {
unittest.test('to-json--from-json', () async {
final o = buildLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Location.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLocation(od);
});
});
unittest.group('obj-schema-LogBucket', () {
unittest.test('to-json--from-json', () async {
final o = buildLogBucket();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogBucket.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogBucket(od);
});
});
unittest.group('obj-schema-LogEntry', () {
unittest.test('to-json--from-json', () async {
final o = buildLogEntry();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogEntry.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogEntry(od);
});
});
unittest.group('obj-schema-LogEntryOperation', () {
unittest.test('to-json--from-json', () async {
final o = buildLogEntryOperation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LogEntryOperation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLogEntryOperation(od);
});
});
unittest.group('obj-schema-LogEntrySourceLocation', () {
unittest.test('to-json--from-json', () async {
final o = buildLogEntrySourceLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LogEntrySourceLocation.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLogEntrySourceLocation(od);
});
});
unittest.group('obj-schema-LogExclusion', () {
unittest.test('to-json--from-json', () async {
final o = buildLogExclusion();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LogExclusion.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLogExclusion(od);
});
});
unittest.group('obj-schema-LogMetric', () {
unittest.test('to-json--from-json', () async {
final o = buildLogMetric();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogMetric.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogMetric(od);
});
});
unittest.group('obj-schema-LogSink', () {
unittest.test('to-json--from-json', () async {
final o = buildLogSink();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogSink.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogSink(od);
});
});
unittest.group('obj-schema-LogSplit', () {
unittest.test('to-json--from-json', () async {
final o = buildLogSplit();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogSplit.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogSplit(od);
});
});
unittest.group('obj-schema-LogView', () {
unittest.test('to-json--from-json', () async {
final o = buildLogView();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.LogView.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLogView(od);
});
});
unittest.group('obj-schema-MetricDescriptor', () {
unittest.test('to-json--from-json', () async {
final o = buildMetricDescriptor();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MetricDescriptor.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMetricDescriptor(od);
});
});
unittest.group('obj-schema-MetricDescriptorMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildMetricDescriptorMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MetricDescriptorMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMetricDescriptorMetadata(od);
});
});
unittest.group('obj-schema-MonitoredResource', () {
unittest.test('to-json--from-json', () async {
final o = buildMonitoredResource();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MonitoredResource.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMonitoredResource(od);
});
});
unittest.group('obj-schema-MonitoredResourceDescriptor', () {
unittest.test('to-json--from-json', () async {
final o = buildMonitoredResourceDescriptor();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MonitoredResourceDescriptor.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMonitoredResourceDescriptor(od);
});
});
unittest.group('obj-schema-MonitoredResourceMetadata', () {
unittest.test('to-json--from-json', () async {
final o = buildMonitoredResourceMetadata();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.MonitoredResourceMetadata.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkMonitoredResourceMetadata(od);
});
});
unittest.group('obj-schema-Operation', () {
unittest.test('to-json--from-json', () async {
final o = buildOperation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Operation.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOperation(od);
});
});
unittest.group('obj-schema-Settings', () {
unittest.test('to-json--from-json', () async {
final o = buildSettings();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Settings.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkSettings(od);
});
});
unittest.group('obj-schema-Status', () {
unittest.test('to-json--from-json', () async {
final o = buildStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Status.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkStatus(od);
});
});
unittest.group('obj-schema-SuppressionInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildSuppressionInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SuppressionInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSuppressionInfo(od);
});
});
unittest.group('obj-schema-TailLogEntriesRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildTailLogEntriesRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TailLogEntriesRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTailLogEntriesRequest(od);
});
});
unittest.group('obj-schema-TailLogEntriesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTailLogEntriesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TailLogEntriesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTailLogEntriesResponse(od);
});
});
unittest.group('obj-schema-UndeleteBucketRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildUndeleteBucketRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.UndeleteBucketRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(od);
});
});
unittest.group('obj-schema-WriteLogEntriesRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildWriteLogEntriesRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WriteLogEntriesRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWriteLogEntriesRequest(od);
});
});
unittest.group('obj-schema-WriteLogEntriesResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildWriteLogEntriesResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.WriteLogEntriesResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkWriteLogEntriesResponse(od);
});
});
unittest.group('resource-BillingAccountsResource', () {
unittest.test('method--getCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getCmekSettings(arg_name, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--getSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSettings(arg_name, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
});
unittest.group('resource-BillingAccountsExclusionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.exclusions;
final arg_request = buildLogExclusion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.exclusions;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListExclusionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListExclusionsResponse(response as api.ListExclusionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.exclusions;
final arg_request = buildLogExclusion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
});
unittest.group('resource-BillingAccountsLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-BillingAccountsLocationsBucketsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--createAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.createAsync(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListBucketsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListBucketsResponse(response as api.ListBucketsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--undelete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_request = buildUndeleteBucketRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UndeleteBucketRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.undelete(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--updateAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateAsync(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-BillingAccountsLocationsBucketsLinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.links;
final arg_request = buildLink();
final arg_parent = 'foo';
final arg_linkId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Link.fromJson(json as core.Map<core.String, core.dynamic>);
checkLink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['linkId']!.first,
unittest.equals(arg_linkId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
linkId: arg_linkId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLink(response as api.Link);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.links;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinksResponse(response as api.ListLinksResponse);
});
});
unittest.group('resource-BillingAccountsLocationsBucketsViewsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.views;
final arg_request = buildLogView();
final arg_parent = 'foo';
final arg_viewId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['viewId']!.first,
unittest.equals(arg_viewId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
viewId: arg_viewId, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.views;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListViewsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListViewsResponse(response as api.ListViewsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.buckets.views;
final arg_request = buildLogView();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
});
unittest.group('resource-BillingAccountsLocationsBucketsViewsLogsResource',
() {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res =
api.LoggingApi(mock).billingAccounts.locations.buckets.views.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed38();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-BillingAccountsLocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.locations.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-BillingAccountsLogsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.logs;
final arg_logName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_logName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed39();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-BillingAccountsSinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_request = buildLogSink();
final arg_parent = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_sinkName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_sinkName, $fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSinksResponse(response as api.ListSinksResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).billingAccounts.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
});
unittest.group('resource-EntriesResource', () {
unittest.test('method--copy', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).entries;
final arg_request = buildCopyLogEntriesRequest();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CopyLogEntriesRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCopyLogEntriesRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 15),
unittest.equals('v2/entries:copy'),
);
pathOffset += 15;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.copy(arg_request, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).entries;
final arg_request = buildListLogEntriesRequest();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ListLogEntriesRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkListLogEntriesRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 15),
unittest.equals('v2/entries:list'),
);
pathOffset += 15;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogEntriesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_request, $fields: arg_$fields);
checkListLogEntriesResponse(response as api.ListLogEntriesResponse);
});
unittest.test('method--tail', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).entries;
final arg_request = buildTailLogEntriesRequest();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TailLogEntriesRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTailLogEntriesRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 15),
unittest.equals('v2/entries:tail'),
);
pathOffset += 15;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTailLogEntriesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.tail(arg_request, $fields: arg_$fields);
checkTailLogEntriesResponse(response as api.TailLogEntriesResponse);
});
unittest.test('method--write', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).entries;
final arg_request = buildWriteLogEntriesRequest();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.WriteLogEntriesRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkWriteLogEntriesRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 16),
unittest.equals('v2/entries:write'),
);
pathOffset += 16;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildWriteLogEntriesResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.write(arg_request, $fields: arg_$fields);
checkWriteLogEntriesResponse(response as api.WriteLogEntriesResponse);
});
});
unittest.group('resource-ExclusionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).exclusions;
final arg_request = buildLogExclusion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).exclusions;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListExclusionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListExclusionsResponse(response as api.ListExclusionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).exclusions;
final arg_request = buildLogExclusion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
});
unittest.group('resource-FoldersResource', () {
unittest.test('method--getCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getCmekSettings(arg_name, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--getSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSettings(arg_name, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
unittest.test('method--updateSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders;
final arg_request = buildSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Settings.fromJson(json as core.Map<core.String, core.dynamic>);
checkSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
});
unittest.group('resource-FoldersExclusionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.exclusions;
final arg_request = buildLogExclusion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.exclusions;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListExclusionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListExclusionsResponse(response as api.ListExclusionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.exclusions;
final arg_request = buildLogExclusion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
});
unittest.group('resource-FoldersLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-FoldersLocationsBucketsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--createAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.createAsync(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListBucketsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListBucketsResponse(response as api.ListBucketsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--undelete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_request = buildUndeleteBucketRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UndeleteBucketRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.undelete(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--updateAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateAsync(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-FoldersLocationsBucketsLinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.links;
final arg_request = buildLink();
final arg_parent = 'foo';
final arg_linkId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Link.fromJson(json as core.Map<core.String, core.dynamic>);
checkLink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['linkId']!.first,
unittest.equals(arg_linkId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
linkId: arg_linkId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLink(response as api.Link);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.links;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinksResponse(response as api.ListLinksResponse);
});
});
unittest.group('resource-FoldersLocationsBucketsViewsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views;
final arg_request = buildLogView();
final arg_parent = 'foo';
final arg_viewId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['viewId']!.first,
unittest.equals(arg_viewId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
viewId: arg_viewId, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListViewsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListViewsResponse(response as api.ListViewsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views;
final arg_request = buildLogView();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
});
unittest.group('resource-FoldersLocationsBucketsViewsLogsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.buckets.views.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed40();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-FoldersLocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.locations.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-FoldersLogsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.logs;
final arg_logName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_logName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed41();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-FoldersSinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_request = buildLogSink();
final arg_parent = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_sinkName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_sinkName, $fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSinksResponse(response as api.ListSinksResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).folders.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
});
unittest.group('resource-LocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-LocationsBucketsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--createAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.createAsync(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListBucketsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListBucketsResponse(response as api.ListBucketsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--undelete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_request = buildUndeleteBucketRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UndeleteBucketRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.undelete(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--updateAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateAsync(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-LocationsBucketsLinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.links;
final arg_request = buildLink();
final arg_parent = 'foo';
final arg_linkId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Link.fromJson(json as core.Map<core.String, core.dynamic>);
checkLink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['linkId']!.first,
unittest.equals(arg_linkId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
linkId: arg_linkId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLink(response as api.Link);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.links;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinksResponse(response as api.ListLinksResponse);
});
});
unittest.group('resource-LocationsBucketsViewsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.views;
final arg_request = buildLogView();
final arg_parent = 'foo';
final arg_viewId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['viewId']!.first,
unittest.equals(arg_viewId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
viewId: arg_viewId, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.views;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListViewsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListViewsResponse(response as api.ListViewsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.buckets.views;
final arg_request = buildLogView();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
});
unittest.group('resource-LocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).locations.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-LogsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).logs;
final arg_logName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_logName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed42();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-MonitoredResourceDescriptorsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).monitoredResourceDescriptors;
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 31),
unittest.equals('v2/monitoredResourceDescriptors'),
);
pathOffset += 31;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json
.encode(buildListMonitoredResourceDescriptorsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListMonitoredResourceDescriptorsResponse(
response as api.ListMonitoredResourceDescriptorsResponse);
});
});
unittest.group('resource-OrganizationsResource', () {
unittest.test('method--getCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getCmekSettings(arg_name, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--getSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSettings(arg_name, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
unittest.test('method--updateCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations;
final arg_request = buildCmekSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CmekSettings.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCmekSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateCmekSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--updateSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations;
final arg_request = buildSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Settings.fromJson(json as core.Map<core.String, core.dynamic>);
checkSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
});
unittest.group('resource-OrganizationsExclusionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.exclusions;
final arg_request = buildLogExclusion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.exclusions;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListExclusionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListExclusionsResponse(response as api.ListExclusionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.exclusions;
final arg_request = buildLogExclusion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
});
unittest.group('resource-OrganizationsLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-OrganizationsLocationsBucketsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--createAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.createAsync(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListBucketsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListBucketsResponse(response as api.ListBucketsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--undelete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_request = buildUndeleteBucketRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UndeleteBucketRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.undelete(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--updateAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateAsync(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-OrganizationsLocationsBucketsLinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.links;
final arg_request = buildLink();
final arg_parent = 'foo';
final arg_linkId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Link.fromJson(json as core.Map<core.String, core.dynamic>);
checkLink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['linkId']!.first,
unittest.equals(arg_linkId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
linkId: arg_linkId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLink(response as api.Link);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.links;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinksResponse(response as api.ListLinksResponse);
});
});
unittest.group('resource-OrganizationsLocationsBucketsViewsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.views;
final arg_request = buildLogView();
final arg_parent = 'foo';
final arg_viewId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['viewId']!.first,
unittest.equals(arg_viewId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
viewId: arg_viewId, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.views;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListViewsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListViewsResponse(response as api.ListViewsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.buckets.views;
final arg_request = buildLogView();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
});
unittest.group('resource-OrganizationsLocationsBucketsViewsLogsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res =
api.LoggingApi(mock).organizations.locations.buckets.views.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed43();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-OrganizationsLocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.locations.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-OrganizationsLogsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.logs;
final arg_logName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_logName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed44();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-OrganizationsSinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_request = buildLogSink();
final arg_parent = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_sinkName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_sinkName, $fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSinksResponse(response as api.ListSinksResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).organizations.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
});
unittest.group('resource-ProjectsResource', () {
unittest.test('method--getCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getCmekSettings(arg_name, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--getSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSettings(arg_name, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
});
unittest.group('resource-ProjectsExclusionsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.exclusions;
final arg_request = buildLogExclusion();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.exclusions;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.exclusions;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListExclusionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListExclusionsResponse(response as api.ListExclusionsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.exclusions;
final arg_request = buildLogExclusion();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.LogExclusion.fromJson(
json as core.Map<core.String, core.dynamic>);
checkLogExclusion(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogExclusion());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogExclusion(response as api.LogExclusion);
});
});
unittest.group('resource-ProjectsLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-ProjectsLocationsBucketsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--createAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_request = buildLogBucket();
final arg_parent = 'foo';
final arg_bucketId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['bucketId']!.first,
unittest.equals(arg_bucketId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.createAsync(arg_request, arg_parent,
bucketId: arg_bucketId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListBucketsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListBucketsResponse(response as api.ListBucketsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogBucket());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogBucket(response as api.LogBucket);
});
unittest.test('method--undelete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_request = buildUndeleteBucketRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.UndeleteBucketRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkUndeleteBucketRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.undelete(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--updateAsync', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets;
final arg_request = buildLogBucket();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogBucket.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogBucket(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateAsync(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
});
unittest.group('resource-ProjectsLocationsBucketsLinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.links;
final arg_request = buildLink();
final arg_parent = 'foo';
final arg_linkId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Link.fromJson(json as core.Map<core.String, core.dynamic>);
checkLink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['linkId']!.first,
unittest.equals(arg_linkId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
linkId: arg_linkId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.links;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLink(response as api.Link);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.links;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLinksResponse(response as api.ListLinksResponse);
});
});
unittest.group('resource-ProjectsLocationsBucketsViewsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views;
final arg_request = buildLogView();
final arg_parent = 'foo';
final arg_viewId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['viewId']!.first,
unittest.equals(arg_viewId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
viewId: arg_viewId, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListViewsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListViewsResponse(response as api.ListViewsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views;
final arg_request = buildLogView();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogView.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogView(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogView());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkLogView(response as api.LogView);
});
});
unittest.group('resource-ProjectsLocationsBucketsViewsLogsResource', () {
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.buckets.views.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed45();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-ProjectsLocationsOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.locations.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
unittest.group('resource-ProjectsLogsResource', () {
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.logs;
final arg_logName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_logName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.logs;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_resourceNames = buildUnnamed46();
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['resourceNames']!,
unittest.equals(arg_resourceNames),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
resourceNames: arg_resourceNames,
$fields: arg_$fields);
checkListLogsResponse(response as api.ListLogsResponse);
});
});
unittest.group('resource-ProjectsMetricsResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.metrics;
final arg_request = buildLogMetric();
final arg_parent = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogMetric.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogMetric(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogMetric());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.create(arg_request, arg_parent, $fields: arg_$fields);
checkLogMetric(response as api.LogMetric);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.metrics;
final arg_metricName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_metricName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.metrics;
final arg_metricName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogMetric());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_metricName, $fields: arg_$fields);
checkLogMetric(response as api.LogMetric);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.metrics;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLogMetricsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLogMetricsResponse(response as api.ListLogMetricsResponse);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.metrics;
final arg_request = buildLogMetric();
final arg_metricName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogMetric.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogMetric(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogMetric());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.update(arg_request, arg_metricName, $fields: arg_$fields);
checkLogMetric(response as api.LogMetric);
});
});
unittest.group('resource-ProjectsSinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_request = buildLogSink();
final arg_parent = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_sinkName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_sinkName, $fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSinksResponse(response as api.ListSinksResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).projects.sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
});
unittest.group('resource-SinksResource', () {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).sinks;
final arg_request = buildLogSink();
final arg_parent = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_sinkName, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).sinks;
final arg_sinkName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_sinkName, $fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).sinks;
final arg_parent = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListSinksResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListSinksResponse(response as api.ListSinksResponse);
});
unittest.test('method--update', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).sinks;
final arg_request = buildLogSink();
final arg_sinkName = 'foo';
final arg_customWriterIdentity = 'foo';
final arg_uniqueWriterIdentity = true;
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.LogSink.fromJson(json as core.Map<core.String, core.dynamic>);
checkLogSink(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['customWriterIdentity']!.first,
unittest.equals(arg_customWriterIdentity),
);
unittest.expect(
queryMap['uniqueWriterIdentity']!.first,
unittest.equals('$arg_uniqueWriterIdentity'),
);
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLogSink());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.update(arg_request, arg_sinkName,
customWriterIdentity: arg_customWriterIdentity,
uniqueWriterIdentity: arg_uniqueWriterIdentity,
updateMask: arg_updateMask,
$fields: arg_$fields);
checkLogSink(response as api.LogSink);
});
});
unittest.group('resource-V2Resource', () {
unittest.test('method--getCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).v2;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.getCmekSettings(arg_name, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--getSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).v2;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getSettings(arg_name, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
unittest.test('method--updateCmekSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).v2;
final arg_request = buildCmekSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CmekSettings.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCmekSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildCmekSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateCmekSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkCmekSettings(response as api.CmekSettings);
});
unittest.test('method--updateSettings', () async {
final mock = HttpServerMock();
final res = api.LoggingApi(mock).v2;
final arg_request = buildSettings();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj =
api.Settings.fromJson(json as core.Map<core.String, core.dynamic>);
checkSettings(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v2/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildSettings());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.updateSettings(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkSettings(response as api.Settings);
});
});
}
|
googleapis.dart/generated/googleapis/test/logging/v2_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/logging/v2_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 234964}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/networkmanagement/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAbortInfo = 0;
api.AbortInfo buildAbortInfo() {
final o = api.AbortInfo();
buildCounterAbortInfo++;
if (buildCounterAbortInfo < 3) {
o.cause = 'foo';
o.projectsMissingPermission = buildUnnamed0();
o.resourceUri = 'foo';
}
buildCounterAbortInfo--;
return o;
}
void checkAbortInfo(api.AbortInfo o) {
buildCounterAbortInfo++;
if (buildCounterAbortInfo < 3) {
unittest.expect(
o.cause!,
unittest.equals('foo'),
);
checkUnnamed0(o.projectsMissingPermission!);
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
}
buildCounterAbortInfo--;
}
core.int buildCounterAppEngineVersionEndpoint = 0;
api.AppEngineVersionEndpoint buildAppEngineVersionEndpoint() {
final o = api.AppEngineVersionEndpoint();
buildCounterAppEngineVersionEndpoint++;
if (buildCounterAppEngineVersionEndpoint < 3) {
o.uri = 'foo';
}
buildCounterAppEngineVersionEndpoint--;
return o;
}
void checkAppEngineVersionEndpoint(api.AppEngineVersionEndpoint o) {
buildCounterAppEngineVersionEndpoint++;
if (buildCounterAppEngineVersionEndpoint < 3) {
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterAppEngineVersionEndpoint--;
}
core.int buildCounterAppEngineVersionInfo = 0;
api.AppEngineVersionInfo buildAppEngineVersionInfo() {
final o = api.AppEngineVersionInfo();
buildCounterAppEngineVersionInfo++;
if (buildCounterAppEngineVersionInfo < 3) {
o.displayName = 'foo';
o.environment = 'foo';
o.runtime = 'foo';
o.uri = 'foo';
}
buildCounterAppEngineVersionInfo--;
return o;
}
void checkAppEngineVersionInfo(api.AppEngineVersionInfo o) {
buildCounterAppEngineVersionInfo++;
if (buildCounterAppEngineVersionInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.environment!,
unittest.equals('foo'),
);
unittest.expect(
o.runtime!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterAppEngineVersionInfo--;
}
core.List<api.AuditLogConfig> buildUnnamed1() => [
buildAuditLogConfig(),
buildAuditLogConfig(),
];
void checkUnnamed1(core.List<api.AuditLogConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAuditLogConfig(o[0]);
checkAuditLogConfig(o[1]);
}
core.int buildCounterAuditConfig = 0;
api.AuditConfig buildAuditConfig() {
final o = api.AuditConfig();
buildCounterAuditConfig++;
if (buildCounterAuditConfig < 3) {
o.auditLogConfigs = buildUnnamed1();
o.service = 'foo';
}
buildCounterAuditConfig--;
return o;
}
void checkAuditConfig(api.AuditConfig o) {
buildCounterAuditConfig++;
if (buildCounterAuditConfig < 3) {
checkUnnamed1(o.auditLogConfigs!);
unittest.expect(
o.service!,
unittest.equals('foo'),
);
}
buildCounterAuditConfig--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAuditLogConfig = 0;
api.AuditLogConfig buildAuditLogConfig() {
final o = api.AuditLogConfig();
buildCounterAuditLogConfig++;
if (buildCounterAuditLogConfig < 3) {
o.exemptedMembers = buildUnnamed2();
o.logType = 'foo';
}
buildCounterAuditLogConfig--;
return o;
}
void checkAuditLogConfig(api.AuditLogConfig o) {
buildCounterAuditLogConfig++;
if (buildCounterAuditLogConfig < 3) {
checkUnnamed2(o.exemptedMembers!);
unittest.expect(
o.logType!,
unittest.equals('foo'),
);
}
buildCounterAuditLogConfig--;
}
core.List<core.String> buildUnnamed3() => [
'foo',
'foo',
];
void checkUnnamed3(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterBinding = 0;
api.Binding buildBinding() {
final o = api.Binding();
buildCounterBinding++;
if (buildCounterBinding < 3) {
o.condition = buildExpr();
o.members = buildUnnamed3();
o.role = 'foo';
}
buildCounterBinding--;
return o;
}
void checkBinding(api.Binding o) {
buildCounterBinding++;
if (buildCounterBinding < 3) {
checkExpr(o.condition!);
checkUnnamed3(o.members!);
unittest.expect(
o.role!,
unittest.equals('foo'),
);
}
buildCounterBinding--;
}
core.int buildCounterCancelOperationRequest = 0;
api.CancelOperationRequest buildCancelOperationRequest() {
final o = api.CancelOperationRequest();
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {}
buildCounterCancelOperationRequest--;
return o;
}
void checkCancelOperationRequest(api.CancelOperationRequest o) {
buildCounterCancelOperationRequest++;
if (buildCounterCancelOperationRequest < 3) {}
buildCounterCancelOperationRequest--;
}
core.int buildCounterCloudFunctionEndpoint = 0;
api.CloudFunctionEndpoint buildCloudFunctionEndpoint() {
final o = api.CloudFunctionEndpoint();
buildCounterCloudFunctionEndpoint++;
if (buildCounterCloudFunctionEndpoint < 3) {
o.uri = 'foo';
}
buildCounterCloudFunctionEndpoint--;
return o;
}
void checkCloudFunctionEndpoint(api.CloudFunctionEndpoint o) {
buildCounterCloudFunctionEndpoint++;
if (buildCounterCloudFunctionEndpoint < 3) {
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterCloudFunctionEndpoint--;
}
core.int buildCounterCloudFunctionInfo = 0;
api.CloudFunctionInfo buildCloudFunctionInfo() {
final o = api.CloudFunctionInfo();
buildCounterCloudFunctionInfo++;
if (buildCounterCloudFunctionInfo < 3) {
o.displayName = 'foo';
o.location = 'foo';
o.uri = 'foo';
o.versionId = 'foo';
}
buildCounterCloudFunctionInfo--;
return o;
}
void checkCloudFunctionInfo(api.CloudFunctionInfo o) {
buildCounterCloudFunctionInfo++;
if (buildCounterCloudFunctionInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
unittest.expect(
o.versionId!,
unittest.equals('foo'),
);
}
buildCounterCloudFunctionInfo--;
}
core.int buildCounterCloudRunRevisionEndpoint = 0;
api.CloudRunRevisionEndpoint buildCloudRunRevisionEndpoint() {
final o = api.CloudRunRevisionEndpoint();
buildCounterCloudRunRevisionEndpoint++;
if (buildCounterCloudRunRevisionEndpoint < 3) {
o.uri = 'foo';
}
buildCounterCloudRunRevisionEndpoint--;
return o;
}
void checkCloudRunRevisionEndpoint(api.CloudRunRevisionEndpoint o) {
buildCounterCloudRunRevisionEndpoint++;
if (buildCounterCloudRunRevisionEndpoint < 3) {
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterCloudRunRevisionEndpoint--;
}
core.int buildCounterCloudRunRevisionInfo = 0;
api.CloudRunRevisionInfo buildCloudRunRevisionInfo() {
final o = api.CloudRunRevisionInfo();
buildCounterCloudRunRevisionInfo++;
if (buildCounterCloudRunRevisionInfo < 3) {
o.displayName = 'foo';
o.location = 'foo';
o.serviceUri = 'foo';
o.uri = 'foo';
}
buildCounterCloudRunRevisionInfo--;
return o;
}
void checkCloudRunRevisionInfo(api.CloudRunRevisionInfo o) {
buildCounterCloudRunRevisionInfo++;
if (buildCounterCloudRunRevisionInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.serviceUri!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterCloudRunRevisionInfo--;
}
core.int buildCounterCloudSQLInstanceInfo = 0;
api.CloudSQLInstanceInfo buildCloudSQLInstanceInfo() {
final o = api.CloudSQLInstanceInfo();
buildCounterCloudSQLInstanceInfo++;
if (buildCounterCloudSQLInstanceInfo < 3) {
o.displayName = 'foo';
o.externalIp = 'foo';
o.internalIp = 'foo';
o.networkUri = 'foo';
o.region = 'foo';
o.uri = 'foo';
}
buildCounterCloudSQLInstanceInfo--;
return o;
}
void checkCloudSQLInstanceInfo(api.CloudSQLInstanceInfo o) {
buildCounterCloudSQLInstanceInfo++;
if (buildCounterCloudSQLInstanceInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.externalIp!,
unittest.equals('foo'),
);
unittest.expect(
o.internalIp!,
unittest.equals('foo'),
);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.region!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterCloudSQLInstanceInfo--;
}
core.Map<core.String, core.String> buildUnnamed4() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed4(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed5() => [
'foo',
'foo',
];
void checkUnnamed5(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterConnectivityTest = 0;
api.ConnectivityTest buildConnectivityTest() {
final o = api.ConnectivityTest();
buildCounterConnectivityTest++;
if (buildCounterConnectivityTest < 3) {
o.createTime = 'foo';
o.description = 'foo';
o.destination = buildEndpoint();
o.displayName = 'foo';
o.labels = buildUnnamed4();
o.name = 'foo';
o.protocol = 'foo';
o.reachabilityDetails = buildReachabilityDetails();
o.relatedProjects = buildUnnamed5();
o.source = buildEndpoint();
o.updateTime = 'foo';
}
buildCounterConnectivityTest--;
return o;
}
void checkConnectivityTest(api.ConnectivityTest o) {
buildCounterConnectivityTest++;
if (buildCounterConnectivityTest < 3) {
unittest.expect(
o.createTime!,
unittest.equals('foo'),
);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkEndpoint(o.destination!);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed4(o.labels!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
unittest.expect(
o.protocol!,
unittest.equals('foo'),
);
checkReachabilityDetails(o.reachabilityDetails!);
checkUnnamed5(o.relatedProjects!);
checkEndpoint(o.source!);
unittest.expect(
o.updateTime!,
unittest.equals('foo'),
);
}
buildCounterConnectivityTest--;
}
core.int buildCounterDeliverInfo = 0;
api.DeliverInfo buildDeliverInfo() {
final o = api.DeliverInfo();
buildCounterDeliverInfo++;
if (buildCounterDeliverInfo < 3) {
o.resourceUri = 'foo';
o.target = 'foo';
}
buildCounterDeliverInfo--;
return o;
}
void checkDeliverInfo(api.DeliverInfo o) {
buildCounterDeliverInfo++;
if (buildCounterDeliverInfo < 3) {
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
unittest.expect(
o.target!,
unittest.equals('foo'),
);
}
buildCounterDeliverInfo--;
}
core.int buildCounterDropInfo = 0;
api.DropInfo buildDropInfo() {
final o = api.DropInfo();
buildCounterDropInfo++;
if (buildCounterDropInfo < 3) {
o.cause = 'foo';
o.resourceUri = 'foo';
}
buildCounterDropInfo--;
return o;
}
void checkDropInfo(api.DropInfo o) {
buildCounterDropInfo++;
if (buildCounterDropInfo < 3) {
unittest.expect(
o.cause!,
unittest.equals('foo'),
);
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
}
buildCounterDropInfo--;
}
core.int buildCounterEmpty = 0;
api.Empty buildEmpty() {
final o = api.Empty();
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
return o;
}
void checkEmpty(api.Empty o) {
buildCounterEmpty++;
if (buildCounterEmpty < 3) {}
buildCounterEmpty--;
}
core.int buildCounterEndpoint = 0;
api.Endpoint buildEndpoint() {
final o = api.Endpoint();
buildCounterEndpoint++;
if (buildCounterEndpoint < 3) {
o.appEngineVersion = buildAppEngineVersionEndpoint();
o.cloudFunction = buildCloudFunctionEndpoint();
o.cloudRunRevision = buildCloudRunRevisionEndpoint();
o.cloudSqlInstance = 'foo';
o.forwardingRule = 'foo';
o.gkeMasterCluster = 'foo';
o.instance = 'foo';
o.ipAddress = 'foo';
o.network = 'foo';
o.networkType = 'foo';
o.port = 42;
o.projectId = 'foo';
}
buildCounterEndpoint--;
return o;
}
void checkEndpoint(api.Endpoint o) {
buildCounterEndpoint++;
if (buildCounterEndpoint < 3) {
checkAppEngineVersionEndpoint(o.appEngineVersion!);
checkCloudFunctionEndpoint(o.cloudFunction!);
checkCloudRunRevisionEndpoint(o.cloudRunRevision!);
unittest.expect(
o.cloudSqlInstance!,
unittest.equals('foo'),
);
unittest.expect(
o.forwardingRule!,
unittest.equals('foo'),
);
unittest.expect(
o.gkeMasterCluster!,
unittest.equals('foo'),
);
unittest.expect(
o.instance!,
unittest.equals('foo'),
);
unittest.expect(
o.ipAddress!,
unittest.equals('foo'),
);
unittest.expect(
o.network!,
unittest.equals('foo'),
);
unittest.expect(
o.networkType!,
unittest.equals('foo'),
);
unittest.expect(
o.port!,
unittest.equals(42),
);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
}
buildCounterEndpoint--;
}
core.int buildCounterEndpointInfo = 0;
api.EndpointInfo buildEndpointInfo() {
final o = api.EndpointInfo();
buildCounterEndpointInfo++;
if (buildCounterEndpointInfo < 3) {
o.destinationIp = 'foo';
o.destinationNetworkUri = 'foo';
o.destinationPort = 42;
o.protocol = 'foo';
o.sourceIp = 'foo';
o.sourceNetworkUri = 'foo';
o.sourcePort = 42;
}
buildCounterEndpointInfo--;
return o;
}
void checkEndpointInfo(api.EndpointInfo o) {
buildCounterEndpointInfo++;
if (buildCounterEndpointInfo < 3) {
unittest.expect(
o.destinationIp!,
unittest.equals('foo'),
);
unittest.expect(
o.destinationNetworkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.destinationPort!,
unittest.equals(42),
);
unittest.expect(
o.protocol!,
unittest.equals('foo'),
);
unittest.expect(
o.sourceIp!,
unittest.equals('foo'),
);
unittest.expect(
o.sourceNetworkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.sourcePort!,
unittest.equals(42),
);
}
buildCounterEndpointInfo--;
}
core.int buildCounterExpr = 0;
api.Expr buildExpr() {
final o = api.Expr();
buildCounterExpr++;
if (buildCounterExpr < 3) {
o.description = 'foo';
o.expression = 'foo';
o.location = 'foo';
o.title = 'foo';
}
buildCounterExpr--;
return o;
}
void checkExpr(api.Expr o) {
buildCounterExpr++;
if (buildCounterExpr < 3) {
unittest.expect(
o.description!,
unittest.equals('foo'),
);
unittest.expect(
o.expression!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.title!,
unittest.equals('foo'),
);
}
buildCounterExpr--;
}
core.List<core.String> buildUnnamed6() => [
'foo',
'foo',
];
void checkUnnamed6(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed7() => [
'foo',
'foo',
];
void checkUnnamed7(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterFirewallInfo = 0;
api.FirewallInfo buildFirewallInfo() {
final o = api.FirewallInfo();
buildCounterFirewallInfo++;
if (buildCounterFirewallInfo < 3) {
o.action = 'foo';
o.direction = 'foo';
o.displayName = 'foo';
o.firewallRuleType = 'foo';
o.networkUri = 'foo';
o.policy = 'foo';
o.priority = 42;
o.targetServiceAccounts = buildUnnamed6();
o.targetTags = buildUnnamed7();
o.uri = 'foo';
}
buildCounterFirewallInfo--;
return o;
}
void checkFirewallInfo(api.FirewallInfo o) {
buildCounterFirewallInfo++;
if (buildCounterFirewallInfo < 3) {
unittest.expect(
o.action!,
unittest.equals('foo'),
);
unittest.expect(
o.direction!,
unittest.equals('foo'),
);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.firewallRuleType!,
unittest.equals('foo'),
);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.policy!,
unittest.equals('foo'),
);
unittest.expect(
o.priority!,
unittest.equals(42),
);
checkUnnamed6(o.targetServiceAccounts!);
checkUnnamed7(o.targetTags!);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterFirewallInfo--;
}
core.int buildCounterForwardInfo = 0;
api.ForwardInfo buildForwardInfo() {
final o = api.ForwardInfo();
buildCounterForwardInfo++;
if (buildCounterForwardInfo < 3) {
o.resourceUri = 'foo';
o.target = 'foo';
}
buildCounterForwardInfo--;
return o;
}
void checkForwardInfo(api.ForwardInfo o) {
buildCounterForwardInfo++;
if (buildCounterForwardInfo < 3) {
unittest.expect(
o.resourceUri!,
unittest.equals('foo'),
);
unittest.expect(
o.target!,
unittest.equals('foo'),
);
}
buildCounterForwardInfo--;
}
core.int buildCounterForwardingRuleInfo = 0;
api.ForwardingRuleInfo buildForwardingRuleInfo() {
final o = api.ForwardingRuleInfo();
buildCounterForwardingRuleInfo++;
if (buildCounterForwardingRuleInfo < 3) {
o.displayName = 'foo';
o.matchedPortRange = 'foo';
o.matchedProtocol = 'foo';
o.networkUri = 'foo';
o.target = 'foo';
o.uri = 'foo';
o.vip = 'foo';
}
buildCounterForwardingRuleInfo--;
return o;
}
void checkForwardingRuleInfo(api.ForwardingRuleInfo o) {
buildCounterForwardingRuleInfo++;
if (buildCounterForwardingRuleInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.matchedPortRange!,
unittest.equals('foo'),
);
unittest.expect(
o.matchedProtocol!,
unittest.equals('foo'),
);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.target!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
unittest.expect(
o.vip!,
unittest.equals('foo'),
);
}
buildCounterForwardingRuleInfo--;
}
core.int buildCounterGKEMasterInfo = 0;
api.GKEMasterInfo buildGKEMasterInfo() {
final o = api.GKEMasterInfo();
buildCounterGKEMasterInfo++;
if (buildCounterGKEMasterInfo < 3) {
o.clusterNetworkUri = 'foo';
o.clusterUri = 'foo';
o.externalIp = 'foo';
o.internalIp = 'foo';
}
buildCounterGKEMasterInfo--;
return o;
}
void checkGKEMasterInfo(api.GKEMasterInfo o) {
buildCounterGKEMasterInfo++;
if (buildCounterGKEMasterInfo < 3) {
unittest.expect(
o.clusterNetworkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.clusterUri!,
unittest.equals('foo'),
);
unittest.expect(
o.externalIp!,
unittest.equals('foo'),
);
unittest.expect(
o.internalIp!,
unittest.equals('foo'),
);
}
buildCounterGKEMasterInfo--;
}
core.int buildCounterGoogleServiceInfo = 0;
api.GoogleServiceInfo buildGoogleServiceInfo() {
final o = api.GoogleServiceInfo();
buildCounterGoogleServiceInfo++;
if (buildCounterGoogleServiceInfo < 3) {
o.googleServiceType = 'foo';
o.sourceIp = 'foo';
}
buildCounterGoogleServiceInfo--;
return o;
}
void checkGoogleServiceInfo(api.GoogleServiceInfo o) {
buildCounterGoogleServiceInfo++;
if (buildCounterGoogleServiceInfo < 3) {
unittest.expect(
o.googleServiceType!,
unittest.equals('foo'),
);
unittest.expect(
o.sourceIp!,
unittest.equals('foo'),
);
}
buildCounterGoogleServiceInfo--;
}
core.List<core.String> buildUnnamed8() => [
'foo',
'foo',
];
void checkUnnamed8(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterInstanceInfo = 0;
api.InstanceInfo buildInstanceInfo() {
final o = api.InstanceInfo();
buildCounterInstanceInfo++;
if (buildCounterInstanceInfo < 3) {
o.displayName = 'foo';
o.externalIp = 'foo';
o.interface = 'foo';
o.internalIp = 'foo';
o.networkTags = buildUnnamed8();
o.networkUri = 'foo';
o.serviceAccount = 'foo';
o.uri = 'foo';
}
buildCounterInstanceInfo--;
return o;
}
void checkInstanceInfo(api.InstanceInfo o) {
buildCounterInstanceInfo++;
if (buildCounterInstanceInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.externalIp!,
unittest.equals('foo'),
);
unittest.expect(
o.interface!,
unittest.equals('foo'),
);
unittest.expect(
o.internalIp!,
unittest.equals('foo'),
);
checkUnnamed8(o.networkTags!);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.serviceAccount!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterInstanceInfo--;
}
core.List<api.ConnectivityTest> buildUnnamed9() => [
buildConnectivityTest(),
buildConnectivityTest(),
];
void checkUnnamed9(core.List<api.ConnectivityTest> o) {
unittest.expect(o, unittest.hasLength(2));
checkConnectivityTest(o[0]);
checkConnectivityTest(o[1]);
}
core.List<core.String> buildUnnamed10() => [
'foo',
'foo',
];
void checkUnnamed10(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterListConnectivityTestsResponse = 0;
api.ListConnectivityTestsResponse buildListConnectivityTestsResponse() {
final o = api.ListConnectivityTestsResponse();
buildCounterListConnectivityTestsResponse++;
if (buildCounterListConnectivityTestsResponse < 3) {
o.nextPageToken = 'foo';
o.resources = buildUnnamed9();
o.unreachable = buildUnnamed10();
}
buildCounterListConnectivityTestsResponse--;
return o;
}
void checkListConnectivityTestsResponse(api.ListConnectivityTestsResponse o) {
buildCounterListConnectivityTestsResponse++;
if (buildCounterListConnectivityTestsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed9(o.resources!);
checkUnnamed10(o.unreachable!);
}
buildCounterListConnectivityTestsResponse--;
}
core.List<api.Location> buildUnnamed11() => [
buildLocation(),
buildLocation(),
];
void checkUnnamed11(core.List<api.Location> o) {
unittest.expect(o, unittest.hasLength(2));
checkLocation(o[0]);
checkLocation(o[1]);
}
core.int buildCounterListLocationsResponse = 0;
api.ListLocationsResponse buildListLocationsResponse() {
final o = api.ListLocationsResponse();
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
o.locations = buildUnnamed11();
o.nextPageToken = 'foo';
}
buildCounterListLocationsResponse--;
return o;
}
void checkListLocationsResponse(api.ListLocationsResponse o) {
buildCounterListLocationsResponse++;
if (buildCounterListLocationsResponse < 3) {
checkUnnamed11(o.locations!);
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
}
buildCounterListLocationsResponse--;
}
core.List<api.Operation> buildUnnamed12() => [
buildOperation(),
buildOperation(),
];
void checkUnnamed12(core.List<api.Operation> o) {
unittest.expect(o, unittest.hasLength(2));
checkOperation(o[0]);
checkOperation(o[1]);
}
core.int buildCounterListOperationsResponse = 0;
api.ListOperationsResponse buildListOperationsResponse() {
final o = api.ListOperationsResponse();
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
o.nextPageToken = 'foo';
o.operations = buildUnnamed12();
}
buildCounterListOperationsResponse--;
return o;
}
void checkListOperationsResponse(api.ListOperationsResponse o) {
buildCounterListOperationsResponse++;
if (buildCounterListOperationsResponse < 3) {
unittest.expect(
o.nextPageToken!,
unittest.equals('foo'),
);
checkUnnamed12(o.operations!);
}
buildCounterListOperationsResponse--;
}
core.List<core.String> buildUnnamed13() => [
'foo',
'foo',
];
void checkUnnamed13(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed14() => [
'foo',
'foo',
];
void checkUnnamed14(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterLoadBalancerBackend = 0;
api.LoadBalancerBackend buildLoadBalancerBackend() {
final o = api.LoadBalancerBackend();
buildCounterLoadBalancerBackend++;
if (buildCounterLoadBalancerBackend < 3) {
o.displayName = 'foo';
o.healthCheckAllowingFirewallRules = buildUnnamed13();
o.healthCheckBlockingFirewallRules = buildUnnamed14();
o.healthCheckFirewallState = 'foo';
o.uri = 'foo';
}
buildCounterLoadBalancerBackend--;
return o;
}
void checkLoadBalancerBackend(api.LoadBalancerBackend o) {
buildCounterLoadBalancerBackend++;
if (buildCounterLoadBalancerBackend < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed13(o.healthCheckAllowingFirewallRules!);
checkUnnamed14(o.healthCheckBlockingFirewallRules!);
unittest.expect(
o.healthCheckFirewallState!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterLoadBalancerBackend--;
}
core.List<api.LoadBalancerBackend> buildUnnamed15() => [
buildLoadBalancerBackend(),
buildLoadBalancerBackend(),
];
void checkUnnamed15(core.List<api.LoadBalancerBackend> o) {
unittest.expect(o, unittest.hasLength(2));
checkLoadBalancerBackend(o[0]);
checkLoadBalancerBackend(o[1]);
}
core.int buildCounterLoadBalancerInfo = 0;
api.LoadBalancerInfo buildLoadBalancerInfo() {
final o = api.LoadBalancerInfo();
buildCounterLoadBalancerInfo++;
if (buildCounterLoadBalancerInfo < 3) {
o.backendType = 'foo';
o.backendUri = 'foo';
o.backends = buildUnnamed15();
o.healthCheckUri = 'foo';
o.loadBalancerType = 'foo';
}
buildCounterLoadBalancerInfo--;
return o;
}
void checkLoadBalancerInfo(api.LoadBalancerInfo o) {
buildCounterLoadBalancerInfo++;
if (buildCounterLoadBalancerInfo < 3) {
unittest.expect(
o.backendType!,
unittest.equals('foo'),
);
unittest.expect(
o.backendUri!,
unittest.equals('foo'),
);
checkUnnamed15(o.backends!);
unittest.expect(
o.healthCheckUri!,
unittest.equals('foo'),
);
unittest.expect(
o.loadBalancerType!,
unittest.equals('foo'),
);
}
buildCounterLoadBalancerInfo--;
}
core.Map<core.String, core.String> buildUnnamed16() => {
'x': 'foo',
'y': 'foo',
};
void checkUnnamed16(core.Map<core.String, core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o['x']!,
unittest.equals('foo'),
);
unittest.expect(
o['y']!,
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed17() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed17(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted1 = (o['x']!) as core.Map;
unittest.expect(casted1, unittest.hasLength(3));
unittest.expect(
casted1['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted1['bool'],
unittest.equals(true),
);
unittest.expect(
casted1['string'],
unittest.equals('foo'),
);
var casted2 = (o['y']!) as core.Map;
unittest.expect(casted2, unittest.hasLength(3));
unittest.expect(
casted2['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted2['bool'],
unittest.equals(true),
);
unittest.expect(
casted2['string'],
unittest.equals('foo'),
);
}
core.int buildCounterLocation = 0;
api.Location buildLocation() {
final o = api.Location();
buildCounterLocation++;
if (buildCounterLocation < 3) {
o.displayName = 'foo';
o.labels = buildUnnamed16();
o.locationId = 'foo';
o.metadata = buildUnnamed17();
o.name = 'foo';
}
buildCounterLocation--;
return o;
}
void checkLocation(api.Location o) {
buildCounterLocation++;
if (buildCounterLocation < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed16(o.labels!);
unittest.expect(
o.locationId!,
unittest.equals('foo'),
);
checkUnnamed17(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
}
buildCounterLocation--;
}
core.int buildCounterNetworkInfo = 0;
api.NetworkInfo buildNetworkInfo() {
final o = api.NetworkInfo();
buildCounterNetworkInfo++;
if (buildCounterNetworkInfo < 3) {
o.displayName = 'foo';
o.matchedIpRange = 'foo';
o.uri = 'foo';
}
buildCounterNetworkInfo--;
return o;
}
void checkNetworkInfo(api.NetworkInfo o) {
buildCounterNetworkInfo++;
if (buildCounterNetworkInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.matchedIpRange!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterNetworkInfo--;
}
core.Map<core.String, core.Object?> buildUnnamed18() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed18(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted3 = (o['x']!) as core.Map;
unittest.expect(casted3, unittest.hasLength(3));
unittest.expect(
casted3['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted3['bool'],
unittest.equals(true),
);
unittest.expect(
casted3['string'],
unittest.equals('foo'),
);
var casted4 = (o['y']!) as core.Map;
unittest.expect(casted4, unittest.hasLength(3));
unittest.expect(
casted4['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted4['bool'],
unittest.equals(true),
);
unittest.expect(
casted4['string'],
unittest.equals('foo'),
);
}
core.Map<core.String, core.Object?> buildUnnamed19() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed19(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted5 = (o['x']!) as core.Map;
unittest.expect(casted5, unittest.hasLength(3));
unittest.expect(
casted5['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted5['bool'],
unittest.equals(true),
);
unittest.expect(
casted5['string'],
unittest.equals('foo'),
);
var casted6 = (o['y']!) as core.Map;
unittest.expect(casted6, unittest.hasLength(3));
unittest.expect(
casted6['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted6['bool'],
unittest.equals(true),
);
unittest.expect(
casted6['string'],
unittest.equals('foo'),
);
}
core.int buildCounterOperation = 0;
api.Operation buildOperation() {
final o = api.Operation();
buildCounterOperation++;
if (buildCounterOperation < 3) {
o.done = true;
o.error = buildStatus();
o.metadata = buildUnnamed18();
o.name = 'foo';
o.response = buildUnnamed19();
}
buildCounterOperation--;
return o;
}
void checkOperation(api.Operation o) {
buildCounterOperation++;
if (buildCounterOperation < 3) {
unittest.expect(o.done!, unittest.isTrue);
checkStatus(o.error!);
checkUnnamed18(o.metadata!);
unittest.expect(
o.name!,
unittest.equals('foo'),
);
checkUnnamed19(o.response!);
}
buildCounterOperation--;
}
core.List<api.AuditConfig> buildUnnamed20() => [
buildAuditConfig(),
buildAuditConfig(),
];
void checkUnnamed20(core.List<api.AuditConfig> o) {
unittest.expect(o, unittest.hasLength(2));
checkAuditConfig(o[0]);
checkAuditConfig(o[1]);
}
core.List<api.Binding> buildUnnamed21() => [
buildBinding(),
buildBinding(),
];
void checkUnnamed21(core.List<api.Binding> o) {
unittest.expect(o, unittest.hasLength(2));
checkBinding(o[0]);
checkBinding(o[1]);
}
core.int buildCounterPolicy = 0;
api.Policy buildPolicy() {
final o = api.Policy();
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
o.auditConfigs = buildUnnamed20();
o.bindings = buildUnnamed21();
o.etag = 'foo';
o.version = 42;
}
buildCounterPolicy--;
return o;
}
void checkPolicy(api.Policy o) {
buildCounterPolicy++;
if (buildCounterPolicy < 3) {
checkUnnamed20(o.auditConfigs!);
checkUnnamed21(o.bindings!);
unittest.expect(
o.etag!,
unittest.equals('foo'),
);
unittest.expect(
o.version!,
unittest.equals(42),
);
}
buildCounterPolicy--;
}
core.List<api.Trace> buildUnnamed22() => [
buildTrace(),
buildTrace(),
];
void checkUnnamed22(core.List<api.Trace> o) {
unittest.expect(o, unittest.hasLength(2));
checkTrace(o[0]);
checkTrace(o[1]);
}
core.int buildCounterReachabilityDetails = 0;
api.ReachabilityDetails buildReachabilityDetails() {
final o = api.ReachabilityDetails();
buildCounterReachabilityDetails++;
if (buildCounterReachabilityDetails < 3) {
o.error = buildStatus();
o.result = 'foo';
o.traces = buildUnnamed22();
o.verifyTime = 'foo';
}
buildCounterReachabilityDetails--;
return o;
}
void checkReachabilityDetails(api.ReachabilityDetails o) {
buildCounterReachabilityDetails++;
if (buildCounterReachabilityDetails < 3) {
checkStatus(o.error!);
unittest.expect(
o.result!,
unittest.equals('foo'),
);
checkUnnamed22(o.traces!);
unittest.expect(
o.verifyTime!,
unittest.equals('foo'),
);
}
buildCounterReachabilityDetails--;
}
core.int buildCounterRerunConnectivityTestRequest = 0;
api.RerunConnectivityTestRequest buildRerunConnectivityTestRequest() {
final o = api.RerunConnectivityTestRequest();
buildCounterRerunConnectivityTestRequest++;
if (buildCounterRerunConnectivityTestRequest < 3) {}
buildCounterRerunConnectivityTestRequest--;
return o;
}
void checkRerunConnectivityTestRequest(api.RerunConnectivityTestRequest o) {
buildCounterRerunConnectivityTestRequest++;
if (buildCounterRerunConnectivityTestRequest < 3) {}
buildCounterRerunConnectivityTestRequest--;
}
core.List<core.String> buildUnnamed23() => [
'foo',
'foo',
];
void checkUnnamed23(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed24() => [
'foo',
'foo',
];
void checkUnnamed24(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed25() => [
'foo',
'foo',
];
void checkUnnamed25(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.List<core.String> buildUnnamed26() => [
'foo',
'foo',
];
void checkUnnamed26(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterRouteInfo = 0;
api.RouteInfo buildRouteInfo() {
final o = api.RouteInfo();
buildCounterRouteInfo++;
if (buildCounterRouteInfo < 3) {
o.destIpRange = 'foo';
o.destPortRanges = buildUnnamed23();
o.displayName = 'foo';
o.instanceTags = buildUnnamed24();
o.networkUri = 'foo';
o.nextHop = 'foo';
o.nextHopType = 'foo';
o.priority = 42;
o.protocols = buildUnnamed25();
o.routeType = 'foo';
o.srcIpRange = 'foo';
o.srcPortRanges = buildUnnamed26();
o.uri = 'foo';
}
buildCounterRouteInfo--;
return o;
}
void checkRouteInfo(api.RouteInfo o) {
buildCounterRouteInfo++;
if (buildCounterRouteInfo < 3) {
unittest.expect(
o.destIpRange!,
unittest.equals('foo'),
);
checkUnnamed23(o.destPortRanges!);
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
checkUnnamed24(o.instanceTags!);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.nextHop!,
unittest.equals('foo'),
);
unittest.expect(
o.nextHopType!,
unittest.equals('foo'),
);
unittest.expect(
o.priority!,
unittest.equals(42),
);
checkUnnamed25(o.protocols!);
unittest.expect(
o.routeType!,
unittest.equals('foo'),
);
unittest.expect(
o.srcIpRange!,
unittest.equals('foo'),
);
checkUnnamed26(o.srcPortRanges!);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterRouteInfo--;
}
core.int buildCounterSetIamPolicyRequest = 0;
api.SetIamPolicyRequest buildSetIamPolicyRequest() {
final o = api.SetIamPolicyRequest();
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
o.policy = buildPolicy();
o.updateMask = 'foo';
}
buildCounterSetIamPolicyRequest--;
return o;
}
void checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
buildCounterSetIamPolicyRequest++;
if (buildCounterSetIamPolicyRequest < 3) {
checkPolicy(o.policy!);
unittest.expect(
o.updateMask!,
unittest.equals('foo'),
);
}
buildCounterSetIamPolicyRequest--;
}
core.Map<core.String, core.Object?> buildUnnamed27() => {
'x': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
'y': {
'list': [1, 2, 3],
'bool': true,
'string': 'foo'
},
};
void checkUnnamed27(core.Map<core.String, core.Object?> o) {
unittest.expect(o, unittest.hasLength(2));
var casted7 = (o['x']!) as core.Map;
unittest.expect(casted7, unittest.hasLength(3));
unittest.expect(
casted7['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted7['bool'],
unittest.equals(true),
);
unittest.expect(
casted7['string'],
unittest.equals('foo'),
);
var casted8 = (o['y']!) as core.Map;
unittest.expect(casted8, unittest.hasLength(3));
unittest.expect(
casted8['list'],
unittest.equals([1, 2, 3]),
);
unittest.expect(
casted8['bool'],
unittest.equals(true),
);
unittest.expect(
casted8['string'],
unittest.equals('foo'),
);
}
core.List<core.Map<core.String, core.Object?>> buildUnnamed28() => [
buildUnnamed27(),
buildUnnamed27(),
];
void checkUnnamed28(core.List<core.Map<core.String, core.Object?>> o) {
unittest.expect(o, unittest.hasLength(2));
checkUnnamed27(o[0]);
checkUnnamed27(o[1]);
}
core.int buildCounterStatus = 0;
api.Status buildStatus() {
final o = api.Status();
buildCounterStatus++;
if (buildCounterStatus < 3) {
o.code = 42;
o.details = buildUnnamed28();
o.message = 'foo';
}
buildCounterStatus--;
return o;
}
void checkStatus(api.Status o) {
buildCounterStatus++;
if (buildCounterStatus < 3) {
unittest.expect(
o.code!,
unittest.equals(42),
);
checkUnnamed28(o.details!);
unittest.expect(
o.message!,
unittest.equals('foo'),
);
}
buildCounterStatus--;
}
core.int buildCounterStep = 0;
api.Step buildStep() {
final o = api.Step();
buildCounterStep++;
if (buildCounterStep < 3) {
o.abort = buildAbortInfo();
o.appEngineVersion = buildAppEngineVersionInfo();
o.causesDrop = true;
o.cloudFunction = buildCloudFunctionInfo();
o.cloudRunRevision = buildCloudRunRevisionInfo();
o.cloudSqlInstance = buildCloudSQLInstanceInfo();
o.deliver = buildDeliverInfo();
o.description = 'foo';
o.drop = buildDropInfo();
o.endpoint = buildEndpointInfo();
o.firewall = buildFirewallInfo();
o.forward = buildForwardInfo();
o.forwardingRule = buildForwardingRuleInfo();
o.gkeMaster = buildGKEMasterInfo();
o.googleService = buildGoogleServiceInfo();
o.instance = buildInstanceInfo();
o.loadBalancer = buildLoadBalancerInfo();
o.network = buildNetworkInfo();
o.projectId = 'foo';
o.route = buildRouteInfo();
o.state = 'foo';
o.vpcConnector = buildVpcConnectorInfo();
o.vpnGateway = buildVpnGatewayInfo();
o.vpnTunnel = buildVpnTunnelInfo();
}
buildCounterStep--;
return o;
}
void checkStep(api.Step o) {
buildCounterStep++;
if (buildCounterStep < 3) {
checkAbortInfo(o.abort!);
checkAppEngineVersionInfo(o.appEngineVersion!);
unittest.expect(o.causesDrop!, unittest.isTrue);
checkCloudFunctionInfo(o.cloudFunction!);
checkCloudRunRevisionInfo(o.cloudRunRevision!);
checkCloudSQLInstanceInfo(o.cloudSqlInstance!);
checkDeliverInfo(o.deliver!);
unittest.expect(
o.description!,
unittest.equals('foo'),
);
checkDropInfo(o.drop!);
checkEndpointInfo(o.endpoint!);
checkFirewallInfo(o.firewall!);
checkForwardInfo(o.forward!);
checkForwardingRuleInfo(o.forwardingRule!);
checkGKEMasterInfo(o.gkeMaster!);
checkGoogleServiceInfo(o.googleService!);
checkInstanceInfo(o.instance!);
checkLoadBalancerInfo(o.loadBalancer!);
checkNetworkInfo(o.network!);
unittest.expect(
o.projectId!,
unittest.equals('foo'),
);
checkRouteInfo(o.route!);
unittest.expect(
o.state!,
unittest.equals('foo'),
);
checkVpcConnectorInfo(o.vpcConnector!);
checkVpnGatewayInfo(o.vpnGateway!);
checkVpnTunnelInfo(o.vpnTunnel!);
}
buildCounterStep--;
}
core.List<core.String> buildUnnamed29() => [
'foo',
'foo',
];
void checkUnnamed29(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsRequest = 0;
api.TestIamPermissionsRequest buildTestIamPermissionsRequest() {
final o = api.TestIamPermissionsRequest();
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
o.permissions = buildUnnamed29();
}
buildCounterTestIamPermissionsRequest--;
return o;
}
void checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
buildCounterTestIamPermissionsRequest++;
if (buildCounterTestIamPermissionsRequest < 3) {
checkUnnamed29(o.permissions!);
}
buildCounterTestIamPermissionsRequest--;
}
core.List<core.String> buildUnnamed30() => [
'foo',
'foo',
];
void checkUnnamed30(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterTestIamPermissionsResponse = 0;
api.TestIamPermissionsResponse buildTestIamPermissionsResponse() {
final o = api.TestIamPermissionsResponse();
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
o.permissions = buildUnnamed30();
}
buildCounterTestIamPermissionsResponse--;
return o;
}
void checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
buildCounterTestIamPermissionsResponse++;
if (buildCounterTestIamPermissionsResponse < 3) {
checkUnnamed30(o.permissions!);
}
buildCounterTestIamPermissionsResponse--;
}
core.List<api.Step> buildUnnamed31() => [
buildStep(),
buildStep(),
];
void checkUnnamed31(core.List<api.Step> o) {
unittest.expect(o, unittest.hasLength(2));
checkStep(o[0]);
checkStep(o[1]);
}
core.int buildCounterTrace = 0;
api.Trace buildTrace() {
final o = api.Trace();
buildCounterTrace++;
if (buildCounterTrace < 3) {
o.endpointInfo = buildEndpointInfo();
o.steps = buildUnnamed31();
}
buildCounterTrace--;
return o;
}
void checkTrace(api.Trace o) {
buildCounterTrace++;
if (buildCounterTrace < 3) {
checkEndpointInfo(o.endpointInfo!);
checkUnnamed31(o.steps!);
}
buildCounterTrace--;
}
core.int buildCounterVpcConnectorInfo = 0;
api.VpcConnectorInfo buildVpcConnectorInfo() {
final o = api.VpcConnectorInfo();
buildCounterVpcConnectorInfo++;
if (buildCounterVpcConnectorInfo < 3) {
o.displayName = 'foo';
o.location = 'foo';
o.uri = 'foo';
}
buildCounterVpcConnectorInfo--;
return o;
}
void checkVpcConnectorInfo(api.VpcConnectorInfo o) {
buildCounterVpcConnectorInfo++;
if (buildCounterVpcConnectorInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.location!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterVpcConnectorInfo--;
}
core.int buildCounterVpnGatewayInfo = 0;
api.VpnGatewayInfo buildVpnGatewayInfo() {
final o = api.VpnGatewayInfo();
buildCounterVpnGatewayInfo++;
if (buildCounterVpnGatewayInfo < 3) {
o.displayName = 'foo';
o.ipAddress = 'foo';
o.networkUri = 'foo';
o.region = 'foo';
o.uri = 'foo';
o.vpnTunnelUri = 'foo';
}
buildCounterVpnGatewayInfo--;
return o;
}
void checkVpnGatewayInfo(api.VpnGatewayInfo o) {
buildCounterVpnGatewayInfo++;
if (buildCounterVpnGatewayInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.ipAddress!,
unittest.equals('foo'),
);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.region!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
unittest.expect(
o.vpnTunnelUri!,
unittest.equals('foo'),
);
}
buildCounterVpnGatewayInfo--;
}
core.int buildCounterVpnTunnelInfo = 0;
api.VpnTunnelInfo buildVpnTunnelInfo() {
final o = api.VpnTunnelInfo();
buildCounterVpnTunnelInfo++;
if (buildCounterVpnTunnelInfo < 3) {
o.displayName = 'foo';
o.networkUri = 'foo';
o.region = 'foo';
o.remoteGateway = 'foo';
o.remoteGatewayIp = 'foo';
o.routingType = 'foo';
o.sourceGateway = 'foo';
o.sourceGatewayIp = 'foo';
o.uri = 'foo';
}
buildCounterVpnTunnelInfo--;
return o;
}
void checkVpnTunnelInfo(api.VpnTunnelInfo o) {
buildCounterVpnTunnelInfo++;
if (buildCounterVpnTunnelInfo < 3) {
unittest.expect(
o.displayName!,
unittest.equals('foo'),
);
unittest.expect(
o.networkUri!,
unittest.equals('foo'),
);
unittest.expect(
o.region!,
unittest.equals('foo'),
);
unittest.expect(
o.remoteGateway!,
unittest.equals('foo'),
);
unittest.expect(
o.remoteGatewayIp!,
unittest.equals('foo'),
);
unittest.expect(
o.routingType!,
unittest.equals('foo'),
);
unittest.expect(
o.sourceGateway!,
unittest.equals('foo'),
);
unittest.expect(
o.sourceGatewayIp!,
unittest.equals('foo'),
);
unittest.expect(
o.uri!,
unittest.equals('foo'),
);
}
buildCounterVpnTunnelInfo--;
}
void main() {
unittest.group('obj-schema-AbortInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildAbortInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.AbortInfo.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkAbortInfo(od);
});
});
unittest.group('obj-schema-AppEngineVersionEndpoint', () {
unittest.test('to-json--from-json', () async {
final o = buildAppEngineVersionEndpoint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AppEngineVersionEndpoint.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAppEngineVersionEndpoint(od);
});
});
unittest.group('obj-schema-AppEngineVersionInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildAppEngineVersionInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AppEngineVersionInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAppEngineVersionInfo(od);
});
});
unittest.group('obj-schema-AuditConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAuditConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AuditConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAuditConfig(od);
});
});
unittest.group('obj-schema-AuditLogConfig', () {
unittest.test('to-json--from-json', () async {
final o = buildAuditLogConfig();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AuditLogConfig.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAuditLogConfig(od);
});
});
unittest.group('obj-schema-Binding', () {
unittest.test('to-json--from-json', () async {
final o = buildBinding();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Binding.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkBinding(od);
});
});
unittest.group('obj-schema-CancelOperationRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildCancelOperationRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CancelOperationRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(od);
});
});
unittest.group('obj-schema-CloudFunctionEndpoint', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudFunctionEndpoint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudFunctionEndpoint.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudFunctionEndpoint(od);
});
});
unittest.group('obj-schema-CloudFunctionInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudFunctionInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudFunctionInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudFunctionInfo(od);
});
});
unittest.group('obj-schema-CloudRunRevisionEndpoint', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudRunRevisionEndpoint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudRunRevisionEndpoint.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudRunRevisionEndpoint(od);
});
});
unittest.group('obj-schema-CloudRunRevisionInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudRunRevisionInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudRunRevisionInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudRunRevisionInfo(od);
});
});
unittest.group('obj-schema-CloudSQLInstanceInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildCloudSQLInstanceInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.CloudSQLInstanceInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkCloudSQLInstanceInfo(od);
});
});
unittest.group('obj-schema-ConnectivityTest', () {
unittest.test('to-json--from-json', () async {
final o = buildConnectivityTest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ConnectivityTest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkConnectivityTest(od);
});
});
unittest.group('obj-schema-DeliverInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildDeliverInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DeliverInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDeliverInfo(od);
});
});
unittest.group('obj-schema-DropInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildDropInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.DropInfo.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkDropInfo(od);
});
});
unittest.group('obj-schema-Empty', () {
unittest.test('to-json--from-json', () async {
final o = buildEmpty();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Empty.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEmpty(od);
});
});
unittest.group('obj-schema-Endpoint', () {
unittest.test('to-json--from-json', () async {
final o = buildEndpoint();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Endpoint.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkEndpoint(od);
});
});
unittest.group('obj-schema-EndpointInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildEndpointInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.EndpointInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkEndpointInfo(od);
});
});
unittest.group('obj-schema-Expr', () {
unittest.test('to-json--from-json', () async {
final o = buildExpr();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Expr.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkExpr(od);
});
});
unittest.group('obj-schema-FirewallInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildFirewallInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.FirewallInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkFirewallInfo(od);
});
});
unittest.group('obj-schema-ForwardInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildForwardInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ForwardInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkForwardInfo(od);
});
});
unittest.group('obj-schema-ForwardingRuleInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildForwardingRuleInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ForwardingRuleInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkForwardingRuleInfo(od);
});
});
unittest.group('obj-schema-GKEMasterInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildGKEMasterInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GKEMasterInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGKEMasterInfo(od);
});
});
unittest.group('obj-schema-GoogleServiceInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildGoogleServiceInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GoogleServiceInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGoogleServiceInfo(od);
});
});
unittest.group('obj-schema-InstanceInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildInstanceInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.InstanceInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkInstanceInfo(od);
});
});
unittest.group('obj-schema-ListConnectivityTestsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListConnectivityTestsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListConnectivityTestsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListConnectivityTestsResponse(od);
});
});
unittest.group('obj-schema-ListLocationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListLocationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListLocationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListLocationsResponse(od);
});
});
unittest.group('obj-schema-ListOperationsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildListOperationsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ListOperationsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkListOperationsResponse(od);
});
});
unittest.group('obj-schema-LoadBalancerBackend', () {
unittest.test('to-json--from-json', () async {
final o = buildLoadBalancerBackend();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LoadBalancerBackend.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLoadBalancerBackend(od);
});
});
unittest.group('obj-schema-LoadBalancerInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildLoadBalancerInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.LoadBalancerInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkLoadBalancerInfo(od);
});
});
unittest.group('obj-schema-Location', () {
unittest.test('to-json--from-json', () async {
final o = buildLocation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Location.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkLocation(od);
});
});
unittest.group('obj-schema-NetworkInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildNetworkInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.NetworkInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkNetworkInfo(od);
});
});
unittest.group('obj-schema-Operation', () {
unittest.test('to-json--from-json', () async {
final o = buildOperation();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Operation.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkOperation(od);
});
});
unittest.group('obj-schema-Policy', () {
unittest.test('to-json--from-json', () async {
final o = buildPolicy();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Policy.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkPolicy(od);
});
});
unittest.group('obj-schema-ReachabilityDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildReachabilityDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.ReachabilityDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkReachabilityDetails(od);
});
});
unittest.group('obj-schema-RerunConnectivityTestRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildRerunConnectivityTestRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RerunConnectivityTestRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRerunConnectivityTestRequest(od);
});
});
unittest.group('obj-schema-RouteInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildRouteInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.RouteInfo.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkRouteInfo(od);
});
});
unittest.group('obj-schema-SetIamPolicyRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildSetIamPolicyRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.SetIamPolicyRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(od);
});
});
unittest.group('obj-schema-Status', () {
unittest.test('to-json--from-json', () async {
final o = buildStatus();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Status.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkStatus(od);
});
});
unittest.group('obj-schema-Step', () {
unittest.test('to-json--from-json', () async {
final o = buildStep();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Step.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkStep(od);
});
});
unittest.group('obj-schema-TestIamPermissionsRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(od);
});
});
unittest.group('obj-schema-TestIamPermissionsResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildTestIamPermissionsResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestIamPermissionsResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsResponse(od);
});
});
unittest.group('obj-schema-Trace', () {
unittest.test('to-json--from-json', () async {
final o = buildTrace();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od =
api.Trace.fromJson(oJson as core.Map<core.String, core.dynamic>);
checkTrace(od);
});
});
unittest.group('obj-schema-VpcConnectorInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildVpcConnectorInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VpcConnectorInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVpcConnectorInfo(od);
});
});
unittest.group('obj-schema-VpnGatewayInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildVpnGatewayInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VpnGatewayInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVpnGatewayInfo(od);
});
});
unittest.group('obj-schema-VpnTunnelInfo', () {
unittest.test('to-json--from-json', () async {
final o = buildVpnTunnelInfo();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.VpnTunnelInfo.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkVpnTunnelInfo(od);
});
});
unittest.group('resource-ProjectsLocationsResource', () {
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock).projects.locations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildLocation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkLocation(response as api.Location);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock).projects.locations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListLocationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListLocationsResponse(response as api.ListLocationsResponse);
});
});
unittest.group('resource-ProjectsLocationsGlobalConnectivityTestsResource',
() {
unittest.test('method--create', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_request = buildConnectivityTest();
final arg_parent = 'foo';
final arg_testId = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ConnectivityTest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkConnectivityTest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['testId']!.first,
unittest.equals(arg_testId),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.create(arg_request, arg_parent,
testId: arg_testId, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildConnectivityTest());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkConnectivityTest(response as api.ConnectivityTest);
});
unittest.test('method--getIamPolicy', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_resource = 'foo';
final arg_options_requestedPolicyVersion = 42;
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
core.int.parse(queryMap['options.requestedPolicyVersion']!.first),
unittest.equals(arg_options_requestedPolicyVersion),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.getIamPolicy(arg_resource,
options_requestedPolicyVersion: arg_options_requestedPolicyVersion,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_parent = 'foo';
final arg_filter = 'foo';
final arg_orderBy = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
queryMap['orderBy']!.first,
unittest.equals(arg_orderBy),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListConnectivityTestsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_parent,
filter: arg_filter,
orderBy: arg_orderBy,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListConnectivityTestsResponse(
response as api.ListConnectivityTestsResponse);
});
unittest.test('method--patch', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_request = buildConnectivityTest();
final arg_name = 'foo';
final arg_updateMask = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.ConnectivityTest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkConnectivityTest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['updateMask']!.first,
unittest.equals(arg_updateMask),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.patch(arg_request, arg_name,
updateMask: arg_updateMask, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--rerun', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_request = buildRerunConnectivityTestRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.RerunConnectivityTestRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkRerunConnectivityTestRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.rerun(arg_request, arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--setIamPolicy', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_request = buildSetIamPolicyRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.SetIamPolicyRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkSetIamPolicyRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildPolicy());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.setIamPolicy(arg_request, arg_resource,
$fields: arg_$fields);
checkPolicy(response as api.Policy);
});
unittest.test('method--testIamPermissions', () async {
final mock = HttpServerMock();
final res = api.NetworkManagementApi(mock)
.projects
.locations
.global
.connectivityTests;
final arg_request = buildTestIamPermissionsRequest();
final arg_resource = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.TestIamPermissionsRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkTestIamPermissionsRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildTestIamPermissionsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.testIamPermissions(arg_request, arg_resource,
$fields: arg_$fields);
checkTestIamPermissionsResponse(
response as api.TestIamPermissionsResponse);
});
});
unittest.group('resource-ProjectsLocationsGlobalOperationsResource', () {
unittest.test('method--cancel', () async {
final mock = HttpServerMock();
final res =
api.NetworkManagementApi(mock).projects.locations.global.operations;
final arg_request = buildCancelOperationRequest();
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.CancelOperationRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkCancelOperationRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response =
await res.cancel(arg_request, arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--delete', () async {
final mock = HttpServerMock();
final res =
api.NetworkManagementApi(mock).projects.locations.global.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildEmpty());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.delete(arg_name, $fields: arg_$fields);
checkEmpty(response as api.Empty);
});
unittest.test('method--get', () async {
final mock = HttpServerMock();
final res =
api.NetworkManagementApi(mock).projects.locations.global.operations;
final arg_name = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildOperation());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.get(arg_name, $fields: arg_$fields);
checkOperation(response as api.Operation);
});
unittest.test('method--list', () async {
final mock = HttpServerMock();
final res =
api.NetworkManagementApi(mock).projects.locations.global.operations;
final arg_name = 'foo';
final arg_filter = 'foo';
final arg_pageSize = 42;
final arg_pageToken = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['filter']!.first,
unittest.equals(arg_filter),
);
unittest.expect(
core.int.parse(queryMap['pageSize']!.first),
unittest.equals(arg_pageSize),
);
unittest.expect(
queryMap['pageToken']!.first,
unittest.equals(arg_pageToken),
);
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildListOperationsResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.list(arg_name,
filter: arg_filter,
pageSize: arg_pageSize,
pageToken: arg_pageToken,
$fields: arg_$fields);
checkListOperationsResponse(response as api.ListOperationsResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/networkmanagement/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/networkmanagement/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 43967}
|
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_library_directive
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:googleapis/playintegrity/v1.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;
import '../test_shared.dart';
core.int buildCounterAccountActivity = 0;
api.AccountActivity buildAccountActivity() {
final o = api.AccountActivity();
buildCounterAccountActivity++;
if (buildCounterAccountActivity < 3) {
o.activityLevel = 'foo';
}
buildCounterAccountActivity--;
return o;
}
void checkAccountActivity(api.AccountActivity o) {
buildCounterAccountActivity++;
if (buildCounterAccountActivity < 3) {
unittest.expect(
o.activityLevel!,
unittest.equals('foo'),
);
}
buildCounterAccountActivity--;
}
core.int buildCounterAccountDetails = 0;
api.AccountDetails buildAccountDetails() {
final o = api.AccountDetails();
buildCounterAccountDetails++;
if (buildCounterAccountDetails < 3) {
o.accountActivity = buildAccountActivity();
o.appLicensingVerdict = 'foo';
}
buildCounterAccountDetails--;
return o;
}
void checkAccountDetails(api.AccountDetails o) {
buildCounterAccountDetails++;
if (buildCounterAccountDetails < 3) {
checkAccountActivity(o.accountActivity!);
unittest.expect(
o.appLicensingVerdict!,
unittest.equals('foo'),
);
}
buildCounterAccountDetails--;
}
core.List<core.String> buildUnnamed0() => [
'foo',
'foo',
];
void checkUnnamed0(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterAppIntegrity = 0;
api.AppIntegrity buildAppIntegrity() {
final o = api.AppIntegrity();
buildCounterAppIntegrity++;
if (buildCounterAppIntegrity < 3) {
o.appRecognitionVerdict = 'foo';
o.certificateSha256Digest = buildUnnamed0();
o.packageName = 'foo';
o.versionCode = 'foo';
}
buildCounterAppIntegrity--;
return o;
}
void checkAppIntegrity(api.AppIntegrity o) {
buildCounterAppIntegrity++;
if (buildCounterAppIntegrity < 3) {
unittest.expect(
o.appRecognitionVerdict!,
unittest.equals('foo'),
);
checkUnnamed0(o.certificateSha256Digest!);
unittest.expect(
o.packageName!,
unittest.equals('foo'),
);
unittest.expect(
o.versionCode!,
unittest.equals('foo'),
);
}
buildCounterAppIntegrity--;
}
core.int buildCounterDecodeIntegrityTokenRequest = 0;
api.DecodeIntegrityTokenRequest buildDecodeIntegrityTokenRequest() {
final o = api.DecodeIntegrityTokenRequest();
buildCounterDecodeIntegrityTokenRequest++;
if (buildCounterDecodeIntegrityTokenRequest < 3) {
o.integrityToken = 'foo';
}
buildCounterDecodeIntegrityTokenRequest--;
return o;
}
void checkDecodeIntegrityTokenRequest(api.DecodeIntegrityTokenRequest o) {
buildCounterDecodeIntegrityTokenRequest++;
if (buildCounterDecodeIntegrityTokenRequest < 3) {
unittest.expect(
o.integrityToken!,
unittest.equals('foo'),
);
}
buildCounterDecodeIntegrityTokenRequest--;
}
core.int buildCounterDecodeIntegrityTokenResponse = 0;
api.DecodeIntegrityTokenResponse buildDecodeIntegrityTokenResponse() {
final o = api.DecodeIntegrityTokenResponse();
buildCounterDecodeIntegrityTokenResponse++;
if (buildCounterDecodeIntegrityTokenResponse < 3) {
o.tokenPayloadExternal = buildTokenPayloadExternal();
}
buildCounterDecodeIntegrityTokenResponse--;
return o;
}
void checkDecodeIntegrityTokenResponse(api.DecodeIntegrityTokenResponse o) {
buildCounterDecodeIntegrityTokenResponse++;
if (buildCounterDecodeIntegrityTokenResponse < 3) {
checkTokenPayloadExternal(o.tokenPayloadExternal!);
}
buildCounterDecodeIntegrityTokenResponse--;
}
core.List<core.String> buildUnnamed1() => [
'foo',
'foo',
];
void checkUnnamed1(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterDeviceIntegrity = 0;
api.DeviceIntegrity buildDeviceIntegrity() {
final o = api.DeviceIntegrity();
buildCounterDeviceIntegrity++;
if (buildCounterDeviceIntegrity < 3) {
o.deviceRecognitionVerdict = buildUnnamed1();
}
buildCounterDeviceIntegrity--;
return o;
}
void checkDeviceIntegrity(api.DeviceIntegrity o) {
buildCounterDeviceIntegrity++;
if (buildCounterDeviceIntegrity < 3) {
checkUnnamed1(o.deviceRecognitionVerdict!);
}
buildCounterDeviceIntegrity--;
}
core.List<core.String> buildUnnamed2() => [
'foo',
'foo',
];
void checkUnnamed2(core.List<core.String> o) {
unittest.expect(o, unittest.hasLength(2));
unittest.expect(
o[0],
unittest.equals('foo'),
);
unittest.expect(
o[1],
unittest.equals('foo'),
);
}
core.int buildCounterGuidanceDetails = 0;
api.GuidanceDetails buildGuidanceDetails() {
final o = api.GuidanceDetails();
buildCounterGuidanceDetails++;
if (buildCounterGuidanceDetails < 3) {
o.userRemediation = buildUnnamed2();
}
buildCounterGuidanceDetails--;
return o;
}
void checkGuidanceDetails(api.GuidanceDetails o) {
buildCounterGuidanceDetails++;
if (buildCounterGuidanceDetails < 3) {
checkUnnamed2(o.userRemediation!);
}
buildCounterGuidanceDetails--;
}
core.int buildCounterRequestDetails = 0;
api.RequestDetails buildRequestDetails() {
final o = api.RequestDetails();
buildCounterRequestDetails++;
if (buildCounterRequestDetails < 3) {
o.nonce = 'foo';
o.requestHash = 'foo';
o.requestPackageName = 'foo';
o.timestampMillis = 'foo';
}
buildCounterRequestDetails--;
return o;
}
void checkRequestDetails(api.RequestDetails o) {
buildCounterRequestDetails++;
if (buildCounterRequestDetails < 3) {
unittest.expect(
o.nonce!,
unittest.equals('foo'),
);
unittest.expect(
o.requestHash!,
unittest.equals('foo'),
);
unittest.expect(
o.requestPackageName!,
unittest.equals('foo'),
);
unittest.expect(
o.timestampMillis!,
unittest.equals('foo'),
);
}
buildCounterRequestDetails--;
}
core.int buildCounterTestingDetails = 0;
api.TestingDetails buildTestingDetails() {
final o = api.TestingDetails();
buildCounterTestingDetails++;
if (buildCounterTestingDetails < 3) {
o.isTestingResponse = true;
}
buildCounterTestingDetails--;
return o;
}
void checkTestingDetails(api.TestingDetails o) {
buildCounterTestingDetails++;
if (buildCounterTestingDetails < 3) {
unittest.expect(o.isTestingResponse!, unittest.isTrue);
}
buildCounterTestingDetails--;
}
core.int buildCounterTokenPayloadExternal = 0;
api.TokenPayloadExternal buildTokenPayloadExternal() {
final o = api.TokenPayloadExternal();
buildCounterTokenPayloadExternal++;
if (buildCounterTokenPayloadExternal < 3) {
o.accountDetails = buildAccountDetails();
o.appIntegrity = buildAppIntegrity();
o.deviceIntegrity = buildDeviceIntegrity();
o.guidanceDetails = buildGuidanceDetails();
o.requestDetails = buildRequestDetails();
o.testingDetails = buildTestingDetails();
}
buildCounterTokenPayloadExternal--;
return o;
}
void checkTokenPayloadExternal(api.TokenPayloadExternal o) {
buildCounterTokenPayloadExternal++;
if (buildCounterTokenPayloadExternal < 3) {
checkAccountDetails(o.accountDetails!);
checkAppIntegrity(o.appIntegrity!);
checkDeviceIntegrity(o.deviceIntegrity!);
checkGuidanceDetails(o.guidanceDetails!);
checkRequestDetails(o.requestDetails!);
checkTestingDetails(o.testingDetails!);
}
buildCounterTokenPayloadExternal--;
}
void main() {
unittest.group('obj-schema-AccountActivity', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountActivity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountActivity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountActivity(od);
});
});
unittest.group('obj-schema-AccountDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildAccountDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AccountDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAccountDetails(od);
});
});
unittest.group('obj-schema-AppIntegrity', () {
unittest.test('to-json--from-json', () async {
final o = buildAppIntegrity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.AppIntegrity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkAppIntegrity(od);
});
});
unittest.group('obj-schema-DecodeIntegrityTokenRequest', () {
unittest.test('to-json--from-json', () async {
final o = buildDecodeIntegrityTokenRequest();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DecodeIntegrityTokenRequest.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDecodeIntegrityTokenRequest(od);
});
});
unittest.group('obj-schema-DecodeIntegrityTokenResponse', () {
unittest.test('to-json--from-json', () async {
final o = buildDecodeIntegrityTokenResponse();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DecodeIntegrityTokenResponse.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDecodeIntegrityTokenResponse(od);
});
});
unittest.group('obj-schema-DeviceIntegrity', () {
unittest.test('to-json--from-json', () async {
final o = buildDeviceIntegrity();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.DeviceIntegrity.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkDeviceIntegrity(od);
});
});
unittest.group('obj-schema-GuidanceDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildGuidanceDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.GuidanceDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkGuidanceDetails(od);
});
});
unittest.group('obj-schema-RequestDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildRequestDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.RequestDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkRequestDetails(od);
});
});
unittest.group('obj-schema-TestingDetails', () {
unittest.test('to-json--from-json', () async {
final o = buildTestingDetails();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TestingDetails.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTestingDetails(od);
});
});
unittest.group('obj-schema-TokenPayloadExternal', () {
unittest.test('to-json--from-json', () async {
final o = buildTokenPayloadExternal();
final oJson = convert.jsonDecode(convert.jsonEncode(o));
final od = api.TokenPayloadExternal.fromJson(
oJson as core.Map<core.String, core.dynamic>);
checkTokenPayloadExternal(od);
});
});
unittest.group('resource-V1Resource', () {
unittest.test('method--decodeIntegrityToken', () async {
final mock = HttpServerMock();
final res = api.PlayIntegrityApi(mock).v1;
final arg_request = buildDecodeIntegrityTokenRequest();
final arg_packageName = 'foo';
final arg_$fields = 'foo';
mock.register(unittest.expectAsync2((http.BaseRequest req, json) {
final obj = api.DecodeIntegrityTokenRequest.fromJson(
json as core.Map<core.String, core.dynamic>);
checkDecodeIntegrityTokenRequest(obj);
final path = req.url.path;
var pathOffset = 0;
core.int index;
core.String subPart;
unittest.expect(
path.substring(pathOffset, pathOffset + 1),
unittest.equals('/'),
);
pathOffset += 1;
unittest.expect(
path.substring(pathOffset, pathOffset + 3),
unittest.equals('v1/'),
);
pathOffset += 3;
// NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
final query = req.url.query;
var queryOffset = 0;
final queryMap = <core.String, core.List<core.String>>{};
void addQueryParam(core.String n, core.String v) =>
queryMap.putIfAbsent(n, () => []).add(v);
if (query.isNotEmpty) {
for (var part in query.split('&')) {
final keyValue = part.split('=');
addQueryParam(
core.Uri.decodeQueryComponent(keyValue[0]),
core.Uri.decodeQueryComponent(keyValue[1]),
);
}
}
unittest.expect(
queryMap['fields']!.first,
unittest.equals(arg_$fields),
);
final h = {
'content-type': 'application/json; charset=utf-8',
};
final resp = convert.json.encode(buildDecodeIntegrityTokenResponse());
return async.Future.value(stringResponse(200, h, resp));
}), true);
final response = await res.decodeIntegrityToken(
arg_request, arg_packageName,
$fields: arg_$fields);
checkDecodeIntegrityTokenResponse(
response as api.DecodeIntegrityTokenResponse);
});
});
}
|
googleapis.dart/generated/googleapis/test/playintegrity/v1_test.dart/0
|
{'file_path': 'googleapis.dart/generated/googleapis/test/playintegrity/v1_test.dart', 'repo_id': 'googleapis.dart', 'token_count': 5571}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.