| Index: generated/googleapis/test/spanner/v1_test.dart
|
| diff --git a/generated/googleapis/test/spanner/v1_test.dart b/generated/googleapis/test/spanner/v1_test.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..0774ee9cde5bfcf441b3fef7ca9b4e73f17e1f96
|
| --- /dev/null
|
| +++ b/generated/googleapis/test/spanner/v1_test.dart
|
| @@ -0,0 +1,4441 @@
|
| +library googleapis.spanner.v1.test;
|
| +
|
| +import "dart:core" as core;
|
| +import "dart:collection" as collection;
|
| +import "dart:async" as async;
|
| +import "dart:convert" as convert;
|
| +
|
| +import 'package:http/http.dart' as http;
|
| +import 'package:http/testing.dart' as http_testing;
|
| +import 'package:unittest/unittest.dart' as unittest;
|
| +
|
| +import 'package:googleapis/spanner/v1.dart' as api;
|
| +
|
| +class HttpServerMock extends http.BaseClient {
|
| + core.Function _callback;
|
| + core.bool _expectJson;
|
| +
|
| + void register(core.Function callback, core.bool expectJson) {
|
| + _callback = callback;
|
| + _expectJson = expectJson;
|
| + }
|
| +
|
| + async.Future<http.StreamedResponse> send(http.BaseRequest request) {
|
| + if (_expectJson) {
|
| + return request.finalize()
|
| + .transform(convert.UTF8.decoder)
|
| + .join('')
|
| + .then((core.String jsonString) {
|
| + if (jsonString.isEmpty) {
|
| + return _callback(request, null);
|
| + } else {
|
| + return _callback(request, convert.JSON.decode(jsonString));
|
| + }
|
| + });
|
| + } else {
|
| + var stream = request.finalize();
|
| + if (stream == null) {
|
| + return _callback(request, []);
|
| + } else {
|
| + return stream.toBytes().then((data) {
|
| + return _callback(request, data);
|
| + });
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +http.StreamedResponse stringResponse(
|
| + core.int status, core.Map headers, core.String body) {
|
| + var stream = new async.Stream.fromIterable([convert.UTF8.encode(body)]);
|
| + return new http.StreamedResponse(stream, status, headers: headers);
|
| +}
|
| +
|
| +buildUnnamed1769() {
|
| + var o = new core.List<api.AuditLogConfig>();
|
| + o.add(buildAuditLogConfig());
|
| + o.add(buildAuditLogConfig());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1769(core.List<api.AuditLogConfig> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkAuditLogConfig(o[0]);
|
| + checkAuditLogConfig(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1770() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1770(core.List<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 buildCounterAuditConfig = 0;
|
| +buildAuditConfig() {
|
| + var o = new api.AuditConfig();
|
| + buildCounterAuditConfig++;
|
| + if (buildCounterAuditConfig < 3) {
|
| + o.auditLogConfigs = buildUnnamed1769();
|
| + o.exemptedMembers = buildUnnamed1770();
|
| + o.service = "foo";
|
| + }
|
| + buildCounterAuditConfig--;
|
| + return o;
|
| +}
|
| +
|
| +checkAuditConfig(api.AuditConfig o) {
|
| + buildCounterAuditConfig++;
|
| + if (buildCounterAuditConfig < 3) {
|
| + checkUnnamed1769(o.auditLogConfigs);
|
| + checkUnnamed1770(o.exemptedMembers);
|
| + unittest.expect(o.service, unittest.equals('foo'));
|
| + }
|
| + buildCounterAuditConfig--;
|
| +}
|
| +
|
| +buildUnnamed1771() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1771(core.List<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;
|
| +buildAuditLogConfig() {
|
| + var o = new api.AuditLogConfig();
|
| + buildCounterAuditLogConfig++;
|
| + if (buildCounterAuditLogConfig < 3) {
|
| + o.exemptedMembers = buildUnnamed1771();
|
| + o.logType = "foo";
|
| + }
|
| + buildCounterAuditLogConfig--;
|
| + return o;
|
| +}
|
| +
|
| +checkAuditLogConfig(api.AuditLogConfig o) {
|
| + buildCounterAuditLogConfig++;
|
| + if (buildCounterAuditLogConfig < 3) {
|
| + checkUnnamed1771(o.exemptedMembers);
|
| + unittest.expect(o.logType, unittest.equals('foo'));
|
| + }
|
| + buildCounterAuditLogConfig--;
|
| +}
|
| +
|
| +core.int buildCounterBeginTransactionRequest = 0;
|
| +buildBeginTransactionRequest() {
|
| + var o = new api.BeginTransactionRequest();
|
| + buildCounterBeginTransactionRequest++;
|
| + if (buildCounterBeginTransactionRequest < 3) {
|
| + o.options = buildTransactionOptions();
|
| + }
|
| + buildCounterBeginTransactionRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkBeginTransactionRequest(api.BeginTransactionRequest o) {
|
| + buildCounterBeginTransactionRequest++;
|
| + if (buildCounterBeginTransactionRequest < 3) {
|
| + checkTransactionOptions(o.options);
|
| + }
|
| + buildCounterBeginTransactionRequest--;
|
| +}
|
| +
|
| +buildUnnamed1772() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1772(core.List<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;
|
| +buildBinding() {
|
| + var o = new api.Binding();
|
| + buildCounterBinding++;
|
| + if (buildCounterBinding < 3) {
|
| + o.members = buildUnnamed1772();
|
| + o.role = "foo";
|
| + }
|
| + buildCounterBinding--;
|
| + return o;
|
| +}
|
| +
|
| +checkBinding(api.Binding o) {
|
| + buildCounterBinding++;
|
| + if (buildCounterBinding < 3) {
|
| + checkUnnamed1772(o.members);
|
| + unittest.expect(o.role, unittest.equals('foo'));
|
| + }
|
| + buildCounterBinding--;
|
| +}
|
| +
|
| +core.int buildCounterChildLink = 0;
|
| +buildChildLink() {
|
| + var o = new api.ChildLink();
|
| + buildCounterChildLink++;
|
| + if (buildCounterChildLink < 3) {
|
| + o.childIndex = 42;
|
| + o.type = "foo";
|
| + o.variable = "foo";
|
| + }
|
| + buildCounterChildLink--;
|
| + return o;
|
| +}
|
| +
|
| +checkChildLink(api.ChildLink o) {
|
| + buildCounterChildLink++;
|
| + if (buildCounterChildLink < 3) {
|
| + unittest.expect(o.childIndex, unittest.equals(42));
|
| + unittest.expect(o.type, unittest.equals('foo'));
|
| + unittest.expect(o.variable, unittest.equals('foo'));
|
| + }
|
| + buildCounterChildLink--;
|
| +}
|
| +
|
| +core.int buildCounterCloudAuditOptions = 0;
|
| +buildCloudAuditOptions() {
|
| + var o = new api.CloudAuditOptions();
|
| + buildCounterCloudAuditOptions++;
|
| + if (buildCounterCloudAuditOptions < 3) {
|
| + }
|
| + buildCounterCloudAuditOptions--;
|
| + return o;
|
| +}
|
| +
|
| +checkCloudAuditOptions(api.CloudAuditOptions o) {
|
| + buildCounterCloudAuditOptions++;
|
| + if (buildCounterCloudAuditOptions < 3) {
|
| + }
|
| + buildCounterCloudAuditOptions--;
|
| +}
|
| +
|
| +buildUnnamed1773() {
|
| + var o = new core.List<api.Mutation>();
|
| + o.add(buildMutation());
|
| + o.add(buildMutation());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1773(core.List<api.Mutation> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkMutation(o[0]);
|
| + checkMutation(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterCommitRequest = 0;
|
| +buildCommitRequest() {
|
| + var o = new api.CommitRequest();
|
| + buildCounterCommitRequest++;
|
| + if (buildCounterCommitRequest < 3) {
|
| + o.mutations = buildUnnamed1773();
|
| + o.singleUseTransaction = buildTransactionOptions();
|
| + o.transactionId = "foo";
|
| + }
|
| + buildCounterCommitRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkCommitRequest(api.CommitRequest o) {
|
| + buildCounterCommitRequest++;
|
| + if (buildCounterCommitRequest < 3) {
|
| + checkUnnamed1773(o.mutations);
|
| + checkTransactionOptions(o.singleUseTransaction);
|
| + unittest.expect(o.transactionId, unittest.equals('foo'));
|
| + }
|
| + buildCounterCommitRequest--;
|
| +}
|
| +
|
| +core.int buildCounterCommitResponse = 0;
|
| +buildCommitResponse() {
|
| + var o = new api.CommitResponse();
|
| + buildCounterCommitResponse++;
|
| + if (buildCounterCommitResponse < 3) {
|
| + o.commitTimestamp = "foo";
|
| + }
|
| + buildCounterCommitResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkCommitResponse(api.CommitResponse o) {
|
| + buildCounterCommitResponse++;
|
| + if (buildCounterCommitResponse < 3) {
|
| + unittest.expect(o.commitTimestamp, unittest.equals('foo'));
|
| + }
|
| + buildCounterCommitResponse--;
|
| +}
|
| +
|
| +buildUnnamed1774() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1774(core.List<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 buildCounterCondition = 0;
|
| +buildCondition() {
|
| + var o = new api.Condition();
|
| + buildCounterCondition++;
|
| + if (buildCounterCondition < 3) {
|
| + o.iam = "foo";
|
| + o.op = "foo";
|
| + o.svc = "foo";
|
| + o.sys = "foo";
|
| + o.value = "foo";
|
| + o.values = buildUnnamed1774();
|
| + }
|
| + buildCounterCondition--;
|
| + return o;
|
| +}
|
| +
|
| +checkCondition(api.Condition o) {
|
| + buildCounterCondition++;
|
| + if (buildCounterCondition < 3) {
|
| + unittest.expect(o.iam, unittest.equals('foo'));
|
| + unittest.expect(o.op, unittest.equals('foo'));
|
| + unittest.expect(o.svc, unittest.equals('foo'));
|
| + unittest.expect(o.sys, unittest.equals('foo'));
|
| + unittest.expect(o.value, unittest.equals('foo'));
|
| + checkUnnamed1774(o.values);
|
| + }
|
| + buildCounterCondition--;
|
| +}
|
| +
|
| +core.int buildCounterCounterOptions = 0;
|
| +buildCounterOptions() {
|
| + var o = new api.CounterOptions();
|
| + buildCounterCounterOptions++;
|
| + if (buildCounterCounterOptions < 3) {
|
| + o.field = "foo";
|
| + o.metric = "foo";
|
| + }
|
| + buildCounterCounterOptions--;
|
| + return o;
|
| +}
|
| +
|
| +checkCounterOptions(api.CounterOptions o) {
|
| + buildCounterCounterOptions++;
|
| + if (buildCounterCounterOptions < 3) {
|
| + unittest.expect(o.field, unittest.equals('foo'));
|
| + unittest.expect(o.metric, unittest.equals('foo'));
|
| + }
|
| + buildCounterCounterOptions--;
|
| +}
|
| +
|
| +core.int buildCounterCreateDatabaseMetadata = 0;
|
| +buildCreateDatabaseMetadata() {
|
| + var o = new api.CreateDatabaseMetadata();
|
| + buildCounterCreateDatabaseMetadata++;
|
| + if (buildCounterCreateDatabaseMetadata < 3) {
|
| + o.database = "foo";
|
| + }
|
| + buildCounterCreateDatabaseMetadata--;
|
| + return o;
|
| +}
|
| +
|
| +checkCreateDatabaseMetadata(api.CreateDatabaseMetadata o) {
|
| + buildCounterCreateDatabaseMetadata++;
|
| + if (buildCounterCreateDatabaseMetadata < 3) {
|
| + unittest.expect(o.database, unittest.equals('foo'));
|
| + }
|
| + buildCounterCreateDatabaseMetadata--;
|
| +}
|
| +
|
| +buildUnnamed1775() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1775(core.List<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 buildCounterCreateDatabaseRequest = 0;
|
| +buildCreateDatabaseRequest() {
|
| + var o = new api.CreateDatabaseRequest();
|
| + buildCounterCreateDatabaseRequest++;
|
| + if (buildCounterCreateDatabaseRequest < 3) {
|
| + o.createStatement = "foo";
|
| + o.extraStatements = buildUnnamed1775();
|
| + }
|
| + buildCounterCreateDatabaseRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkCreateDatabaseRequest(api.CreateDatabaseRequest o) {
|
| + buildCounterCreateDatabaseRequest++;
|
| + if (buildCounterCreateDatabaseRequest < 3) {
|
| + unittest.expect(o.createStatement, unittest.equals('foo'));
|
| + checkUnnamed1775(o.extraStatements);
|
| + }
|
| + buildCounterCreateDatabaseRequest--;
|
| +}
|
| +
|
| +core.int buildCounterCreateInstanceMetadata = 0;
|
| +buildCreateInstanceMetadata() {
|
| + var o = new api.CreateInstanceMetadata();
|
| + buildCounterCreateInstanceMetadata++;
|
| + if (buildCounterCreateInstanceMetadata < 3) {
|
| + o.cancelTime = "foo";
|
| + o.endTime = "foo";
|
| + o.instance = buildInstance();
|
| + o.startTime = "foo";
|
| + }
|
| + buildCounterCreateInstanceMetadata--;
|
| + return o;
|
| +}
|
| +
|
| +checkCreateInstanceMetadata(api.CreateInstanceMetadata o) {
|
| + buildCounterCreateInstanceMetadata++;
|
| + if (buildCounterCreateInstanceMetadata < 3) {
|
| + unittest.expect(o.cancelTime, unittest.equals('foo'));
|
| + unittest.expect(o.endTime, unittest.equals('foo'));
|
| + checkInstance(o.instance);
|
| + unittest.expect(o.startTime, unittest.equals('foo'));
|
| + }
|
| + buildCounterCreateInstanceMetadata--;
|
| +}
|
| +
|
| +core.int buildCounterCreateInstanceRequest = 0;
|
| +buildCreateInstanceRequest() {
|
| + var o = new api.CreateInstanceRequest();
|
| + buildCounterCreateInstanceRequest++;
|
| + if (buildCounterCreateInstanceRequest < 3) {
|
| + o.instance = buildInstance();
|
| + o.instanceId = "foo";
|
| + }
|
| + buildCounterCreateInstanceRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkCreateInstanceRequest(api.CreateInstanceRequest o) {
|
| + buildCounterCreateInstanceRequest++;
|
| + if (buildCounterCreateInstanceRequest < 3) {
|
| + checkInstance(o.instance);
|
| + unittest.expect(o.instanceId, unittest.equals('foo'));
|
| + }
|
| + buildCounterCreateInstanceRequest--;
|
| +}
|
| +
|
| +core.int buildCounterDataAccessOptions = 0;
|
| +buildDataAccessOptions() {
|
| + var o = new api.DataAccessOptions();
|
| + buildCounterDataAccessOptions++;
|
| + if (buildCounterDataAccessOptions < 3) {
|
| + }
|
| + buildCounterDataAccessOptions--;
|
| + return o;
|
| +}
|
| +
|
| +checkDataAccessOptions(api.DataAccessOptions o) {
|
| + buildCounterDataAccessOptions++;
|
| + if (buildCounterDataAccessOptions < 3) {
|
| + }
|
| + buildCounterDataAccessOptions--;
|
| +}
|
| +
|
| +core.int buildCounterDatabase = 0;
|
| +buildDatabase() {
|
| + var o = new api.Database();
|
| + buildCounterDatabase++;
|
| + if (buildCounterDatabase < 3) {
|
| + o.name = "foo";
|
| + o.state = "foo";
|
| + }
|
| + buildCounterDatabase--;
|
| + return o;
|
| +}
|
| +
|
| +checkDatabase(api.Database o) {
|
| + buildCounterDatabase++;
|
| + if (buildCounterDatabase < 3) {
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + unittest.expect(o.state, unittest.equals('foo'));
|
| + }
|
| + buildCounterDatabase--;
|
| +}
|
| +
|
| +core.int buildCounterDelete = 0;
|
| +buildDelete() {
|
| + var o = new api.Delete();
|
| + buildCounterDelete++;
|
| + if (buildCounterDelete < 3) {
|
| + o.keySet = buildKeySet();
|
| + o.table = "foo";
|
| + }
|
| + buildCounterDelete--;
|
| + return o;
|
| +}
|
| +
|
| +checkDelete(api.Delete o) {
|
| + buildCounterDelete++;
|
| + if (buildCounterDelete < 3) {
|
| + checkKeySet(o.keySet);
|
| + unittest.expect(o.table, unittest.equals('foo'));
|
| + }
|
| + buildCounterDelete--;
|
| +}
|
| +
|
| +core.int buildCounterEmpty = 0;
|
| +buildEmpty() {
|
| + var o = new api.Empty();
|
| + buildCounterEmpty++;
|
| + if (buildCounterEmpty < 3) {
|
| + }
|
| + buildCounterEmpty--;
|
| + return o;
|
| +}
|
| +
|
| +checkEmpty(api.Empty o) {
|
| + buildCounterEmpty++;
|
| + if (buildCounterEmpty < 3) {
|
| + }
|
| + buildCounterEmpty--;
|
| +}
|
| +
|
| +buildUnnamed1776() {
|
| + var o = new core.Map<core.String, api.Type>();
|
| + o["x"] = buildType();
|
| + o["y"] = buildType();
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1776(core.Map<core.String, api.Type> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkType(o["x"]);
|
| + checkType(o["y"]);
|
| +}
|
| +
|
| +buildUnnamed1777() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1777(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 buildCounterExecuteSqlRequest = 0;
|
| +buildExecuteSqlRequest() {
|
| + var o = new api.ExecuteSqlRequest();
|
| + buildCounterExecuteSqlRequest++;
|
| + if (buildCounterExecuteSqlRequest < 3) {
|
| + o.paramTypes = buildUnnamed1776();
|
| + o.params = buildUnnamed1777();
|
| + o.queryMode = "foo";
|
| + o.resumeToken = "foo";
|
| + o.sql = "foo";
|
| + o.transaction = buildTransactionSelector();
|
| + }
|
| + buildCounterExecuteSqlRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkExecuteSqlRequest(api.ExecuteSqlRequest o) {
|
| + buildCounterExecuteSqlRequest++;
|
| + if (buildCounterExecuteSqlRequest < 3) {
|
| + checkUnnamed1776(o.paramTypes);
|
| + checkUnnamed1777(o.params);
|
| + unittest.expect(o.queryMode, unittest.equals('foo'));
|
| + unittest.expect(o.resumeToken, unittest.equals('foo'));
|
| + unittest.expect(o.sql, unittest.equals('foo'));
|
| + checkTransactionSelector(o.transaction);
|
| + }
|
| + buildCounterExecuteSqlRequest--;
|
| +}
|
| +
|
| +core.int buildCounterField = 0;
|
| +buildField() {
|
| + var o = new api.Field();
|
| + buildCounterField++;
|
| + if (buildCounterField < 3) {
|
| + o.name = "foo";
|
| + o.type = buildType();
|
| + }
|
| + buildCounterField--;
|
| + return o;
|
| +}
|
| +
|
| +checkField(api.Field o) {
|
| + buildCounterField++;
|
| + if (buildCounterField < 3) {
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + checkType(o.type);
|
| + }
|
| + buildCounterField--;
|
| +}
|
| +
|
| +buildUnnamed1778() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1778(core.List<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 buildCounterGetDatabaseDdlResponse = 0;
|
| +buildGetDatabaseDdlResponse() {
|
| + var o = new api.GetDatabaseDdlResponse();
|
| + buildCounterGetDatabaseDdlResponse++;
|
| + if (buildCounterGetDatabaseDdlResponse < 3) {
|
| + o.statements = buildUnnamed1778();
|
| + }
|
| + buildCounterGetDatabaseDdlResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkGetDatabaseDdlResponse(api.GetDatabaseDdlResponse o) {
|
| + buildCounterGetDatabaseDdlResponse++;
|
| + if (buildCounterGetDatabaseDdlResponse < 3) {
|
| + checkUnnamed1778(o.statements);
|
| + }
|
| + buildCounterGetDatabaseDdlResponse--;
|
| +}
|
| +
|
| +core.int buildCounterGetIamPolicyRequest = 0;
|
| +buildGetIamPolicyRequest() {
|
| + var o = new api.GetIamPolicyRequest();
|
| + buildCounterGetIamPolicyRequest++;
|
| + if (buildCounterGetIamPolicyRequest < 3) {
|
| + }
|
| + buildCounterGetIamPolicyRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkGetIamPolicyRequest(api.GetIamPolicyRequest o) {
|
| + buildCounterGetIamPolicyRequest++;
|
| + if (buildCounterGetIamPolicyRequest < 3) {
|
| + }
|
| + buildCounterGetIamPolicyRequest--;
|
| +}
|
| +
|
| +buildUnnamed1779() {
|
| + var o = new core.Map<core.String, core.String>();
|
| + o["x"] = "foo";
|
| + o["y"] = "foo";
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1779(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 buildCounterInstance = 0;
|
| +buildInstance() {
|
| + var o = new api.Instance();
|
| + buildCounterInstance++;
|
| + if (buildCounterInstance < 3) {
|
| + o.config = "foo";
|
| + o.displayName = "foo";
|
| + o.labels = buildUnnamed1779();
|
| + o.name = "foo";
|
| + o.nodeCount = 42;
|
| + o.state = "foo";
|
| + }
|
| + buildCounterInstance--;
|
| + return o;
|
| +}
|
| +
|
| +checkInstance(api.Instance o) {
|
| + buildCounterInstance++;
|
| + if (buildCounterInstance < 3) {
|
| + unittest.expect(o.config, unittest.equals('foo'));
|
| + unittest.expect(o.displayName, unittest.equals('foo'));
|
| + checkUnnamed1779(o.labels);
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + unittest.expect(o.nodeCount, unittest.equals(42));
|
| + unittest.expect(o.state, unittest.equals('foo'));
|
| + }
|
| + buildCounterInstance--;
|
| +}
|
| +
|
| +core.int buildCounterInstanceConfig = 0;
|
| +buildInstanceConfig() {
|
| + var o = new api.InstanceConfig();
|
| + buildCounterInstanceConfig++;
|
| + if (buildCounterInstanceConfig < 3) {
|
| + o.displayName = "foo";
|
| + o.name = "foo";
|
| + }
|
| + buildCounterInstanceConfig--;
|
| + return o;
|
| +}
|
| +
|
| +checkInstanceConfig(api.InstanceConfig o) {
|
| + buildCounterInstanceConfig++;
|
| + if (buildCounterInstanceConfig < 3) {
|
| + unittest.expect(o.displayName, unittest.equals('foo'));
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + }
|
| + buildCounterInstanceConfig--;
|
| +}
|
| +
|
| +buildUnnamed1780() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1780(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted3 = (o[0]) 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[1]) 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'));
|
| +}
|
| +
|
| +buildUnnamed1781() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1781(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted5 = (o[0]) 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[1]) 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'));
|
| +}
|
| +
|
| +buildUnnamed1782() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1782(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted7 = (o[0]) 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[1]) 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'));
|
| +}
|
| +
|
| +buildUnnamed1783() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1783(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted9 = (o[0]) 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[1]) 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.int buildCounterKeyRange = 0;
|
| +buildKeyRange() {
|
| + var o = new api.KeyRange();
|
| + buildCounterKeyRange++;
|
| + if (buildCounterKeyRange < 3) {
|
| + o.endClosed = buildUnnamed1780();
|
| + o.endOpen = buildUnnamed1781();
|
| + o.startClosed = buildUnnamed1782();
|
| + o.startOpen = buildUnnamed1783();
|
| + }
|
| + buildCounterKeyRange--;
|
| + return o;
|
| +}
|
| +
|
| +checkKeyRange(api.KeyRange o) {
|
| + buildCounterKeyRange++;
|
| + if (buildCounterKeyRange < 3) {
|
| + checkUnnamed1780(o.endClosed);
|
| + checkUnnamed1781(o.endOpen);
|
| + checkUnnamed1782(o.startClosed);
|
| + checkUnnamed1783(o.startOpen);
|
| + }
|
| + buildCounterKeyRange--;
|
| +}
|
| +
|
| +buildUnnamed1784() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1784(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted11 = (o[0]) 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[1]) 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'));
|
| +}
|
| +
|
| +buildUnnamed1785() {
|
| + var o = new core.List<core.List<core.Object>>();
|
| + o.add(buildUnnamed1784());
|
| + o.add(buildUnnamed1784());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1785(core.List<core.List<core.Object>> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkUnnamed1784(o[0]);
|
| + checkUnnamed1784(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1786() {
|
| + var o = new core.List<api.KeyRange>();
|
| + o.add(buildKeyRange());
|
| + o.add(buildKeyRange());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1786(core.List<api.KeyRange> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkKeyRange(o[0]);
|
| + checkKeyRange(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterKeySet = 0;
|
| +buildKeySet() {
|
| + var o = new api.KeySet();
|
| + buildCounterKeySet++;
|
| + if (buildCounterKeySet < 3) {
|
| + o.all = true;
|
| + o.keys = buildUnnamed1785();
|
| + o.ranges = buildUnnamed1786();
|
| + }
|
| + buildCounterKeySet--;
|
| + return o;
|
| +}
|
| +
|
| +checkKeySet(api.KeySet o) {
|
| + buildCounterKeySet++;
|
| + if (buildCounterKeySet < 3) {
|
| + unittest.expect(o.all, unittest.isTrue);
|
| + checkUnnamed1785(o.keys);
|
| + checkUnnamed1786(o.ranges);
|
| + }
|
| + buildCounterKeySet--;
|
| +}
|
| +
|
| +buildUnnamed1787() {
|
| + var o = new core.List<api.Database>();
|
| + o.add(buildDatabase());
|
| + o.add(buildDatabase());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1787(core.List<api.Database> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkDatabase(o[0]);
|
| + checkDatabase(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterListDatabasesResponse = 0;
|
| +buildListDatabasesResponse() {
|
| + var o = new api.ListDatabasesResponse();
|
| + buildCounterListDatabasesResponse++;
|
| + if (buildCounterListDatabasesResponse < 3) {
|
| + o.databases = buildUnnamed1787();
|
| + o.nextPageToken = "foo";
|
| + }
|
| + buildCounterListDatabasesResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkListDatabasesResponse(api.ListDatabasesResponse o) {
|
| + buildCounterListDatabasesResponse++;
|
| + if (buildCounterListDatabasesResponse < 3) {
|
| + checkUnnamed1787(o.databases);
|
| + unittest.expect(o.nextPageToken, unittest.equals('foo'));
|
| + }
|
| + buildCounterListDatabasesResponse--;
|
| +}
|
| +
|
| +buildUnnamed1788() {
|
| + var o = new core.List<api.InstanceConfig>();
|
| + o.add(buildInstanceConfig());
|
| + o.add(buildInstanceConfig());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1788(core.List<api.InstanceConfig> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkInstanceConfig(o[0]);
|
| + checkInstanceConfig(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterListInstanceConfigsResponse = 0;
|
| +buildListInstanceConfigsResponse() {
|
| + var o = new api.ListInstanceConfigsResponse();
|
| + buildCounterListInstanceConfigsResponse++;
|
| + if (buildCounterListInstanceConfigsResponse < 3) {
|
| + o.instanceConfigs = buildUnnamed1788();
|
| + o.nextPageToken = "foo";
|
| + }
|
| + buildCounterListInstanceConfigsResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkListInstanceConfigsResponse(api.ListInstanceConfigsResponse o) {
|
| + buildCounterListInstanceConfigsResponse++;
|
| + if (buildCounterListInstanceConfigsResponse < 3) {
|
| + checkUnnamed1788(o.instanceConfigs);
|
| + unittest.expect(o.nextPageToken, unittest.equals('foo'));
|
| + }
|
| + buildCounterListInstanceConfigsResponse--;
|
| +}
|
| +
|
| +buildUnnamed1789() {
|
| + var o = new core.List<api.Instance>();
|
| + o.add(buildInstance());
|
| + o.add(buildInstance());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1789(core.List<api.Instance> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkInstance(o[0]);
|
| + checkInstance(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterListInstancesResponse = 0;
|
| +buildListInstancesResponse() {
|
| + var o = new api.ListInstancesResponse();
|
| + buildCounterListInstancesResponse++;
|
| + if (buildCounterListInstancesResponse < 3) {
|
| + o.instances = buildUnnamed1789();
|
| + o.nextPageToken = "foo";
|
| + }
|
| + buildCounterListInstancesResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkListInstancesResponse(api.ListInstancesResponse o) {
|
| + buildCounterListInstancesResponse++;
|
| + if (buildCounterListInstancesResponse < 3) {
|
| + checkUnnamed1789(o.instances);
|
| + unittest.expect(o.nextPageToken, unittest.equals('foo'));
|
| + }
|
| + buildCounterListInstancesResponse--;
|
| +}
|
| +
|
| +buildUnnamed1790() {
|
| + var o = new core.List<api.Operation>();
|
| + o.add(buildOperation());
|
| + o.add(buildOperation());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1790(core.List<api.Operation> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkOperation(o[0]);
|
| + checkOperation(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterListOperationsResponse = 0;
|
| +buildListOperationsResponse() {
|
| + var o = new api.ListOperationsResponse();
|
| + buildCounterListOperationsResponse++;
|
| + if (buildCounterListOperationsResponse < 3) {
|
| + o.nextPageToken = "foo";
|
| + o.operations = buildUnnamed1790();
|
| + }
|
| + buildCounterListOperationsResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkListOperationsResponse(api.ListOperationsResponse o) {
|
| + buildCounterListOperationsResponse++;
|
| + if (buildCounterListOperationsResponse < 3) {
|
| + unittest.expect(o.nextPageToken, unittest.equals('foo'));
|
| + checkUnnamed1790(o.operations);
|
| + }
|
| + buildCounterListOperationsResponse--;
|
| +}
|
| +
|
| +core.int buildCounterLogConfig = 0;
|
| +buildLogConfig() {
|
| + var o = new api.LogConfig();
|
| + buildCounterLogConfig++;
|
| + if (buildCounterLogConfig < 3) {
|
| + o.cloudAudit = buildCloudAuditOptions();
|
| + o.counter = buildCounterOptions();
|
| + o.dataAccess = buildDataAccessOptions();
|
| + }
|
| + buildCounterLogConfig--;
|
| + return o;
|
| +}
|
| +
|
| +checkLogConfig(api.LogConfig o) {
|
| + buildCounterLogConfig++;
|
| + if (buildCounterLogConfig < 3) {
|
| + checkCloudAuditOptions(o.cloudAudit);
|
| + checkCounterOptions(o.counter);
|
| + checkDataAccessOptions(o.dataAccess);
|
| + }
|
| + buildCounterLogConfig--;
|
| +}
|
| +
|
| +core.int buildCounterMutation = 0;
|
| +buildMutation() {
|
| + var o = new api.Mutation();
|
| + buildCounterMutation++;
|
| + if (buildCounterMutation < 3) {
|
| + o.delete = buildDelete();
|
| + o.insert = buildWrite();
|
| + o.insertOrUpdate = buildWrite();
|
| + o.replace = buildWrite();
|
| + o.update = buildWrite();
|
| + }
|
| + buildCounterMutation--;
|
| + return o;
|
| +}
|
| +
|
| +checkMutation(api.Mutation o) {
|
| + buildCounterMutation++;
|
| + if (buildCounterMutation < 3) {
|
| + checkDelete(o.delete);
|
| + checkWrite(o.insert);
|
| + checkWrite(o.insertOrUpdate);
|
| + checkWrite(o.replace);
|
| + checkWrite(o.update);
|
| + }
|
| + buildCounterMutation--;
|
| +}
|
| +
|
| +buildUnnamed1791() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1791(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'));
|
| +}
|
| +
|
| +buildUnnamed1792() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1792(core.Map<core.String, core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted15 = (o["x"]) as core.Map; unittest.expect(casted15, unittest.hasLength(3)); unittest.expect(casted15["list"], unittest.equals([1, 2, 3])); unittest.expect(casted15["bool"], unittest.equals(true)); unittest.expect(casted15["string"], unittest.equals('foo'));
|
| + var casted16 = (o["y"]) as core.Map; unittest.expect(casted16, unittest.hasLength(3)); unittest.expect(casted16["list"], unittest.equals([1, 2, 3])); unittest.expect(casted16["bool"], unittest.equals(true)); unittest.expect(casted16["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +core.int buildCounterOperation = 0;
|
| +buildOperation() {
|
| + var o = new api.Operation();
|
| + buildCounterOperation++;
|
| + if (buildCounterOperation < 3) {
|
| + o.done = true;
|
| + o.error = buildStatus();
|
| + o.metadata = buildUnnamed1791();
|
| + o.name = "foo";
|
| + o.response = buildUnnamed1792();
|
| + }
|
| + buildCounterOperation--;
|
| + return o;
|
| +}
|
| +
|
| +checkOperation(api.Operation o) {
|
| + buildCounterOperation++;
|
| + if (buildCounterOperation < 3) {
|
| + unittest.expect(o.done, unittest.isTrue);
|
| + checkStatus(o.error);
|
| + checkUnnamed1791(o.metadata);
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + checkUnnamed1792(o.response);
|
| + }
|
| + buildCounterOperation--;
|
| +}
|
| +
|
| +buildUnnamed1793() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1793(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted17 = (o[0]) as core.Map; unittest.expect(casted17, unittest.hasLength(3)); unittest.expect(casted17["list"], unittest.equals([1, 2, 3])); unittest.expect(casted17["bool"], unittest.equals(true)); unittest.expect(casted17["string"], unittest.equals('foo'));
|
| + var casted18 = (o[1]) as core.Map; unittest.expect(casted18, unittest.hasLength(3)); unittest.expect(casted18["list"], unittest.equals([1, 2, 3])); unittest.expect(casted18["bool"], unittest.equals(true)); unittest.expect(casted18["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +core.int buildCounterPartialResultSet = 0;
|
| +buildPartialResultSet() {
|
| + var o = new api.PartialResultSet();
|
| + buildCounterPartialResultSet++;
|
| + if (buildCounterPartialResultSet < 3) {
|
| + o.chunkedValue = true;
|
| + o.metadata = buildResultSetMetadata();
|
| + o.resumeToken = "foo";
|
| + o.stats = buildResultSetStats();
|
| + o.values = buildUnnamed1793();
|
| + }
|
| + buildCounterPartialResultSet--;
|
| + return o;
|
| +}
|
| +
|
| +checkPartialResultSet(api.PartialResultSet o) {
|
| + buildCounterPartialResultSet++;
|
| + if (buildCounterPartialResultSet < 3) {
|
| + unittest.expect(o.chunkedValue, unittest.isTrue);
|
| + checkResultSetMetadata(o.metadata);
|
| + unittest.expect(o.resumeToken, unittest.equals('foo'));
|
| + checkResultSetStats(o.stats);
|
| + checkUnnamed1793(o.values);
|
| + }
|
| + buildCounterPartialResultSet--;
|
| +}
|
| +
|
| +buildUnnamed1794() {
|
| + var o = new core.List<api.ChildLink>();
|
| + o.add(buildChildLink());
|
| + o.add(buildChildLink());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1794(core.List<api.ChildLink> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkChildLink(o[0]);
|
| + checkChildLink(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1795() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1795(core.Map<core.String, core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted19 = (o["x"]) as core.Map; unittest.expect(casted19, unittest.hasLength(3)); unittest.expect(casted19["list"], unittest.equals([1, 2, 3])); unittest.expect(casted19["bool"], unittest.equals(true)); unittest.expect(casted19["string"], unittest.equals('foo'));
|
| + var casted20 = (o["y"]) as core.Map; unittest.expect(casted20, unittest.hasLength(3)); unittest.expect(casted20["list"], unittest.equals([1, 2, 3])); unittest.expect(casted20["bool"], unittest.equals(true)); unittest.expect(casted20["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1796() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1796(core.Map<core.String, core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted21 = (o["x"]) as core.Map; unittest.expect(casted21, unittest.hasLength(3)); unittest.expect(casted21["list"], unittest.equals([1, 2, 3])); unittest.expect(casted21["bool"], unittest.equals(true)); unittest.expect(casted21["string"], unittest.equals('foo'));
|
| + var casted22 = (o["y"]) as core.Map; unittest.expect(casted22, unittest.hasLength(3)); unittest.expect(casted22["list"], unittest.equals([1, 2, 3])); unittest.expect(casted22["bool"], unittest.equals(true)); unittest.expect(casted22["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +core.int buildCounterPlanNode = 0;
|
| +buildPlanNode() {
|
| + var o = new api.PlanNode();
|
| + buildCounterPlanNode++;
|
| + if (buildCounterPlanNode < 3) {
|
| + o.childLinks = buildUnnamed1794();
|
| + o.displayName = "foo";
|
| + o.executionStats = buildUnnamed1795();
|
| + o.index = 42;
|
| + o.kind = "foo";
|
| + o.metadata = buildUnnamed1796();
|
| + o.shortRepresentation = buildShortRepresentation();
|
| + }
|
| + buildCounterPlanNode--;
|
| + return o;
|
| +}
|
| +
|
| +checkPlanNode(api.PlanNode o) {
|
| + buildCounterPlanNode++;
|
| + if (buildCounterPlanNode < 3) {
|
| + checkUnnamed1794(o.childLinks);
|
| + unittest.expect(o.displayName, unittest.equals('foo'));
|
| + checkUnnamed1795(o.executionStats);
|
| + unittest.expect(o.index, unittest.equals(42));
|
| + unittest.expect(o.kind, unittest.equals('foo'));
|
| + checkUnnamed1796(o.metadata);
|
| + checkShortRepresentation(o.shortRepresentation);
|
| + }
|
| + buildCounterPlanNode--;
|
| +}
|
| +
|
| +buildUnnamed1797() {
|
| + var o = new core.List<api.AuditConfig>();
|
| + o.add(buildAuditConfig());
|
| + o.add(buildAuditConfig());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1797(core.List<api.AuditConfig> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkAuditConfig(o[0]);
|
| + checkAuditConfig(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1798() {
|
| + var o = new core.List<api.Binding>();
|
| + o.add(buildBinding());
|
| + o.add(buildBinding());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1798(core.List<api.Binding> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkBinding(o[0]);
|
| + checkBinding(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1799() {
|
| + var o = new core.List<api.Rule>();
|
| + o.add(buildRule());
|
| + o.add(buildRule());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1799(core.List<api.Rule> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkRule(o[0]);
|
| + checkRule(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterPolicy = 0;
|
| +buildPolicy() {
|
| + var o = new api.Policy();
|
| + buildCounterPolicy++;
|
| + if (buildCounterPolicy < 3) {
|
| + o.auditConfigs = buildUnnamed1797();
|
| + o.bindings = buildUnnamed1798();
|
| + o.etag = "foo";
|
| + o.iamOwned = true;
|
| + o.rules = buildUnnamed1799();
|
| + o.version = 42;
|
| + }
|
| + buildCounterPolicy--;
|
| + return o;
|
| +}
|
| +
|
| +checkPolicy(api.Policy o) {
|
| + buildCounterPolicy++;
|
| + if (buildCounterPolicy < 3) {
|
| + checkUnnamed1797(o.auditConfigs);
|
| + checkUnnamed1798(o.bindings);
|
| + unittest.expect(o.etag, unittest.equals('foo'));
|
| + unittest.expect(o.iamOwned, unittest.isTrue);
|
| + checkUnnamed1799(o.rules);
|
| + unittest.expect(o.version, unittest.equals(42));
|
| + }
|
| + buildCounterPolicy--;
|
| +}
|
| +
|
| +buildUnnamed1800() {
|
| + var o = new core.List<api.PlanNode>();
|
| + o.add(buildPlanNode());
|
| + o.add(buildPlanNode());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1800(core.List<api.PlanNode> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkPlanNode(o[0]);
|
| + checkPlanNode(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterQueryPlan = 0;
|
| +buildQueryPlan() {
|
| + var o = new api.QueryPlan();
|
| + buildCounterQueryPlan++;
|
| + if (buildCounterQueryPlan < 3) {
|
| + o.planNodes = buildUnnamed1800();
|
| + }
|
| + buildCounterQueryPlan--;
|
| + return o;
|
| +}
|
| +
|
| +checkQueryPlan(api.QueryPlan o) {
|
| + buildCounterQueryPlan++;
|
| + if (buildCounterQueryPlan < 3) {
|
| + checkUnnamed1800(o.planNodes);
|
| + }
|
| + buildCounterQueryPlan--;
|
| +}
|
| +
|
| +core.int buildCounterReadOnly = 0;
|
| +buildReadOnly() {
|
| + var o = new api.ReadOnly();
|
| + buildCounterReadOnly++;
|
| + if (buildCounterReadOnly < 3) {
|
| + o.exactStaleness = "foo";
|
| + o.maxStaleness = "foo";
|
| + o.minReadTimestamp = "foo";
|
| + o.readTimestamp = "foo";
|
| + o.returnReadTimestamp = true;
|
| + o.strong = true;
|
| + }
|
| + buildCounterReadOnly--;
|
| + return o;
|
| +}
|
| +
|
| +checkReadOnly(api.ReadOnly o) {
|
| + buildCounterReadOnly++;
|
| + if (buildCounterReadOnly < 3) {
|
| + unittest.expect(o.exactStaleness, unittest.equals('foo'));
|
| + unittest.expect(o.maxStaleness, unittest.equals('foo'));
|
| + unittest.expect(o.minReadTimestamp, unittest.equals('foo'));
|
| + unittest.expect(o.readTimestamp, unittest.equals('foo'));
|
| + unittest.expect(o.returnReadTimestamp, unittest.isTrue);
|
| + unittest.expect(o.strong, unittest.isTrue);
|
| + }
|
| + buildCounterReadOnly--;
|
| +}
|
| +
|
| +buildUnnamed1801() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1801(core.List<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 buildCounterReadRequest = 0;
|
| +buildReadRequest() {
|
| + var o = new api.ReadRequest();
|
| + buildCounterReadRequest++;
|
| + if (buildCounterReadRequest < 3) {
|
| + o.columns = buildUnnamed1801();
|
| + o.index = "foo";
|
| + o.keySet = buildKeySet();
|
| + o.limit = "foo";
|
| + o.resumeToken = "foo";
|
| + o.table = "foo";
|
| + o.transaction = buildTransactionSelector();
|
| + }
|
| + buildCounterReadRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkReadRequest(api.ReadRequest o) {
|
| + buildCounterReadRequest++;
|
| + if (buildCounterReadRequest < 3) {
|
| + checkUnnamed1801(o.columns);
|
| + unittest.expect(o.index, unittest.equals('foo'));
|
| + checkKeySet(o.keySet);
|
| + unittest.expect(o.limit, unittest.equals('foo'));
|
| + unittest.expect(o.resumeToken, unittest.equals('foo'));
|
| + unittest.expect(o.table, unittest.equals('foo'));
|
| + checkTransactionSelector(o.transaction);
|
| + }
|
| + buildCounterReadRequest--;
|
| +}
|
| +
|
| +core.int buildCounterReadWrite = 0;
|
| +buildReadWrite() {
|
| + var o = new api.ReadWrite();
|
| + buildCounterReadWrite++;
|
| + if (buildCounterReadWrite < 3) {
|
| + }
|
| + buildCounterReadWrite--;
|
| + return o;
|
| +}
|
| +
|
| +checkReadWrite(api.ReadWrite o) {
|
| + buildCounterReadWrite++;
|
| + if (buildCounterReadWrite < 3) {
|
| + }
|
| + buildCounterReadWrite--;
|
| +}
|
| +
|
| +buildUnnamed1802() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1802(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted23 = (o[0]) as core.Map; unittest.expect(casted23, unittest.hasLength(3)); unittest.expect(casted23["list"], unittest.equals([1, 2, 3])); unittest.expect(casted23["bool"], unittest.equals(true)); unittest.expect(casted23["string"], unittest.equals('foo'));
|
| + var casted24 = (o[1]) as core.Map; unittest.expect(casted24, unittest.hasLength(3)); unittest.expect(casted24["list"], unittest.equals([1, 2, 3])); unittest.expect(casted24["bool"], unittest.equals(true)); unittest.expect(casted24["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1803() {
|
| + var o = new core.List<core.List<core.Object>>();
|
| + o.add(buildUnnamed1802());
|
| + o.add(buildUnnamed1802());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1803(core.List<core.List<core.Object>> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkUnnamed1802(o[0]);
|
| + checkUnnamed1802(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterResultSet = 0;
|
| +buildResultSet() {
|
| + var o = new api.ResultSet();
|
| + buildCounterResultSet++;
|
| + if (buildCounterResultSet < 3) {
|
| + o.metadata = buildResultSetMetadata();
|
| + o.rows = buildUnnamed1803();
|
| + o.stats = buildResultSetStats();
|
| + }
|
| + buildCounterResultSet--;
|
| + return o;
|
| +}
|
| +
|
| +checkResultSet(api.ResultSet o) {
|
| + buildCounterResultSet++;
|
| + if (buildCounterResultSet < 3) {
|
| + checkResultSetMetadata(o.metadata);
|
| + checkUnnamed1803(o.rows);
|
| + checkResultSetStats(o.stats);
|
| + }
|
| + buildCounterResultSet--;
|
| +}
|
| +
|
| +core.int buildCounterResultSetMetadata = 0;
|
| +buildResultSetMetadata() {
|
| + var o = new api.ResultSetMetadata();
|
| + buildCounterResultSetMetadata++;
|
| + if (buildCounterResultSetMetadata < 3) {
|
| + o.rowType = buildStructType();
|
| + o.transaction = buildTransaction();
|
| + }
|
| + buildCounterResultSetMetadata--;
|
| + return o;
|
| +}
|
| +
|
| +checkResultSetMetadata(api.ResultSetMetadata o) {
|
| + buildCounterResultSetMetadata++;
|
| + if (buildCounterResultSetMetadata < 3) {
|
| + checkStructType(o.rowType);
|
| + checkTransaction(o.transaction);
|
| + }
|
| + buildCounterResultSetMetadata--;
|
| +}
|
| +
|
| +buildUnnamed1804() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1804(core.Map<core.String, core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted25 = (o["x"]) as core.Map; unittest.expect(casted25, unittest.hasLength(3)); unittest.expect(casted25["list"], unittest.equals([1, 2, 3])); unittest.expect(casted25["bool"], unittest.equals(true)); unittest.expect(casted25["string"], unittest.equals('foo'));
|
| + var casted26 = (o["y"]) as core.Map; unittest.expect(casted26, unittest.hasLength(3)); unittest.expect(casted26["list"], unittest.equals([1, 2, 3])); unittest.expect(casted26["bool"], unittest.equals(true)); unittest.expect(casted26["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +core.int buildCounterResultSetStats = 0;
|
| +buildResultSetStats() {
|
| + var o = new api.ResultSetStats();
|
| + buildCounterResultSetStats++;
|
| + if (buildCounterResultSetStats < 3) {
|
| + o.queryPlan = buildQueryPlan();
|
| + o.queryStats = buildUnnamed1804();
|
| + }
|
| + buildCounterResultSetStats--;
|
| + return o;
|
| +}
|
| +
|
| +checkResultSetStats(api.ResultSetStats o) {
|
| + buildCounterResultSetStats++;
|
| + if (buildCounterResultSetStats < 3) {
|
| + checkQueryPlan(o.queryPlan);
|
| + checkUnnamed1804(o.queryStats);
|
| + }
|
| + buildCounterResultSetStats--;
|
| +}
|
| +
|
| +core.int buildCounterRollbackRequest = 0;
|
| +buildRollbackRequest() {
|
| + var o = new api.RollbackRequest();
|
| + buildCounterRollbackRequest++;
|
| + if (buildCounterRollbackRequest < 3) {
|
| + o.transactionId = "foo";
|
| + }
|
| + buildCounterRollbackRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkRollbackRequest(api.RollbackRequest o) {
|
| + buildCounterRollbackRequest++;
|
| + if (buildCounterRollbackRequest < 3) {
|
| + unittest.expect(o.transactionId, unittest.equals('foo'));
|
| + }
|
| + buildCounterRollbackRequest--;
|
| +}
|
| +
|
| +buildUnnamed1805() {
|
| + var o = new core.List<api.Condition>();
|
| + o.add(buildCondition());
|
| + o.add(buildCondition());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1805(core.List<api.Condition> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkCondition(o[0]);
|
| + checkCondition(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1806() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1806(core.List<core.String> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + unittest.expect(o[0], unittest.equals('foo'));
|
| + unittest.expect(o[1], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1807() {
|
| + var o = new core.List<api.LogConfig>();
|
| + o.add(buildLogConfig());
|
| + o.add(buildLogConfig());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1807(core.List<api.LogConfig> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkLogConfig(o[0]);
|
| + checkLogConfig(o[1]);
|
| +}
|
| +
|
| +buildUnnamed1808() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1808(core.List<core.String> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + unittest.expect(o[0], unittest.equals('foo'));
|
| + unittest.expect(o[1], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1809() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1809(core.List<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 buildCounterRule = 0;
|
| +buildRule() {
|
| + var o = new api.Rule();
|
| + buildCounterRule++;
|
| + if (buildCounterRule < 3) {
|
| + o.action = "foo";
|
| + o.conditions = buildUnnamed1805();
|
| + o.description = "foo";
|
| + o.in_ = buildUnnamed1806();
|
| + o.logConfig = buildUnnamed1807();
|
| + o.notIn = buildUnnamed1808();
|
| + o.permissions = buildUnnamed1809();
|
| + }
|
| + buildCounterRule--;
|
| + return o;
|
| +}
|
| +
|
| +checkRule(api.Rule o) {
|
| + buildCounterRule++;
|
| + if (buildCounterRule < 3) {
|
| + unittest.expect(o.action, unittest.equals('foo'));
|
| + checkUnnamed1805(o.conditions);
|
| + unittest.expect(o.description, unittest.equals('foo'));
|
| + checkUnnamed1806(o.in_);
|
| + checkUnnamed1807(o.logConfig);
|
| + checkUnnamed1808(o.notIn);
|
| + checkUnnamed1809(o.permissions);
|
| + }
|
| + buildCounterRule--;
|
| +}
|
| +
|
| +core.int buildCounterSession = 0;
|
| +buildSession() {
|
| + var o = new api.Session();
|
| + buildCounterSession++;
|
| + if (buildCounterSession < 3) {
|
| + o.name = "foo";
|
| + }
|
| + buildCounterSession--;
|
| + return o;
|
| +}
|
| +
|
| +checkSession(api.Session o) {
|
| + buildCounterSession++;
|
| + if (buildCounterSession < 3) {
|
| + unittest.expect(o.name, unittest.equals('foo'));
|
| + }
|
| + buildCounterSession--;
|
| +}
|
| +
|
| +core.int buildCounterSetIamPolicyRequest = 0;
|
| +buildSetIamPolicyRequest() {
|
| + var o = new api.SetIamPolicyRequest();
|
| + buildCounterSetIamPolicyRequest++;
|
| + if (buildCounterSetIamPolicyRequest < 3) {
|
| + o.policy = buildPolicy();
|
| + o.updateMask = "foo";
|
| + }
|
| + buildCounterSetIamPolicyRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkSetIamPolicyRequest(api.SetIamPolicyRequest o) {
|
| + buildCounterSetIamPolicyRequest++;
|
| + if (buildCounterSetIamPolicyRequest < 3) {
|
| + checkPolicy(o.policy);
|
| + unittest.expect(o.updateMask, unittest.equals('foo'));
|
| + }
|
| + buildCounterSetIamPolicyRequest--;
|
| +}
|
| +
|
| +buildUnnamed1810() {
|
| + var o = new core.Map<core.String, core.int>();
|
| + o["x"] = 42;
|
| + o["y"] = 42;
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1810(core.Map<core.String, core.int> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + unittest.expect(o["x"], unittest.equals(42));
|
| + unittest.expect(o["y"], unittest.equals(42));
|
| +}
|
| +
|
| +core.int buildCounterShortRepresentation = 0;
|
| +buildShortRepresentation() {
|
| + var o = new api.ShortRepresentation();
|
| + buildCounterShortRepresentation++;
|
| + if (buildCounterShortRepresentation < 3) {
|
| + o.description = "foo";
|
| + o.subqueries = buildUnnamed1810();
|
| + }
|
| + buildCounterShortRepresentation--;
|
| + return o;
|
| +}
|
| +
|
| +checkShortRepresentation(api.ShortRepresentation o) {
|
| + buildCounterShortRepresentation++;
|
| + if (buildCounterShortRepresentation < 3) {
|
| + unittest.expect(o.description, unittest.equals('foo'));
|
| + checkUnnamed1810(o.subqueries);
|
| + }
|
| + buildCounterShortRepresentation--;
|
| +}
|
| +
|
| +buildUnnamed1811() {
|
| + var o = new core.Map<core.String, core.Object>();
|
| + o["x"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + o["y"] = {'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'};
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1811(core.Map<core.String, core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted27 = (o["x"]) as core.Map; unittest.expect(casted27, unittest.hasLength(3)); unittest.expect(casted27["list"], unittest.equals([1, 2, 3])); unittest.expect(casted27["bool"], unittest.equals(true)); unittest.expect(casted27["string"], unittest.equals('foo'));
|
| + var casted28 = (o["y"]) as core.Map; unittest.expect(casted28, unittest.hasLength(3)); unittest.expect(casted28["list"], unittest.equals([1, 2, 3])); unittest.expect(casted28["bool"], unittest.equals(true)); unittest.expect(casted28["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1812() {
|
| + var o = new core.List<core.Map<core.String, core.Object>>();
|
| + o.add(buildUnnamed1811());
|
| + o.add(buildUnnamed1811());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1812(core.List<core.Map<core.String, core.Object>> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkUnnamed1811(o[0]);
|
| + checkUnnamed1811(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterStatus = 0;
|
| +buildStatus() {
|
| + var o = new api.Status();
|
| + buildCounterStatus++;
|
| + if (buildCounterStatus < 3) {
|
| + o.code = 42;
|
| + o.details = buildUnnamed1812();
|
| + o.message = "foo";
|
| + }
|
| + buildCounterStatus--;
|
| + return o;
|
| +}
|
| +
|
| +checkStatus(api.Status o) {
|
| + buildCounterStatus++;
|
| + if (buildCounterStatus < 3) {
|
| + unittest.expect(o.code, unittest.equals(42));
|
| + checkUnnamed1812(o.details);
|
| + unittest.expect(o.message, unittest.equals('foo'));
|
| + }
|
| + buildCounterStatus--;
|
| +}
|
| +
|
| +buildUnnamed1813() {
|
| + var o = new core.List<api.Field>();
|
| + o.add(buildField());
|
| + o.add(buildField());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1813(core.List<api.Field> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkField(o[0]);
|
| + checkField(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterStructType = 0;
|
| +buildStructType() {
|
| + var o = new api.StructType();
|
| + buildCounterStructType++;
|
| + if (buildCounterStructType < 3) {
|
| + o.fields = buildUnnamed1813();
|
| + }
|
| + buildCounterStructType--;
|
| + return o;
|
| +}
|
| +
|
| +checkStructType(api.StructType o) {
|
| + buildCounterStructType++;
|
| + if (buildCounterStructType < 3) {
|
| + checkUnnamed1813(o.fields);
|
| + }
|
| + buildCounterStructType--;
|
| +}
|
| +
|
| +buildUnnamed1814() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1814(core.List<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;
|
| +buildTestIamPermissionsRequest() {
|
| + var o = new api.TestIamPermissionsRequest();
|
| + buildCounterTestIamPermissionsRequest++;
|
| + if (buildCounterTestIamPermissionsRequest < 3) {
|
| + o.permissions = buildUnnamed1814();
|
| + }
|
| + buildCounterTestIamPermissionsRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkTestIamPermissionsRequest(api.TestIamPermissionsRequest o) {
|
| + buildCounterTestIamPermissionsRequest++;
|
| + if (buildCounterTestIamPermissionsRequest < 3) {
|
| + checkUnnamed1814(o.permissions);
|
| + }
|
| + buildCounterTestIamPermissionsRequest--;
|
| +}
|
| +
|
| +buildUnnamed1815() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1815(core.List<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;
|
| +buildTestIamPermissionsResponse() {
|
| + var o = new api.TestIamPermissionsResponse();
|
| + buildCounterTestIamPermissionsResponse++;
|
| + if (buildCounterTestIamPermissionsResponse < 3) {
|
| + o.permissions = buildUnnamed1815();
|
| + }
|
| + buildCounterTestIamPermissionsResponse--;
|
| + return o;
|
| +}
|
| +
|
| +checkTestIamPermissionsResponse(api.TestIamPermissionsResponse o) {
|
| + buildCounterTestIamPermissionsResponse++;
|
| + if (buildCounterTestIamPermissionsResponse < 3) {
|
| + checkUnnamed1815(o.permissions);
|
| + }
|
| + buildCounterTestIamPermissionsResponse--;
|
| +}
|
| +
|
| +core.int buildCounterTransaction = 0;
|
| +buildTransaction() {
|
| + var o = new api.Transaction();
|
| + buildCounterTransaction++;
|
| + if (buildCounterTransaction < 3) {
|
| + o.id = "foo";
|
| + o.readTimestamp = "foo";
|
| + }
|
| + buildCounterTransaction--;
|
| + return o;
|
| +}
|
| +
|
| +checkTransaction(api.Transaction o) {
|
| + buildCounterTransaction++;
|
| + if (buildCounterTransaction < 3) {
|
| + unittest.expect(o.id, unittest.equals('foo'));
|
| + unittest.expect(o.readTimestamp, unittest.equals('foo'));
|
| + }
|
| + buildCounterTransaction--;
|
| +}
|
| +
|
| +core.int buildCounterTransactionOptions = 0;
|
| +buildTransactionOptions() {
|
| + var o = new api.TransactionOptions();
|
| + buildCounterTransactionOptions++;
|
| + if (buildCounterTransactionOptions < 3) {
|
| + o.readOnly = buildReadOnly();
|
| + o.readWrite = buildReadWrite();
|
| + }
|
| + buildCounterTransactionOptions--;
|
| + return o;
|
| +}
|
| +
|
| +checkTransactionOptions(api.TransactionOptions o) {
|
| + buildCounterTransactionOptions++;
|
| + if (buildCounterTransactionOptions < 3) {
|
| + checkReadOnly(o.readOnly);
|
| + checkReadWrite(o.readWrite);
|
| + }
|
| + buildCounterTransactionOptions--;
|
| +}
|
| +
|
| +core.int buildCounterTransactionSelector = 0;
|
| +buildTransactionSelector() {
|
| + var o = new api.TransactionSelector();
|
| + buildCounterTransactionSelector++;
|
| + if (buildCounterTransactionSelector < 3) {
|
| + o.begin = buildTransactionOptions();
|
| + o.id = "foo";
|
| + o.singleUse = buildTransactionOptions();
|
| + }
|
| + buildCounterTransactionSelector--;
|
| + return o;
|
| +}
|
| +
|
| +checkTransactionSelector(api.TransactionSelector o) {
|
| + buildCounterTransactionSelector++;
|
| + if (buildCounterTransactionSelector < 3) {
|
| + checkTransactionOptions(o.begin);
|
| + unittest.expect(o.id, unittest.equals('foo'));
|
| + checkTransactionOptions(o.singleUse);
|
| + }
|
| + buildCounterTransactionSelector--;
|
| +}
|
| +
|
| +core.int buildCounterType = 0;
|
| +buildType() {
|
| + var o = new api.Type();
|
| + buildCounterType++;
|
| + if (buildCounterType < 3) {
|
| + o.arrayElementType = buildType();
|
| + o.code = "foo";
|
| + o.structType = buildStructType();
|
| + }
|
| + buildCounterType--;
|
| + return o;
|
| +}
|
| +
|
| +checkType(api.Type o) {
|
| + buildCounterType++;
|
| + if (buildCounterType < 3) {
|
| + checkType(o.arrayElementType);
|
| + unittest.expect(o.code, unittest.equals('foo'));
|
| + checkStructType(o.structType);
|
| + }
|
| + buildCounterType--;
|
| +}
|
| +
|
| +buildUnnamed1816() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1816(core.List<core.String> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + unittest.expect(o[0], unittest.equals('foo'));
|
| + unittest.expect(o[1], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1817() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1817(core.List<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 buildCounterUpdateDatabaseDdlMetadata = 0;
|
| +buildUpdateDatabaseDdlMetadata() {
|
| + var o = new api.UpdateDatabaseDdlMetadata();
|
| + buildCounterUpdateDatabaseDdlMetadata++;
|
| + if (buildCounterUpdateDatabaseDdlMetadata < 3) {
|
| + o.commitTimestamps = buildUnnamed1816();
|
| + o.database = "foo";
|
| + o.statements = buildUnnamed1817();
|
| + }
|
| + buildCounterUpdateDatabaseDdlMetadata--;
|
| + return o;
|
| +}
|
| +
|
| +checkUpdateDatabaseDdlMetadata(api.UpdateDatabaseDdlMetadata o) {
|
| + buildCounterUpdateDatabaseDdlMetadata++;
|
| + if (buildCounterUpdateDatabaseDdlMetadata < 3) {
|
| + checkUnnamed1816(o.commitTimestamps);
|
| + unittest.expect(o.database, unittest.equals('foo'));
|
| + checkUnnamed1817(o.statements);
|
| + }
|
| + buildCounterUpdateDatabaseDdlMetadata--;
|
| +}
|
| +
|
| +buildUnnamed1818() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1818(core.List<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 buildCounterUpdateDatabaseDdlRequest = 0;
|
| +buildUpdateDatabaseDdlRequest() {
|
| + var o = new api.UpdateDatabaseDdlRequest();
|
| + buildCounterUpdateDatabaseDdlRequest++;
|
| + if (buildCounterUpdateDatabaseDdlRequest < 3) {
|
| + o.operationId = "foo";
|
| + o.statements = buildUnnamed1818();
|
| + }
|
| + buildCounterUpdateDatabaseDdlRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkUpdateDatabaseDdlRequest(api.UpdateDatabaseDdlRequest o) {
|
| + buildCounterUpdateDatabaseDdlRequest++;
|
| + if (buildCounterUpdateDatabaseDdlRequest < 3) {
|
| + unittest.expect(o.operationId, unittest.equals('foo'));
|
| + checkUnnamed1818(o.statements);
|
| + }
|
| + buildCounterUpdateDatabaseDdlRequest--;
|
| +}
|
| +
|
| +core.int buildCounterUpdateInstanceMetadata = 0;
|
| +buildUpdateInstanceMetadata() {
|
| + var o = new api.UpdateInstanceMetadata();
|
| + buildCounterUpdateInstanceMetadata++;
|
| + if (buildCounterUpdateInstanceMetadata < 3) {
|
| + o.cancelTime = "foo";
|
| + o.endTime = "foo";
|
| + o.instance = buildInstance();
|
| + o.startTime = "foo";
|
| + }
|
| + buildCounterUpdateInstanceMetadata--;
|
| + return o;
|
| +}
|
| +
|
| +checkUpdateInstanceMetadata(api.UpdateInstanceMetadata o) {
|
| + buildCounterUpdateInstanceMetadata++;
|
| + if (buildCounterUpdateInstanceMetadata < 3) {
|
| + unittest.expect(o.cancelTime, unittest.equals('foo'));
|
| + unittest.expect(o.endTime, unittest.equals('foo'));
|
| + checkInstance(o.instance);
|
| + unittest.expect(o.startTime, unittest.equals('foo'));
|
| + }
|
| + buildCounterUpdateInstanceMetadata--;
|
| +}
|
| +
|
| +core.int buildCounterUpdateInstanceRequest = 0;
|
| +buildUpdateInstanceRequest() {
|
| + var o = new api.UpdateInstanceRequest();
|
| + buildCounterUpdateInstanceRequest++;
|
| + if (buildCounterUpdateInstanceRequest < 3) {
|
| + o.fieldMask = "foo";
|
| + o.instance = buildInstance();
|
| + }
|
| + buildCounterUpdateInstanceRequest--;
|
| + return o;
|
| +}
|
| +
|
| +checkUpdateInstanceRequest(api.UpdateInstanceRequest o) {
|
| + buildCounterUpdateInstanceRequest++;
|
| + if (buildCounterUpdateInstanceRequest < 3) {
|
| + unittest.expect(o.fieldMask, unittest.equals('foo'));
|
| + checkInstance(o.instance);
|
| + }
|
| + buildCounterUpdateInstanceRequest--;
|
| +}
|
| +
|
| +buildUnnamed1819() {
|
| + var o = new core.List<core.String>();
|
| + o.add("foo");
|
| + o.add("foo");
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1819(core.List<core.String> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + unittest.expect(o[0], unittest.equals('foo'));
|
| + unittest.expect(o[1], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1820() {
|
| + var o = new core.List<core.Object>();
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + o.add({'list' : [1, 2, 3], 'bool' : true, 'string' : 'foo'});
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1820(core.List<core.Object> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + var casted29 = (o[0]) as core.Map; unittest.expect(casted29, unittest.hasLength(3)); unittest.expect(casted29["list"], unittest.equals([1, 2, 3])); unittest.expect(casted29["bool"], unittest.equals(true)); unittest.expect(casted29["string"], unittest.equals('foo'));
|
| + var casted30 = (o[1]) as core.Map; unittest.expect(casted30, unittest.hasLength(3)); unittest.expect(casted30["list"], unittest.equals([1, 2, 3])); unittest.expect(casted30["bool"], unittest.equals(true)); unittest.expect(casted30["string"], unittest.equals('foo'));
|
| +}
|
| +
|
| +buildUnnamed1821() {
|
| + var o = new core.List<core.List<core.Object>>();
|
| + o.add(buildUnnamed1820());
|
| + o.add(buildUnnamed1820());
|
| + return o;
|
| +}
|
| +
|
| +checkUnnamed1821(core.List<core.List<core.Object>> o) {
|
| + unittest.expect(o, unittest.hasLength(2));
|
| + checkUnnamed1820(o[0]);
|
| + checkUnnamed1820(o[1]);
|
| +}
|
| +
|
| +core.int buildCounterWrite = 0;
|
| +buildWrite() {
|
| + var o = new api.Write();
|
| + buildCounterWrite++;
|
| + if (buildCounterWrite < 3) {
|
| + o.columns = buildUnnamed1819();
|
| + o.table = "foo";
|
| + o.values = buildUnnamed1821();
|
| + }
|
| + buildCounterWrite--;
|
| + return o;
|
| +}
|
| +
|
| +checkWrite(api.Write o) {
|
| + buildCounterWrite++;
|
| + if (buildCounterWrite < 3) {
|
| + checkUnnamed1819(o.columns);
|
| + unittest.expect(o.table, unittest.equals('foo'));
|
| + checkUnnamed1821(o.values);
|
| + }
|
| + buildCounterWrite--;
|
| +}
|
| +
|
| +
|
| +main() {
|
| + unittest.group("obj-schema-AuditConfig", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildAuditConfig();
|
| + var od = new api.AuditConfig.fromJson(o.toJson());
|
| + checkAuditConfig(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-AuditLogConfig", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildAuditLogConfig();
|
| + var od = new api.AuditLogConfig.fromJson(o.toJson());
|
| + checkAuditLogConfig(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-BeginTransactionRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildBeginTransactionRequest();
|
| + var od = new api.BeginTransactionRequest.fromJson(o.toJson());
|
| + checkBeginTransactionRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Binding", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildBinding();
|
| + var od = new api.Binding.fromJson(o.toJson());
|
| + checkBinding(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ChildLink", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildChildLink();
|
| + var od = new api.ChildLink.fromJson(o.toJson());
|
| + checkChildLink(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CloudAuditOptions", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCloudAuditOptions();
|
| + var od = new api.CloudAuditOptions.fromJson(o.toJson());
|
| + checkCloudAuditOptions(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CommitRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCommitRequest();
|
| + var od = new api.CommitRequest.fromJson(o.toJson());
|
| + checkCommitRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CommitResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCommitResponse();
|
| + var od = new api.CommitResponse.fromJson(o.toJson());
|
| + checkCommitResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Condition", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCondition();
|
| + var od = new api.Condition.fromJson(o.toJson());
|
| + checkCondition(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CounterOptions", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCounterOptions();
|
| + var od = new api.CounterOptions.fromJson(o.toJson());
|
| + checkCounterOptions(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CreateDatabaseMetadata", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCreateDatabaseMetadata();
|
| + var od = new api.CreateDatabaseMetadata.fromJson(o.toJson());
|
| + checkCreateDatabaseMetadata(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CreateDatabaseRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCreateDatabaseRequest();
|
| + var od = new api.CreateDatabaseRequest.fromJson(o.toJson());
|
| + checkCreateDatabaseRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CreateInstanceMetadata", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCreateInstanceMetadata();
|
| + var od = new api.CreateInstanceMetadata.fromJson(o.toJson());
|
| + checkCreateInstanceMetadata(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-CreateInstanceRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildCreateInstanceRequest();
|
| + var od = new api.CreateInstanceRequest.fromJson(o.toJson());
|
| + checkCreateInstanceRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-DataAccessOptions", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildDataAccessOptions();
|
| + var od = new api.DataAccessOptions.fromJson(o.toJson());
|
| + checkDataAccessOptions(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Database", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildDatabase();
|
| + var od = new api.Database.fromJson(o.toJson());
|
| + checkDatabase(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Delete", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildDelete();
|
| + var od = new api.Delete.fromJson(o.toJson());
|
| + checkDelete(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Empty", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildEmpty();
|
| + var od = new api.Empty.fromJson(o.toJson());
|
| + checkEmpty(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ExecuteSqlRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildExecuteSqlRequest();
|
| + var od = new api.ExecuteSqlRequest.fromJson(o.toJson());
|
| + checkExecuteSqlRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Field", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildField();
|
| + var od = new api.Field.fromJson(o.toJson());
|
| + checkField(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-GetDatabaseDdlResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildGetDatabaseDdlResponse();
|
| + var od = new api.GetDatabaseDdlResponse.fromJson(o.toJson());
|
| + checkGetDatabaseDdlResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-GetIamPolicyRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildGetIamPolicyRequest();
|
| + var od = new api.GetIamPolicyRequest.fromJson(o.toJson());
|
| + checkGetIamPolicyRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Instance", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildInstance();
|
| + var od = new api.Instance.fromJson(o.toJson());
|
| + checkInstance(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-InstanceConfig", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildInstanceConfig();
|
| + var od = new api.InstanceConfig.fromJson(o.toJson());
|
| + checkInstanceConfig(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-KeyRange", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildKeyRange();
|
| + var od = new api.KeyRange.fromJson(o.toJson());
|
| + checkKeyRange(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-KeySet", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildKeySet();
|
| + var od = new api.KeySet.fromJson(o.toJson());
|
| + checkKeySet(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ListDatabasesResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildListDatabasesResponse();
|
| + var od = new api.ListDatabasesResponse.fromJson(o.toJson());
|
| + checkListDatabasesResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ListInstanceConfigsResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildListInstanceConfigsResponse();
|
| + var od = new api.ListInstanceConfigsResponse.fromJson(o.toJson());
|
| + checkListInstanceConfigsResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ListInstancesResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildListInstancesResponse();
|
| + var od = new api.ListInstancesResponse.fromJson(o.toJson());
|
| + checkListInstancesResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ListOperationsResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildListOperationsResponse();
|
| + var od = new api.ListOperationsResponse.fromJson(o.toJson());
|
| + checkListOperationsResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-LogConfig", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildLogConfig();
|
| + var od = new api.LogConfig.fromJson(o.toJson());
|
| + checkLogConfig(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Mutation", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildMutation();
|
| + var od = new api.Mutation.fromJson(o.toJson());
|
| + checkMutation(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Operation", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildOperation();
|
| + var od = new api.Operation.fromJson(o.toJson());
|
| + checkOperation(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-PartialResultSet", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildPartialResultSet();
|
| + var od = new api.PartialResultSet.fromJson(o.toJson());
|
| + checkPartialResultSet(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-PlanNode", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildPlanNode();
|
| + var od = new api.PlanNode.fromJson(o.toJson());
|
| + checkPlanNode(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Policy", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildPolicy();
|
| + var od = new api.Policy.fromJson(o.toJson());
|
| + checkPolicy(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-QueryPlan", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildQueryPlan();
|
| + var od = new api.QueryPlan.fromJson(o.toJson());
|
| + checkQueryPlan(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ReadOnly", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildReadOnly();
|
| + var od = new api.ReadOnly.fromJson(o.toJson());
|
| + checkReadOnly(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ReadRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildReadRequest();
|
| + var od = new api.ReadRequest.fromJson(o.toJson());
|
| + checkReadRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ReadWrite", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildReadWrite();
|
| + var od = new api.ReadWrite.fromJson(o.toJson());
|
| + checkReadWrite(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ResultSet", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildResultSet();
|
| + var od = new api.ResultSet.fromJson(o.toJson());
|
| + checkResultSet(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ResultSetMetadata", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildResultSetMetadata();
|
| + var od = new api.ResultSetMetadata.fromJson(o.toJson());
|
| + checkResultSetMetadata(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ResultSetStats", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildResultSetStats();
|
| + var od = new api.ResultSetStats.fromJson(o.toJson());
|
| + checkResultSetStats(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-RollbackRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildRollbackRequest();
|
| + var od = new api.RollbackRequest.fromJson(o.toJson());
|
| + checkRollbackRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Rule", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildRule();
|
| + var od = new api.Rule.fromJson(o.toJson());
|
| + checkRule(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Session", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildSession();
|
| + var od = new api.Session.fromJson(o.toJson());
|
| + checkSession(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-SetIamPolicyRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildSetIamPolicyRequest();
|
| + var od = new api.SetIamPolicyRequest.fromJson(o.toJson());
|
| + checkSetIamPolicyRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-ShortRepresentation", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildShortRepresentation();
|
| + var od = new api.ShortRepresentation.fromJson(o.toJson());
|
| + checkShortRepresentation(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Status", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildStatus();
|
| + var od = new api.Status.fromJson(o.toJson());
|
| + checkStatus(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-StructType", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildStructType();
|
| + var od = new api.StructType.fromJson(o.toJson());
|
| + checkStructType(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-TestIamPermissionsRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildTestIamPermissionsRequest();
|
| + var od = new api.TestIamPermissionsRequest.fromJson(o.toJson());
|
| + checkTestIamPermissionsRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-TestIamPermissionsResponse", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildTestIamPermissionsResponse();
|
| + var od = new api.TestIamPermissionsResponse.fromJson(o.toJson());
|
| + checkTestIamPermissionsResponse(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Transaction", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildTransaction();
|
| + var od = new api.Transaction.fromJson(o.toJson());
|
| + checkTransaction(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-TransactionOptions", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildTransactionOptions();
|
| + var od = new api.TransactionOptions.fromJson(o.toJson());
|
| + checkTransactionOptions(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-TransactionSelector", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildTransactionSelector();
|
| + var od = new api.TransactionSelector.fromJson(o.toJson());
|
| + checkTransactionSelector(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Type", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildType();
|
| + var od = new api.Type.fromJson(o.toJson());
|
| + checkType(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-UpdateDatabaseDdlMetadata", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildUpdateDatabaseDdlMetadata();
|
| + var od = new api.UpdateDatabaseDdlMetadata.fromJson(o.toJson());
|
| + checkUpdateDatabaseDdlMetadata(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-UpdateDatabaseDdlRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildUpdateDatabaseDdlRequest();
|
| + var od = new api.UpdateDatabaseDdlRequest.fromJson(o.toJson());
|
| + checkUpdateDatabaseDdlRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-UpdateInstanceMetadata", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildUpdateInstanceMetadata();
|
| + var od = new api.UpdateInstanceMetadata.fromJson(o.toJson());
|
| + checkUpdateInstanceMetadata(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-UpdateInstanceRequest", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildUpdateInstanceRequest();
|
| + var od = new api.UpdateInstanceRequest.fromJson(o.toJson());
|
| + checkUpdateInstanceRequest(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("obj-schema-Write", () {
|
| + unittest.test("to-json--from-json", () {
|
| + var o = buildWrite();
|
| + var od = new api.Write.fromJson(o.toJson());
|
| + checkWrite(od);
|
| + });
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstanceConfigsResourceApi", () {
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstanceConfigsResourceApi res = new api.SpannerApi(mock).projects.instanceConfigs;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildInstanceConfig());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.InstanceConfig response) {
|
| + checkInstanceConfig(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--list", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstanceConfigsResourceApi res = new api.SpannerApi(mock).projects.instanceConfigs;
|
| + var arg_parent = "foo";
|
| + var arg_pageToken = "foo";
|
| + var arg_pageSize = 42;
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| + unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
|
| + unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildListInstanceConfigsResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.list(arg_parent, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListInstanceConfigsResponse response) {
|
| + checkListInstanceConfigsResponse(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstancesResourceApi", () {
|
| + unittest.test("method--create", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_request = buildCreateInstanceRequest();
|
| + var arg_parent = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.CreateInstanceRequest.fromJson(json);
|
| + checkCreateInstanceRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.create(arg_request, arg_parent).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--delete", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildInstance());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.Instance response) {
|
| + checkInstance(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--getIamPolicy", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_request = buildGetIamPolicyRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.GetIamPolicyRequest.fromJson(json);
|
| + checkGetIamPolicyRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPolicy());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
|
| + checkPolicy(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--list", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_parent = "foo";
|
| + var arg_pageToken = "foo";
|
| + var arg_pageSize = 42;
|
| + var arg_filter = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| + unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
|
| + unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
|
| + unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildListInstancesResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.list(arg_parent, pageToken: arg_pageToken, pageSize: arg_pageSize, filter: arg_filter).then(unittest.expectAsync(((api.ListInstancesResponse response) {
|
| + checkListInstancesResponse(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--patch", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_request = buildUpdateInstanceRequest();
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.UpdateInstanceRequest.fromJson(json);
|
| + checkUpdateInstanceRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.patch(arg_request, arg_name).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--setIamPolicy", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_request = buildSetIamPolicyRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.SetIamPolicyRequest.fromJson(json);
|
| + checkSetIamPolicyRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPolicy());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
|
| + checkPolicy(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--testIamPermissions", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesResourceApi res = new api.SpannerApi(mock).projects.instances;
|
| + var arg_request = buildTestIamPermissionsRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.TestIamPermissionsRequest.fromJson(json);
|
| + checkTestIamPermissionsRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildTestIamPermissionsResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync(((api.TestIamPermissionsResponse response) {
|
| + checkTestIamPermissionsResponse(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstancesDatabasesResourceApi", () {
|
| + unittest.test("method--create", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_request = buildCreateDatabaseRequest();
|
| + var arg_parent = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.CreateDatabaseRequest.fromJson(json);
|
| + checkCreateDatabaseRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.create(arg_request, arg_parent).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--dropDatabase", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_database = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.dropDatabase(arg_database).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildDatabase());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.Database response) {
|
| + checkDatabase(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--getDdl", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_database = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildGetDatabaseDdlResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.getDdl(arg_database).then(unittest.expectAsync(((api.GetDatabaseDdlResponse response) {
|
| + checkGetDatabaseDdlResponse(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--getIamPolicy", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_request = buildGetIamPolicyRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.GetIamPolicyRequest.fromJson(json);
|
| + checkGetIamPolicyRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPolicy());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.getIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
|
| + checkPolicy(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--list", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_parent = "foo";
|
| + var arg_pageToken = "foo";
|
| + var arg_pageSize = 42;
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| + unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
|
| + unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildListDatabasesResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.list(arg_parent, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListDatabasesResponse response) {
|
| + checkListDatabasesResponse(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--setIamPolicy", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_request = buildSetIamPolicyRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.SetIamPolicyRequest.fromJson(json);
|
| + checkSetIamPolicyRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPolicy());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.setIamPolicy(arg_request, arg_resource).then(unittest.expectAsync(((api.Policy response) {
|
| + checkPolicy(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--testIamPermissions", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_request = buildTestIamPermissionsRequest();
|
| + var arg_resource = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.TestIamPermissionsRequest.fromJson(json);
|
| + checkTestIamPermissionsRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildTestIamPermissionsResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.testIamPermissions(arg_request, arg_resource).then(unittest.expectAsync(((api.TestIamPermissionsResponse response) {
|
| + checkTestIamPermissionsResponse(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--updateDdl", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesResourceApi res = new api.SpannerApi(mock).projects.instances.databases;
|
| + var arg_request = buildUpdateDatabaseDdlRequest();
|
| + var arg_database = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.UpdateDatabaseDdlRequest.fromJson(json);
|
| + checkUpdateDatabaseDdlRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.updateDdl(arg_request, arg_database).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstancesDatabasesOperationsResourceApi", () {
|
| + unittest.test("method--cancel", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.cancel(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--delete", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--list", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.operations;
|
| + var arg_name = "foo";
|
| + var arg_filter = "foo";
|
| + var arg_pageToken = "foo";
|
| + var arg_pageSize = 42;
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| + unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
|
| + unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
|
| + unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildListOperationsResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.list(arg_name, filter: arg_filter, pageToken: arg_pageToken, pageSize: arg_pageSize).then(unittest.expectAsync(((api.ListOperationsResponse response) {
|
| + checkListOperationsResponse(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstancesDatabasesSessionsResourceApi", () {
|
| + unittest.test("method--beginTransaction", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildBeginTransactionRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.BeginTransactionRequest.fromJson(json);
|
| + checkBeginTransactionRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildTransaction());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.beginTransaction(arg_request, arg_session).then(unittest.expectAsync(((api.Transaction response) {
|
| + checkTransaction(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--commit", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildCommitRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.CommitRequest.fromJson(json);
|
| + checkCommitRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildCommitResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.commit(arg_request, arg_session).then(unittest.expectAsync(((api.CommitResponse response) {
|
| + checkCommitResponse(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--create", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_database = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildSession());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.create(arg_database).then(unittest.expectAsync(((api.Session response) {
|
| + checkSession(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--delete", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--executeSql", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildExecuteSqlRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.ExecuteSqlRequest.fromJson(json);
|
| + checkExecuteSqlRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildResultSet());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.executeSql(arg_request, arg_session).then(unittest.expectAsync(((api.ResultSet response) {
|
| + checkResultSet(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--executeStreamingSql", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildExecuteSqlRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.ExecuteSqlRequest.fromJson(json);
|
| + checkExecuteSqlRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPartialResultSet());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.executeStreamingSql(arg_request, arg_session).then(unittest.expectAsync(((api.PartialResultSet response) {
|
| + checkPartialResultSet(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildSession());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.Session response) {
|
| + checkSession(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--read", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildReadRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.ReadRequest.fromJson(json);
|
| + checkReadRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildResultSet());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.read(arg_request, arg_session).then(unittest.expectAsync(((api.ResultSet response) {
|
| + checkResultSet(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--rollback", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildRollbackRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.RollbackRequest.fromJson(json);
|
| + checkRollbackRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.rollback(arg_request, arg_session).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--streamingRead", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesDatabasesSessionsResourceApi res = new api.SpannerApi(mock).projects.instances.databases.sessions;
|
| + var arg_request = buildReadRequest();
|
| + var arg_session = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var obj = new api.ReadRequest.fromJson(json);
|
| + checkReadRequest(obj);
|
| +
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 1), unittest.equals("/"));
|
| + pathOffset += 1;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 3), unittest.equals("v1/"));
|
| + pathOffset += 3;
|
| + // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildPartialResultSet());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.streamingRead(arg_request, arg_session).then(unittest.expectAsync(((api.PartialResultSet response) {
|
| + checkPartialResultSet(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| + unittest.group("resource-ProjectsInstancesOperationsResourceApi", () {
|
| + unittest.test("method--cancel", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.cancel(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--delete", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildEmpty());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.delete(arg_name).then(unittest.expectAsync(((api.Empty response) {
|
| + checkEmpty(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--get", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.operations;
|
| + var arg_name = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildOperation());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.get(arg_name).then(unittest.expectAsync(((api.Operation response) {
|
| + checkOperation(response);
|
| + })));
|
| + });
|
| +
|
| + unittest.test("method--list", () {
|
| +
|
| + var mock = new HttpServerMock();
|
| + api.ProjectsInstancesOperationsResourceApi res = new api.SpannerApi(mock).projects.instances.operations;
|
| + var arg_name = "foo";
|
| + var arg_pageToken = "foo";
|
| + var arg_pageSize = 42;
|
| + var arg_filter = "foo";
|
| + mock.register(unittest.expectAsync((http.BaseRequest req, json) {
|
| + var path = (req.url).path;
|
| + var pathOffset = 0;
|
| + var index;
|
| + var subPart;
|
| + unittest.expect(path.substring(pathOffset, pathOffset + 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;
|
| +
|
| + var query = (req.url).query;
|
| + var queryOffset = 0;
|
| + var queryMap = {};
|
| + addQueryParam(n, v) => queryMap.putIfAbsent(n, () => []).add(v);
|
| + parseBool(n) {
|
| + if (n == "true") return true;
|
| + if (n == "false") return false;
|
| + if (n == null) return null;
|
| + throw new core.ArgumentError("Invalid boolean: $n");
|
| + }
|
| + if (query.length > 0) {
|
| + for (var part in query.split("&")) {
|
| + var keyvalue = part.split("=");
|
| + addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
|
| + }
|
| + }
|
| + unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
|
| + unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
|
| + unittest.expect(queryMap["filter"].first, unittest.equals(arg_filter));
|
| +
|
| +
|
| + var h = {
|
| + "content-type" : "application/json; charset=utf-8",
|
| + };
|
| + var resp = convert.JSON.encode(buildListOperationsResponse());
|
| + return new async.Future.value(stringResponse(200, h, resp));
|
| + }), true);
|
| + res.list(arg_name, pageToken: arg_pageToken, pageSize: arg_pageSize, filter: arg_filter).then(unittest.expectAsync(((api.ListOperationsResponse response) {
|
| + checkListOperationsResponse(response);
|
| + })));
|
| + });
|
| +
|
| + });
|
| +
|
| +
|
| +}
|
| +
|
|
|
Chromium Code Reviews
Issue 2734843002:
Api-roll 46: 2017-03-06 (Closed)
