Roll of googleapis as of 4/7/2015.

generated/googleapis_beta/test/dataflow/v1beta3_test.dart

 library googleapis_beta.dataflow.v1beta3.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_beta/common/common.dart' as common;
-import 'package:googleapis_beta/src/common_internal.dart' as common_internal;
-import '../common/common_internal_test.dart' as common_test;
 
 import 'package:googleapis_beta/dataflow/v1beta3.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);
+}
 
 core.int buildCounterApproximateProgress = 0;
 buildApproximateProgress() {
   var o = new api.ApproximateProgress();
   buildCounterApproximateProgress++;
   if (buildCounterApproximateProgress < 3) {
     o.percentComplete = 42.0;
     o.position = buildPosition();
     o.remainingTime = "foo";
   }
@@ skipping 25 matching lines @@
 
 checkAutoscalingSettings(api.AutoscalingSettings o) {
   buildCounterAutoscalingSettings++;
   if (buildCounterAutoscalingSettings < 3) {
     unittest.expect(o.algorithm, unittest.equals('foo'));
     unittest.expect(o.maxNumWorkers, unittest.equals(42));
   }
   buildCounterAutoscalingSettings--;
 }
 
-buildUnnamed1776() {
+buildUnnamed1492() {
   var o = new core.List<api.StreamLocation>();
   o.add(buildStreamLocation());
   o.add(buildStreamLocation());
   return o;
 }
 
-checkUnnamed1776(core.List<api.StreamLocation> o) {
+checkUnnamed1492(core.List<api.StreamLocation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStreamLocation(o[0]);
   checkStreamLocation(o[1]);
 }
 
-buildUnnamed1777() {
+buildUnnamed1493() {
   var o = new core.List<api.KeyRangeLocation>();
   o.add(buildKeyRangeLocation());
   o.add(buildKeyRangeLocation());
   return o;
 }
 
-checkUnnamed1777(core.List<api.KeyRangeLocation> o) {
+checkUnnamed1493(core.List<api.KeyRangeLocation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkKeyRangeLocation(o[0]);
   checkKeyRangeLocation(o[1]);
 }
 
-buildUnnamed1778() {
+buildUnnamed1494() {
   var o = new core.List<api.StreamLocation>();
   o.add(buildStreamLocation());
   o.add(buildStreamLocation());
   return o;
 }
 
-checkUnnamed1778(core.List<api.StreamLocation> o) {
+checkUnnamed1494(core.List<api.StreamLocation> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStreamLocation(o[0]);
   checkStreamLocation(o[1]);
 }
 
 core.int buildCounterComputationTopology = 0;
 buildComputationTopology() {
   var o = new api.ComputationTopology();
   buildCounterComputationTopology++;
   if (buildCounterComputationTopology < 3) {
     o.computationId = "foo";
-    o.inputs = buildUnnamed1776();
-    o.keyRanges = buildUnnamed1777();
-    o.outputs = buildUnnamed1778();
+    o.inputs = buildUnnamed1492();
+    o.keyRanges = buildUnnamed1493();
+    o.outputs = buildUnnamed1494();
   }
   buildCounterComputationTopology--;
   return o;
 }
 
 checkComputationTopology(api.ComputationTopology o) {
   buildCounterComputationTopology++;
   if (buildCounterComputationTopology < 3) {
     unittest.expect(o.computationId, unittest.equals('foo'));
-    checkUnnamed1776(o.inputs);
-    checkUnnamed1777(o.keyRanges);
-    checkUnnamed1778(o.outputs);
+    checkUnnamed1492(o.inputs);
+    checkUnnamed1493(o.keyRanges);
+    checkUnnamed1494(o.outputs);
   }
   buildCounterComputationTopology--;
 }
 
-buildUnnamed1779() {
+buildUnnamed1495() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1779(core.List<core.String> o) {
+checkUnnamed1495(core.List<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 buildCounterDataDiskAssignment = 0;
 buildDataDiskAssignment() {
   var o = new api.DataDiskAssignment();
   buildCounterDataDiskAssignment++;
   if (buildCounterDataDiskAssignment < 3) {
-    o.dataDisks = buildUnnamed1779();
+    o.dataDisks = buildUnnamed1495();
     o.vmInstance = "foo";
   }
   buildCounterDataDiskAssignment--;
   return o;
 }
 
 checkDataDiskAssignment(api.DataDiskAssignment o) {
   buildCounterDataDiskAssignment++;
   if (buildCounterDataDiskAssignment < 3) {
-    checkUnnamed1779(o.dataDisks);
+    checkUnnamed1495(o.dataDisks);
     unittest.expect(o.vmInstance, unittest.equals('foo'));
   }
   buildCounterDataDiskAssignment--;
 }
 
+core.int buildCounterDerivedSource = 0;
+buildDerivedSource() {
+  var o = new api.DerivedSource();
+  buildCounterDerivedSource++;
+  if (buildCounterDerivedSource < 3) {
+    o.derivationMode = "foo";
+    o.source = buildSource();
+  }
+  buildCounterDerivedSource--;
+  return o;
+}
+
+checkDerivedSource(api.DerivedSource o) {
+  buildCounterDerivedSource++;
+  if (buildCounterDerivedSource < 3) {
+    unittest.expect(o.derivationMode, unittest.equals('foo'));
+    checkSource(o.source);
+  }
+  buildCounterDerivedSource--;
+}
+
 core.int buildCounterDisk = 0;
 buildDisk() {
   var o = new api.Disk();
   buildCounterDisk++;
   if (buildCounterDisk < 3) {
     o.diskType = "foo";
     o.mountPoint = "foo";
     o.sizeGb = 42;
   }
   buildCounterDisk--;
   return o;
 }
 
 checkDisk(api.Disk o) {
   buildCounterDisk++;
   if (buildCounterDisk < 3) {
     unittest.expect(o.diskType, unittest.equals('foo'));
     unittest.expect(o.mountPoint, unittest.equals('foo'));
     unittest.expect(o.sizeGb, unittest.equals(42));
   }
   buildCounterDisk--;
 }
 
-buildUnnamed1780() {
+core.int buildCounterDynamicSourceSplit = 0;
+buildDynamicSourceSplit() {
+  var o = new api.DynamicSourceSplit();
+  buildCounterDynamicSourceSplit++;
+  if (buildCounterDynamicSourceSplit < 3) {
+    o.primary = buildDerivedSource();
+    o.residual = buildDerivedSource();
+  }
+  buildCounterDynamicSourceSplit--;
+  return o;
+}
+
+checkDynamicSourceSplit(api.DynamicSourceSplit o) {
+  buildCounterDynamicSourceSplit++;
+  if (buildCounterDynamicSourceSplit < 3) {
+    checkDerivedSource(o.primary);
+    checkDerivedSource(o.residual);
+  }
+  buildCounterDynamicSourceSplit--;
+}
+
+buildUnnamed1496() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1780(core.List<core.String> o) {
+checkUnnamed1496(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1781() {
+buildUnnamed1497() {
   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;
 }
 
-checkUnnamed1781(core.Map<core.String, core.Object> o) {
+checkUnnamed1497(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')); 
 }
 
-buildUnnamed1782() {
+buildUnnamed1498() {
   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;
 }
 
-checkUnnamed1782(core.Map<core.String, core.Object> o) {
+checkUnnamed1498(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted3 = (o["x"]) as core.Map; unittest.expect(casted3, unittest.hasLength(3)); unittest.expect(casted3["list"], unittest.equals([1, 2, 3])); unittest.expect(casted3["bool"], unittest.equals(true)); unittest.expect(casted3["string"], unittest.equals('foo')); 
   var casted4 = (o["y"]) as core.Map; unittest.expect(casted4, unittest.hasLength(3)); unittest.expect(casted4["list"], unittest.equals([1, 2, 3])); unittest.expect(casted4["bool"], unittest.equals(true)); unittest.expect(casted4["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1783() {
+buildUnnamed1499() {
   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;
 }
 
-checkUnnamed1783(core.Map<core.String, core.Object> o) {
+checkUnnamed1499(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted5 = (o["x"]) as core.Map; unittest.expect(casted5, unittest.hasLength(3)); unittest.expect(casted5["list"], unittest.equals([1, 2, 3])); unittest.expect(casted5["bool"], unittest.equals(true)); unittest.expect(casted5["string"], unittest.equals('foo')); 
   var casted6 = (o["y"]) as core.Map; unittest.expect(casted6, unittest.hasLength(3)); unittest.expect(casted6["list"], unittest.equals([1, 2, 3])); unittest.expect(casted6["bool"], unittest.equals(true)); unittest.expect(casted6["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1784() {
+buildUnnamed1500() {
   var o = new core.List<api.WorkerPool>();
   o.add(buildWorkerPool());
   o.add(buildWorkerPool());
   return o;
 }
 
-checkUnnamed1784(core.List<api.WorkerPool> o) {
+checkUnnamed1500(core.List<api.WorkerPool> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkWorkerPool(o[0]);
   checkWorkerPool(o[1]);
 }
 
 core.int buildCounterEnvironment = 0;
 buildEnvironment() {
   var o = new api.Environment();
   buildCounterEnvironment++;
   if (buildCounterEnvironment < 3) {
     o.clusterManagerApiService = "foo";
     o.dataset = "foo";
-    o.experiments = buildUnnamed1780();
-    o.sdkPipelineOptions = buildUnnamed1781();
+    o.experiments = buildUnnamed1496();
+    o.sdkPipelineOptions = buildUnnamed1497();
     o.tempStoragePrefix = "foo";
-    o.userAgent = buildUnnamed1782();
-    o.version = buildUnnamed1783();
-    o.workerPools = buildUnnamed1784();
+    o.userAgent = buildUnnamed1498();
+    o.version = buildUnnamed1499();
+    o.workerPools = buildUnnamed1500();
   }
   buildCounterEnvironment--;
   return o;
 }
 
 checkEnvironment(api.Environment o) {
   buildCounterEnvironment++;
   if (buildCounterEnvironment < 3) {
     unittest.expect(o.clusterManagerApiService, unittest.equals('foo'));
     unittest.expect(o.dataset, unittest.equals('foo'));
-    checkUnnamed1780(o.experiments);
-    checkUnnamed1781(o.sdkPipelineOptions);
+    checkUnnamed1496(o.experiments);
+    checkUnnamed1497(o.sdkPipelineOptions);
     unittest.expect(o.tempStoragePrefix, unittest.equals('foo'));
-    checkUnnamed1782(o.userAgent);
-    checkUnnamed1783(o.version);
-    checkUnnamed1784(o.workerPools);
+    checkUnnamed1498(o.userAgent);
+    checkUnnamed1499(o.version);
+    checkUnnamed1500(o.workerPools);
   }
   buildCounterEnvironment--;
 }
 
-buildUnnamed1785() {
+buildUnnamed1501() {
   var o = new core.List<api.InstructionInput>();
   o.add(buildInstructionInput());
   o.add(buildInstructionInput());
   return o;
 }
 
-checkUnnamed1785(core.List<api.InstructionInput> o) {
+checkUnnamed1501(core.List<api.InstructionInput> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkInstructionInput(o[0]);
   checkInstructionInput(o[1]);
 }
 
 core.int buildCounterFlattenInstruction = 0;
 buildFlattenInstruction() {
   var o = new api.FlattenInstruction();
   buildCounterFlattenInstruction++;
   if (buildCounterFlattenInstruction < 3) {
-    o.inputs = buildUnnamed1785();
+    o.inputs = buildUnnamed1501();
   }
   buildCounterFlattenInstruction--;
   return o;
 }
 
 checkFlattenInstruction(api.FlattenInstruction o) {
   buildCounterFlattenInstruction++;
   if (buildCounterFlattenInstruction < 3) {
-    checkUnnamed1785(o.inputs);
+    checkUnnamed1501(o.inputs);
   }
   buildCounterFlattenInstruction--;
 }
 
 core.int buildCounterInstructionInput = 0;
 buildInstructionInput() {
   var o = new api.InstructionInput();
   buildCounterInstructionInput++;
   if (buildCounterInstructionInput < 3) {
     o.outputNum = 42;
     o.producerInstructionIndex = 42;
   }
   buildCounterInstructionInput--;
   return o;
 }
 
 checkInstructionInput(api.InstructionInput o) {
   buildCounterInstructionInput++;
   if (buildCounterInstructionInput < 3) {
     unittest.expect(o.outputNum, unittest.equals(42));
     unittest.expect(o.producerInstructionIndex, unittest.equals(42));
   }
   buildCounterInstructionInput--;
 }
 
-buildUnnamed1786() {
+buildUnnamed1502() {
   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;
 }
 
-checkUnnamed1786(core.Map<core.String, core.Object> o) {
+checkUnnamed1502(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted7 = (o["x"]) as core.Map; unittest.expect(casted7, unittest.hasLength(3)); unittest.expect(casted7["list"], unittest.equals([1, 2, 3])); unittest.expect(casted7["bool"], unittest.equals(true)); unittest.expect(casted7["string"], unittest.equals('foo')); 
   var casted8 = (o["y"]) as core.Map; unittest.expect(casted8, unittest.hasLength(3)); unittest.expect(casted8["list"], unittest.equals([1, 2, 3])); unittest.expect(casted8["bool"], unittest.equals(true)); unittest.expect(casted8["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterInstructionOutput = 0;
 buildInstructionOutput() {
   var o = new api.InstructionOutput();
   buildCounterInstructionOutput++;
   if (buildCounterInstructionOutput < 3) {
-    o.codec = buildUnnamed1786();
+    o.codec = buildUnnamed1502();
     o.name = "foo";
   }
   buildCounterInstructionOutput--;
   return o;
 }
 
 checkInstructionOutput(api.InstructionOutput o) {
   buildCounterInstructionOutput++;
   if (buildCounterInstructionOutput < 3) {
-    checkUnnamed1786(o.codec);
+    checkUnnamed1502(o.codec);
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterInstructionOutput--;
 }
 
-buildUnnamed1787() {
+buildUnnamed1503() {
   var o = new core.List<api.Step>();
   o.add(buildStep());
   o.add(buildStep());
   return o;
 }
 
-checkUnnamed1787(core.List<api.Step> o) {
+checkUnnamed1503(core.List<api.Step> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStep(o[0]);
   checkStep(o[1]);
 }
 
 core.int buildCounterJob = 0;
 buildJob() {
   var o = new api.Job();
   buildCounterJob++;
   if (buildCounterJob < 3) {
     o.createTime = "foo";
     o.currentState = "foo";
     o.currentStateTime = "foo";
     o.environment = buildEnvironment();
     o.executionInfo = buildJobExecutionInfo();
     o.id = "foo";
     o.name = "foo";
     o.projectId = "foo";
     o.requestedState = "foo";
-    o.steps = buildUnnamed1787();
+    o.steps = buildUnnamed1503();
     o.type = "foo";
   }
   buildCounterJob--;
   return o;
 }
 
 checkJob(api.Job o) {
   buildCounterJob++;
   if (buildCounterJob < 3) {
     unittest.expect(o.createTime, unittest.equals('foo'));
     unittest.expect(o.currentState, unittest.equals('foo'));
     unittest.expect(o.currentStateTime, unittest.equals('foo'));
     checkEnvironment(o.environment);
     checkJobExecutionInfo(o.executionInfo);
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.projectId, unittest.equals('foo'));
     unittest.expect(o.requestedState, unittest.equals('foo'));
-    checkUnnamed1787(o.steps);
+    checkUnnamed1503(o.steps);
     unittest.expect(o.type, unittest.equals('foo'));
   }
   buildCounterJob--;
 }
 
-buildUnnamed1788() {
+buildUnnamed1504() {
   var o = new core.Map<core.String, api.JobExecutionStageInfo>();
   o["x"] = buildJobExecutionStageInfo();
   o["y"] = buildJobExecutionStageInfo();
   return o;
 }
 
-checkUnnamed1788(core.Map<core.String, api.JobExecutionStageInfo> o) {
+checkUnnamed1504(core.Map<core.String, api.JobExecutionStageInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkJobExecutionStageInfo(o["x"]);
   checkJobExecutionStageInfo(o["y"]);
 }
 
 core.int buildCounterJobExecutionInfo = 0;
 buildJobExecutionInfo() {
   var o = new api.JobExecutionInfo();
   buildCounterJobExecutionInfo++;
   if (buildCounterJobExecutionInfo < 3) {
-    o.stages = buildUnnamed1788();
+    o.stages = buildUnnamed1504();
   }
   buildCounterJobExecutionInfo--;
   return o;
 }
 
 checkJobExecutionInfo(api.JobExecutionInfo o) {
   buildCounterJobExecutionInfo++;
   if (buildCounterJobExecutionInfo < 3) {
-    checkUnnamed1788(o.stages);
+    checkUnnamed1504(o.stages);
   }
   buildCounterJobExecutionInfo--;
 }
 
-buildUnnamed1789() {
+buildUnnamed1505() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1789(core.List<core.String> o) {
+checkUnnamed1505(core.List<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 buildCounterJobExecutionStageInfo = 0;
 buildJobExecutionStageInfo() {
   var o = new api.JobExecutionStageInfo();
   buildCounterJobExecutionStageInfo++;
   if (buildCounterJobExecutionStageInfo < 3) {
-    o.stepName = buildUnnamed1789();
+    o.stepName = buildUnnamed1505();
   }
   buildCounterJobExecutionStageInfo--;
   return o;
 }
 
 checkJobExecutionStageInfo(api.JobExecutionStageInfo o) {
   buildCounterJobExecutionStageInfo++;
   if (buildCounterJobExecutionStageInfo < 3) {
-    checkUnnamed1789(o.stepName);
+    checkUnnamed1505(o.stepName);
   }
   buildCounterJobExecutionStageInfo--;
 }
 
 core.int buildCounterJobMessage = 0;
 buildJobMessage() {
   var o = new api.JobMessage();
   buildCounterJobMessage++;
   if (buildCounterJobMessage < 3) {
     o.id = "foo";
     o.messageImportance = "foo";
     o.messageText = "foo";
     o.time = "foo";
   }
   buildCounterJobMessage--;
   return o;
 }
 
 checkJobMessage(api.JobMessage o) {
   buildCounterJobMessage++;
   if (buildCounterJobMessage < 3) {
     unittest.expect(o.id, unittest.equals('foo'));
     unittest.expect(o.messageImportance, unittest.equals('foo'));
     unittest.expect(o.messageText, unittest.equals('foo'));
     unittest.expect(o.time, unittest.equals('foo'));
   }
   buildCounterJobMessage--;
 }
 
-buildUnnamed1790() {
+buildUnnamed1506() {
   var o = new core.List<api.MetricUpdate>();
   o.add(buildMetricUpdate());
   o.add(buildMetricUpdate());
   return o;
 }
 
-checkUnnamed1790(core.List<api.MetricUpdate> o) {
+checkUnnamed1506(core.List<api.MetricUpdate> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetricUpdate(o[0]);
   checkMetricUpdate(o[1]);
 }
 
 core.int buildCounterJobMetrics = 0;
 buildJobMetrics() {
   var o = new api.JobMetrics();
   buildCounterJobMetrics++;
   if (buildCounterJobMetrics < 3) {
     o.metricTime = "foo";
-    o.metrics = buildUnnamed1790();
+    o.metrics = buildUnnamed1506();
   }
   buildCounterJobMetrics--;
   return o;
 }
 
 checkJobMetrics(api.JobMetrics o) {
   buildCounterJobMetrics++;
   if (buildCounterJobMetrics < 3) {
     unittest.expect(o.metricTime, unittest.equals('foo'));
-    checkUnnamed1790(o.metrics);
+    checkUnnamed1506(o.metrics);
   }
   buildCounterJobMetrics--;
 }
 
+core.int buildCounterKeyRangeDataDiskAssignment = 0;
+buildKeyRangeDataDiskAssignment() {
+  var o = new api.KeyRangeDataDiskAssignment();
+  buildCounterKeyRangeDataDiskAssignment++;
+  if (buildCounterKeyRangeDataDiskAssignment < 3) {
+    o.dataDisk = "foo";
+    o.end = "foo";
+    o.start = "foo";
+  }
+  buildCounterKeyRangeDataDiskAssignment--;
+  return o;
+}
+
+checkKeyRangeDataDiskAssignment(api.KeyRangeDataDiskAssignment o) {
+  buildCounterKeyRangeDataDiskAssignment++;
+  if (buildCounterKeyRangeDataDiskAssignment < 3) {
+    unittest.expect(o.dataDisk, unittest.equals('foo'));
+    unittest.expect(o.end, unittest.equals('foo'));
+    unittest.expect(o.start, unittest.equals('foo'));
+  }
+  buildCounterKeyRangeDataDiskAssignment--;
+}
+
 core.int buildCounterKeyRangeLocation = 0;
 buildKeyRangeLocation() {
   var o = new api.KeyRangeLocation();
   buildCounterKeyRangeLocation++;
   if (buildCounterKeyRangeLocation < 3) {
     o.dataDisk = "foo";
     o.deliveryEndpoint = "foo";
     o.end = "foo";
     o.persistentDirectory = "foo";
     o.start = "foo";
   }
   buildCounterKeyRangeLocation--;
   return o;
 }
 
 checkKeyRangeLocation(api.KeyRangeLocation o) {
   buildCounterKeyRangeLocation++;
   if (buildCounterKeyRangeLocation < 3) {
     unittest.expect(o.dataDisk, unittest.equals('foo'));
     unittest.expect(o.deliveryEndpoint, unittest.equals('foo'));
     unittest.expect(o.end, unittest.equals('foo'));
     unittest.expect(o.persistentDirectory, unittest.equals('foo'));
     unittest.expect(o.start, unittest.equals('foo'));
   }
   buildCounterKeyRangeLocation--;
 }
 
-buildUnnamed1791() {
+buildUnnamed1507() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1791(core.List<core.String> o) {
+checkUnnamed1507(core.List<core.String> o) {
   unittest.expect(o, unittest.hasLength(2));
   unittest.expect(o[0], unittest.equals('foo'));
   unittest.expect(o[1], unittest.equals('foo'));
 }
 
-buildUnnamed1792() {
+buildUnnamed1508() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1792(core.List<core.String> o) {
+checkUnnamed1508(core.List<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 buildCounterLeaseWorkItemRequest = 0;
 buildLeaseWorkItemRequest() {
   var o = new api.LeaseWorkItemRequest();
   buildCounterLeaseWorkItemRequest++;
   if (buildCounterLeaseWorkItemRequest < 3) {
     o.currentWorkerTime = "foo";
     o.requestedLeaseDuration = "foo";
-    o.workItemTypes = buildUnnamed1791();
-    o.workerCapabilities = buildUnnamed1792();
+    o.workItemTypes = buildUnnamed1507();
+    o.workerCapabilities = buildUnnamed1508();
     o.workerId = "foo";
   }
   buildCounterLeaseWorkItemRequest--;
   return o;
 }
 
 checkLeaseWorkItemRequest(api.LeaseWorkItemRequest o) {
   buildCounterLeaseWorkItemRequest++;
   if (buildCounterLeaseWorkItemRequest < 3) {
     unittest.expect(o.currentWorkerTime, unittest.equals('foo'));
     unittest.expect(o.requestedLeaseDuration, unittest.equals('foo'));
-    checkUnnamed1791(o.workItemTypes);
-    checkUnnamed1792(o.workerCapabilities);
+    checkUnnamed1507(o.workItemTypes);
+    checkUnnamed1508(o.workerCapabilities);
     unittest.expect(o.workerId, unittest.equals('foo'));
   }
   buildCounterLeaseWorkItemRequest--;
 }
 
-buildUnnamed1793() {
+buildUnnamed1509() {
   var o = new core.List<api.WorkItem>();
   o.add(buildWorkItem());
   o.add(buildWorkItem());
   return o;
 }
 
-checkUnnamed1793(core.List<api.WorkItem> o) {
+checkUnnamed1509(core.List<api.WorkItem> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkWorkItem(o[0]);
   checkWorkItem(o[1]);
 }
 
 core.int buildCounterLeaseWorkItemResponse = 0;
 buildLeaseWorkItemResponse() {
   var o = new api.LeaseWorkItemResponse();
   buildCounterLeaseWorkItemResponse++;
   if (buildCounterLeaseWorkItemResponse < 3) {
-    o.workItems = buildUnnamed1793();
+    o.workItems = buildUnnamed1509();
   }
   buildCounterLeaseWorkItemResponse--;
   return o;
 }
 
 checkLeaseWorkItemResponse(api.LeaseWorkItemResponse o) {
   buildCounterLeaseWorkItemResponse++;
   if (buildCounterLeaseWorkItemResponse < 3) {
-    checkUnnamed1793(o.workItems);
+    checkUnnamed1509(o.workItems);
   }
   buildCounterLeaseWorkItemResponse--;
 }
 
-buildUnnamed1794() {
+buildUnnamed1510() {
   var o = new core.List<api.JobMessage>();
   o.add(buildJobMessage());
   o.add(buildJobMessage());
   return o;
 }
 
-checkUnnamed1794(core.List<api.JobMessage> o) {
+checkUnnamed1510(core.List<api.JobMessage> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkJobMessage(o[0]);
   checkJobMessage(o[1]);
 }
 
 core.int buildCounterListJobMessagesResponse = 0;
 buildListJobMessagesResponse() {
   var o = new api.ListJobMessagesResponse();
   buildCounterListJobMessagesResponse++;
   if (buildCounterListJobMessagesResponse < 3) {
-    o.jobMessages = buildUnnamed1794();
+    o.jobMessages = buildUnnamed1510();
     o.nextPageToken = "foo";
   }
   buildCounterListJobMessagesResponse--;
   return o;
 }
 
 checkListJobMessagesResponse(api.ListJobMessagesResponse o) {
   buildCounterListJobMessagesResponse++;
   if (buildCounterListJobMessagesResponse < 3) {
-    checkUnnamed1794(o.jobMessages);
+    checkUnnamed1510(o.jobMessages);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListJobMessagesResponse--;
 }
 
-buildUnnamed1795() {
+buildUnnamed1511() {
   var o = new core.List<api.Job>();
   o.add(buildJob());
   o.add(buildJob());
   return o;
 }
 
-checkUnnamed1795(core.List<api.Job> o) {
+checkUnnamed1511(core.List<api.Job> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkJob(o[0]);
   checkJob(o[1]);
 }
 
 core.int buildCounterListJobsResponse = 0;
 buildListJobsResponse() {
   var o = new api.ListJobsResponse();
   buildCounterListJobsResponse++;
   if (buildCounterListJobsResponse < 3) {
-    o.jobs = buildUnnamed1795();
+    o.jobs = buildUnnamed1511();
     o.nextPageToken = "foo";
   }
   buildCounterListJobsResponse--;
   return o;
 }
 
 checkListJobsResponse(api.ListJobsResponse o) {
   buildCounterListJobsResponse++;
   if (buildCounterListJobsResponse < 3) {
-    checkUnnamed1795(o.jobs);
+    checkUnnamed1511(o.jobs);
     unittest.expect(o.nextPageToken, unittest.equals('foo'));
   }
   buildCounterListJobsResponse--;
 }
 
-buildUnnamed1796() {
+buildUnnamed1512() {
   var o = new core.List<api.ParallelInstruction>();
   o.add(buildParallelInstruction());
   o.add(buildParallelInstruction());
   return o;
 }
 
-checkUnnamed1796(core.List<api.ParallelInstruction> o) {
+checkUnnamed1512(core.List<api.ParallelInstruction> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkParallelInstruction(o[0]);
   checkParallelInstruction(o[1]);
 }
 
 core.int buildCounterMapTask = 0;
 buildMapTask() {
   var o = new api.MapTask();
   buildCounterMapTask++;
   if (buildCounterMapTask < 3) {
-    o.instructions = buildUnnamed1796();
+    o.instructions = buildUnnamed1512();
     o.stageName = "foo";
     o.systemName = "foo";
   }
   buildCounterMapTask--;
   return o;
 }
 
 checkMapTask(api.MapTask o) {
   buildCounterMapTask++;
   if (buildCounterMapTask < 3) {
-    checkUnnamed1796(o.instructions);
+    checkUnnamed1512(o.instructions);
     unittest.expect(o.stageName, unittest.equals('foo'));
     unittest.expect(o.systemName, unittest.equals('foo'));
   }
   buildCounterMapTask--;
 }
 
-buildUnnamed1797() {
+buildUnnamed1513() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed1797(core.Map<core.String, core.String> o) {
+checkUnnamed1513(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 buildCounterMetricStructuredName = 0;
 buildMetricStructuredName() {
   var o = new api.MetricStructuredName();
   buildCounterMetricStructuredName++;
   if (buildCounterMetricStructuredName < 3) {
-    o.context = buildUnnamed1797();
+    o.context = buildUnnamed1513();
     o.name = "foo";
     o.origin = "foo";
   }
   buildCounterMetricStructuredName--;
   return o;
 }
 
 checkMetricStructuredName(api.MetricStructuredName o) {
   buildCounterMetricStructuredName++;
   if (buildCounterMetricStructuredName < 3) {
-    checkUnnamed1797(o.context);
+    checkUnnamed1513(o.context);
     unittest.expect(o.name, unittest.equals('foo'));
     unittest.expect(o.origin, unittest.equals('foo'));
   }
   buildCounterMetricStructuredName--;
 }
 
 core.int buildCounterMetricUpdate = 0;
 buildMetricUpdate() {
   var o = new api.MetricUpdate();
   buildCounterMetricUpdate++;
@@ skipping 21 matching lines @@
     var casted10 = (o.meanCount) 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')); 
     var casted11 = (o.meanSum) 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')); 
     checkMetricStructuredName(o.name);
     var casted12 = (o.scalar) 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')); 
     var casted13 = (o.set) 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')); 
     unittest.expect(o.updateTime, unittest.equals('foo'));
   }
   buildCounterMetricUpdate--;
 }
 
+core.int buildCounterMountedDataDisk = 0;
+buildMountedDataDisk() {
+  var o = new api.MountedDataDisk();
+  buildCounterMountedDataDisk++;
+  if (buildCounterMountedDataDisk < 3) {
+    o.dataDisk = "foo";
+  }
+  buildCounterMountedDataDisk--;
+  return o;
+}
+
+checkMountedDataDisk(api.MountedDataDisk o) {
+  buildCounterMountedDataDisk++;
+  if (buildCounterMountedDataDisk < 3) {
+    unittest.expect(o.dataDisk, unittest.equals('foo'));
+  }
+  buildCounterMountedDataDisk--;
+}
+
 core.int buildCounterMultiOutputInfo = 0;
 buildMultiOutputInfo() {
   var o = new api.MultiOutputInfo();
   buildCounterMultiOutputInfo++;
   if (buildCounterMultiOutputInfo < 3) {
     o.tag = "foo";
   }
   buildCounterMultiOutputInfo--;
   return o;
 }
@@ skipping 20 matching lines @@
 
 checkPackage(api.Package o) {
   buildCounterPackage++;
   if (buildCounterPackage < 3) {
     unittest.expect(o.location, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
   }
   buildCounterPackage--;
 }
 
-buildUnnamed1798() {
+buildUnnamed1514() {
   var o = new core.List<api.MultiOutputInfo>();
   o.add(buildMultiOutputInfo());
   o.add(buildMultiOutputInfo());
   return o;
 }
 
-checkUnnamed1798(core.List<api.MultiOutputInfo> o) {
+checkUnnamed1514(core.List<api.MultiOutputInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMultiOutputInfo(o[0]);
   checkMultiOutputInfo(o[1]);
 }
 
-buildUnnamed1799() {
+buildUnnamed1515() {
   var o = new core.List<api.SideInputInfo>();
   o.add(buildSideInputInfo());
   o.add(buildSideInputInfo());
   return o;
 }
 
-checkUnnamed1799(core.List<api.SideInputInfo> o) {
+checkUnnamed1515(core.List<api.SideInputInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSideInputInfo(o[0]);
   checkSideInputInfo(o[1]);
 }
 
-buildUnnamed1800() {
+buildUnnamed1516() {
   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;
 }
 
-checkUnnamed1800(core.Map<core.String, core.Object> o) {
+checkUnnamed1516(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted14 = (o["x"]) 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')); 
   var casted15 = (o["y"]) 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')); 
 }
 
 core.int buildCounterParDoInstruction = 0;
 buildParDoInstruction() {
   var o = new api.ParDoInstruction();
   buildCounterParDoInstruction++;
   if (buildCounterParDoInstruction < 3) {
     o.input = buildInstructionInput();
-    o.multiOutputInfos = buildUnnamed1798();
+    o.multiOutputInfos = buildUnnamed1514();
     o.numOutputs = 42;
-    o.sideInputs = buildUnnamed1799();
-    o.userFn = buildUnnamed1800();
+    o.sideInputs = buildUnnamed1515();
+    o.userFn = buildUnnamed1516();
   }
   buildCounterParDoInstruction--;
   return o;
 }
 
 checkParDoInstruction(api.ParDoInstruction o) {
   buildCounterParDoInstruction++;
   if (buildCounterParDoInstruction < 3) {
     checkInstructionInput(o.input);
-    checkUnnamed1798(o.multiOutputInfos);
+    checkUnnamed1514(o.multiOutputInfos);
     unittest.expect(o.numOutputs, unittest.equals(42));
-    checkUnnamed1799(o.sideInputs);
-    checkUnnamed1800(o.userFn);
+    checkUnnamed1515(o.sideInputs);
+    checkUnnamed1516(o.userFn);
   }
   buildCounterParDoInstruction--;
 }
 
-buildUnnamed1801() {
+buildUnnamed1517() {
   var o = new core.List<api.InstructionOutput>();
   o.add(buildInstructionOutput());
   o.add(buildInstructionOutput());
   return o;
 }
 
-checkUnnamed1801(core.List<api.InstructionOutput> o) {
+checkUnnamed1517(core.List<api.InstructionOutput> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkInstructionOutput(o[0]);
   checkInstructionOutput(o[1]);
 }
 
 core.int buildCounterParallelInstruction = 0;
 buildParallelInstruction() {
   var o = new api.ParallelInstruction();
   buildCounterParallelInstruction++;
   if (buildCounterParallelInstruction < 3) {
     o.flatten = buildFlattenInstruction();
     o.name = "foo";
-    o.outputs = buildUnnamed1801();
+    o.outputs = buildUnnamed1517();
     o.parDo = buildParDoInstruction();
     o.partialGroupByKey = buildPartialGroupByKeyInstruction();
     o.read = buildReadInstruction();
     o.systemName = "foo";
     o.write = buildWriteInstruction();
   }
   buildCounterParallelInstruction--;
   return o;
 }
 
 checkParallelInstruction(api.ParallelInstruction o) {
   buildCounterParallelInstruction++;
   if (buildCounterParallelInstruction < 3) {
     checkFlattenInstruction(o.flatten);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1801(o.outputs);
+    checkUnnamed1517(o.outputs);
     checkParDoInstruction(o.parDo);
     checkPartialGroupByKeyInstruction(o.partialGroupByKey);
     checkReadInstruction(o.read);
     unittest.expect(o.systemName, unittest.equals('foo'));
     checkWriteInstruction(o.write);
   }
   buildCounterParallelInstruction--;
 }
 
-buildUnnamed1802() {
+buildUnnamed1518() {
   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;
 }
 
-checkUnnamed1802(core.Map<core.String, core.Object> o) {
+checkUnnamed1518(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
   var casted16 = (o["x"]) 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')); 
   var casted17 = (o["y"]) 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')); 
 }
 
+buildUnnamed1519() {
+  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;
+}
+
+checkUnnamed1519(core.Map<core.String, core.Object> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  var casted18 = (o["x"]) 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')); 
+  var casted19 = (o["y"]) 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')); 
+}
+
 core.int buildCounterPartialGroupByKeyInstruction = 0;
 buildPartialGroupByKeyInstruction() {
   var o = new api.PartialGroupByKeyInstruction();
   buildCounterPartialGroupByKeyInstruction++;
   if (buildCounterPartialGroupByKeyInstruction < 3) {
     o.input = buildInstructionInput();
-    o.inputElementCodec = buildUnnamed1802();
+    o.inputElementCodec = buildUnnamed1518();
+    o.valueCombiningFn = buildUnnamed1519();
   }
   buildCounterPartialGroupByKeyInstruction--;
   return o;
 }
 
 checkPartialGroupByKeyInstruction(api.PartialGroupByKeyInstruction o) {
   buildCounterPartialGroupByKeyInstruction++;
   if (buildCounterPartialGroupByKeyInstruction < 3) {
     checkInstructionInput(o.input);
-    checkUnnamed1802(o.inputElementCodec);
+    checkUnnamed1518(o.inputElementCodec);
+    checkUnnamed1519(o.valueCombiningFn);
   }
   buildCounterPartialGroupByKeyInstruction--;
 }
 
 core.int buildCounterPosition = 0;
 buildPosition() {
   var o = new api.Position();
   buildCounterPosition++;
   if (buildCounterPosition < 3) {
     o.byteOffset = "foo";
@@ skipping 21 matching lines @@
 core.int buildCounterPubsubLocation = 0;
 buildPubsubLocation() {
   var o = new api.PubsubLocation();
   buildCounterPubsubLocation++;
   if (buildCounterPubsubLocation < 3) {
     o.dropLateData = true;
     o.idLabel = "foo";
     o.subscription = "foo";
     o.timestampLabel = "foo";
     o.topic = "foo";
+    o.trackingSubscription = "foo";
   }
   buildCounterPubsubLocation--;
   return o;
 }
 
 checkPubsubLocation(api.PubsubLocation o) {
   buildCounterPubsubLocation++;
   if (buildCounterPubsubLocation < 3) {
     unittest.expect(o.dropLateData, unittest.isTrue);
     unittest.expect(o.idLabel, unittest.equals('foo'));
     unittest.expect(o.subscription, unittest.equals('foo'));
     unittest.expect(o.timestampLabel, unittest.equals('foo'));
     unittest.expect(o.topic, unittest.equals('foo'));
+    unittest.expect(o.trackingSubscription, unittest.equals('foo'));
   }
   buildCounterPubsubLocation--;
 }
 
 core.int buildCounterReadInstruction = 0;
 buildReadInstruction() {
   var o = new api.ReadInstruction();
   buildCounterReadInstruction++;
   if (buildCounterReadInstruction < 3) {
     o.source = buildSource();
   }
   buildCounterReadInstruction--;
   return o;
 }
 
 checkReadInstruction(api.ReadInstruction o) {
   buildCounterReadInstruction++;
   if (buildCounterReadInstruction < 3) {
     checkSource(o.source);
   }
   buildCounterReadInstruction--;
 }
 
-buildUnnamed1803() {
+buildUnnamed1520() {
   var o = new core.List<api.WorkItemStatus>();
   o.add(buildWorkItemStatus());
   o.add(buildWorkItemStatus());
   return o;
 }
 
-checkUnnamed1803(core.List<api.WorkItemStatus> o) {
+checkUnnamed1520(core.List<api.WorkItemStatus> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkWorkItemStatus(o[0]);
   checkWorkItemStatus(o[1]);
 }
 
 core.int buildCounterReportWorkItemStatusRequest = 0;
 buildReportWorkItemStatusRequest() {
   var o = new api.ReportWorkItemStatusRequest();
   buildCounterReportWorkItemStatusRequest++;
   if (buildCounterReportWorkItemStatusRequest < 3) {
     o.currentWorkerTime = "foo";
-    o.workItemStatuses = buildUnnamed1803();
+    o.workItemStatuses = buildUnnamed1520();
     o.workerId = "foo";
   }
   buildCounterReportWorkItemStatusRequest--;
   return o;
 }
 
 checkReportWorkItemStatusRequest(api.ReportWorkItemStatusRequest o) {
   buildCounterReportWorkItemStatusRequest++;
   if (buildCounterReportWorkItemStatusRequest < 3) {
     unittest.expect(o.currentWorkerTime, unittest.equals('foo'));
-    checkUnnamed1803(o.workItemStatuses);
+    checkUnnamed1520(o.workItemStatuses);
     unittest.expect(o.workerId, unittest.equals('foo'));
   }
   buildCounterReportWorkItemStatusRequest--;
 }
 
-buildUnnamed1804() {
+buildUnnamed1521() {
   var o = new core.List<api.WorkItemServiceState>();
   o.add(buildWorkItemServiceState());
   o.add(buildWorkItemServiceState());
   return o;
 }
 
-checkUnnamed1804(core.List<api.WorkItemServiceState> o) {
+checkUnnamed1521(core.List<api.WorkItemServiceState> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkWorkItemServiceState(o[0]);
   checkWorkItemServiceState(o[1]);
 }
 
 core.int buildCounterReportWorkItemStatusResponse = 0;
 buildReportWorkItemStatusResponse() {
   var o = new api.ReportWorkItemStatusResponse();
   buildCounterReportWorkItemStatusResponse++;
   if (buildCounterReportWorkItemStatusResponse < 3) {
-    o.workItemServiceStates = buildUnnamed1804();
+    o.workItemServiceStates = buildUnnamed1521();
   }
   buildCounterReportWorkItemStatusResponse--;
   return o;
 }
 
 checkReportWorkItemStatusResponse(api.ReportWorkItemStatusResponse o) {
   buildCounterReportWorkItemStatusResponse++;
   if (buildCounterReportWorkItemStatusResponse < 3) {
-    checkUnnamed1804(o.workItemServiceStates);
+    checkUnnamed1521(o.workItemServiceStates);
   }
   buildCounterReportWorkItemStatusResponse--;
 }
 
-buildUnnamed1805() {
+buildUnnamed1522() {
   var o = new core.List<api.SideInputInfo>();
   o.add(buildSideInputInfo());
   o.add(buildSideInputInfo());
   return o;
 }
 
-checkUnnamed1805(core.List<api.SideInputInfo> o) {
+checkUnnamed1522(core.List<api.SideInputInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSideInputInfo(o[0]);
   checkSideInputInfo(o[1]);
 }
 
-buildUnnamed1806() {
+buildUnnamed1523() {
   var o = new core.List<api.SeqMapTaskOutputInfo>();
   o.add(buildSeqMapTaskOutputInfo());
   o.add(buildSeqMapTaskOutputInfo());
   return o;
 }
 
-checkUnnamed1806(core.List<api.SeqMapTaskOutputInfo> o) {
+checkUnnamed1523(core.List<api.SeqMapTaskOutputInfo> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSeqMapTaskOutputInfo(o[0]);
   checkSeqMapTaskOutputInfo(o[1]);
 }
 
-buildUnnamed1807() {
+buildUnnamed1524() {
   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;
 }
 
-checkUnnamed1807(core.Map<core.String, core.Object> o) {
+checkUnnamed1524(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted18 = (o["x"]) 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')); 
-  var casted19 = (o["y"]) 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["x"]) 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')); 
+  var casted21 = (o["y"]) 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')); 
 }
 
 core.int buildCounterSeqMapTask = 0;
 buildSeqMapTask() {
   var o = new api.SeqMapTask();
   buildCounterSeqMapTask++;
   if (buildCounterSeqMapTask < 3) {
-    o.inputs = buildUnnamed1805();
+    o.inputs = buildUnnamed1522();
     o.name = "foo";
-    o.outputInfos = buildUnnamed1806();
+    o.outputInfos = buildUnnamed1523();
     o.stageName = "foo";
     o.systemName = "foo";
-    o.userFn = buildUnnamed1807();
+    o.userFn = buildUnnamed1524();
   }
   buildCounterSeqMapTask--;
   return o;
 }
 
 checkSeqMapTask(api.SeqMapTask o) {
   buildCounterSeqMapTask++;
   if (buildCounterSeqMapTask < 3) {
-    checkUnnamed1805(o.inputs);
+    checkUnnamed1522(o.inputs);
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1806(o.outputInfos);
+    checkUnnamed1523(o.outputInfos);
     unittest.expect(o.stageName, unittest.equals('foo'));
     unittest.expect(o.systemName, unittest.equals('foo'));
-    checkUnnamed1807(o.userFn);
+    checkUnnamed1524(o.userFn);
   }
   buildCounterSeqMapTask--;
 }
 
 core.int buildCounterSeqMapTaskOutputInfo = 0;
 buildSeqMapTaskOutputInfo() {
   var o = new api.SeqMapTaskOutputInfo();
   buildCounterSeqMapTaskOutputInfo++;
   if (buildCounterSeqMapTaskOutputInfo < 3) {
     o.sink = buildSink();
@@ skipping 26 matching lines @@
 
 checkShellTask(api.ShellTask o) {
   buildCounterShellTask++;
   if (buildCounterShellTask < 3) {
     unittest.expect(o.command, unittest.equals('foo'));
     unittest.expect(o.exitCode, unittest.equals(42));
   }
   buildCounterShellTask--;
 }
 
-buildUnnamed1808() {
+buildUnnamed1525() {
   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;
 }
 
-checkUnnamed1808(core.Map<core.String, core.Object> o) {
+checkUnnamed1525(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted20 = (o["x"]) 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')); 
-  var casted21 = (o["y"]) 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["x"]) 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')); 
+  var casted23 = (o["y"]) 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')); 
 }
 
-buildUnnamed1809() {
+buildUnnamed1526() {
   var o = new core.List<api.Source>();
   o.add(buildSource());
   o.add(buildSource());
   return o;
 }
 
-checkUnnamed1809(core.List<api.Source> o) {
+checkUnnamed1526(core.List<api.Source> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSource(o[0]);
   checkSource(o[1]);
 }
 
 core.int buildCounterSideInputInfo = 0;
 buildSideInputInfo() {
   var o = new api.SideInputInfo();
   buildCounterSideInputInfo++;
   if (buildCounterSideInputInfo < 3) {
-    o.kind = buildUnnamed1808();
-    o.sources = buildUnnamed1809();
+    o.kind = buildUnnamed1525();
+    o.sources = buildUnnamed1526();
     o.tag = "foo";
   }
   buildCounterSideInputInfo--;
   return o;
 }
 
 checkSideInputInfo(api.SideInputInfo o) {
   buildCounterSideInputInfo++;
   if (buildCounterSideInputInfo < 3) {
-    checkUnnamed1808(o.kind);
-    checkUnnamed1809(o.sources);
+    checkUnnamed1525(o.kind);
+    checkUnnamed1526(o.sources);
     unittest.expect(o.tag, unittest.equals('foo'));
   }
   buildCounterSideInputInfo--;
 }
 
-buildUnnamed1810() {
+buildUnnamed1527() {
   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;
 }
 
-checkUnnamed1810(core.Map<core.String, core.Object> o) {
+checkUnnamed1527(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted22 = (o["x"]) 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')); 
-  var casted23 = (o["y"]) 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["x"]) 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')); 
+  var casted25 = (o["y"]) 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')); 
 }
 
-buildUnnamed1811() {
+buildUnnamed1528() {
   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) {
+checkUnnamed1528(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted24 = (o["x"]) 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')); 
-  var casted25 = (o["y"]) 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["x"]) 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')); 
+  var casted27 = (o["y"]) 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')); 
 }
 
 core.int buildCounterSink = 0;
 buildSink() {
   var o = new api.Sink();
   buildCounterSink++;
   if (buildCounterSink < 3) {
-    o.codec = buildUnnamed1810();
-    o.spec = buildUnnamed1811();
+    o.codec = buildUnnamed1527();
+    o.spec = buildUnnamed1528();
   }
   buildCounterSink--;
   return o;
 }
 
 checkSink(api.Sink o) {
   buildCounterSink++;
   if (buildCounterSink < 3) {
-    checkUnnamed1810(o.codec);
-    checkUnnamed1811(o.spec);
+    checkUnnamed1527(o.codec);
+    checkUnnamed1528(o.spec);
   }
   buildCounterSink--;
 }
 
-buildUnnamed1812() {
+buildUnnamed1529() {
   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;
 }
 
-checkUnnamed1812(core.Map<core.String, core.Object> o) {
+checkUnnamed1529(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted26 = (o["x"]) 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')); 
-  var casted27 = (o["y"]) 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["x"]) 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')); 
+  var casted29 = (o["y"]) 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')); 
 }
 
-buildUnnamed1813() {
+buildUnnamed1530() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed1812());
-  o.add(buildUnnamed1812());
+  o.add(buildUnnamed1529());
+  o.add(buildUnnamed1529());
   return o;
 }
 
-checkUnnamed1813(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed1530(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1812(o[0]);
-  checkUnnamed1812(o[1]);
+  checkUnnamed1529(o[0]);
+  checkUnnamed1529(o[1]);
 }
 
-buildUnnamed1814() {
+buildUnnamed1531() {
   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;
 }
 
-checkUnnamed1814(core.Map<core.String, core.Object> o) {
+checkUnnamed1531(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted28 = (o["x"]) 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')); 
-  var casted29 = (o["y"]) 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["x"]) 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')); 
+  var casted31 = (o["y"]) as core.Map; unittest.expect(casted31, unittest.hasLength(3)); unittest.expect(casted31["list"], unittest.equals([1, 2, 3])); unittest.expect(casted31["bool"], unittest.equals(true)); unittest.expect(casted31["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1815() {
+buildUnnamed1532() {
   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;
 }
 
-checkUnnamed1815(core.Map<core.String, core.Object> o) {
+checkUnnamed1532(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted30 = (o["x"]) 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')); 
-  var casted31 = (o["y"]) as core.Map; unittest.expect(casted31, unittest.hasLength(3)); unittest.expect(casted31["list"], unittest.equals([1, 2, 3])); unittest.expect(casted31["bool"], unittest.equals(true)); unittest.expect(casted31["string"], unittest.equals('foo')); 
+  var casted32 = (o["x"]) as core.Map; unittest.expect(casted32, unittest.hasLength(3)); unittest.expect(casted32["list"], unittest.equals([1, 2, 3])); unittest.expect(casted32["bool"], unittest.equals(true)); unittest.expect(casted32["string"], unittest.equals('foo')); 
+  var casted33 = (o["y"]) as core.Map; unittest.expect(casted33, unittest.hasLength(3)); unittest.expect(casted33["list"], unittest.equals([1, 2, 3])); unittest.expect(casted33["bool"], unittest.equals(true)); unittest.expect(casted33["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterSource = 0;
 buildSource() {
   var o = new api.Source();
   buildCounterSource++;
   if (buildCounterSource < 3) {
-    o.baseSpecs = buildUnnamed1813();
-    o.codec = buildUnnamed1814();
+    o.baseSpecs = buildUnnamed1530();
+    o.codec = buildUnnamed1531();
     o.doesNotNeedSplitting = true;
     o.metadata = buildSourceMetadata();
-    o.spec = buildUnnamed1815();
+    o.spec = buildUnnamed1532();
   }
   buildCounterSource--;
   return o;
 }
 
 checkSource(api.Source o) {
   buildCounterSource++;
   if (buildCounterSource < 3) {
-    checkUnnamed1813(o.baseSpecs);
-    checkUnnamed1814(o.codec);
+    checkUnnamed1530(o.baseSpecs);
+    checkUnnamed1531(o.codec);
     unittest.expect(o.doesNotNeedSplitting, unittest.isTrue);
     checkSourceMetadata(o.metadata);
-    checkUnnamed1815(o.spec);
+    checkUnnamed1532(o.spec);
   }
   buildCounterSource--;
 }
 
 core.int buildCounterSourceFork = 0;
 buildSourceFork() {
   var o = new api.SourceFork();
   buildCounterSourceFork++;
   if (buildCounterSourceFork < 3) {
     o.primary = buildSourceSplitShard();
+    o.primarySource = buildDerivedSource();
     o.residual = buildSourceSplitShard();
+    o.residualSource = buildDerivedSource();
   }
   buildCounterSourceFork--;
   return o;
 }
 
 checkSourceFork(api.SourceFork o) {
   buildCounterSourceFork++;
   if (buildCounterSourceFork < 3) {
     checkSourceSplitShard(o.primary);
+    checkDerivedSource(o.primarySource);
     checkSourceSplitShard(o.residual);
+    checkDerivedSource(o.residualSource);
   }
   buildCounterSourceFork--;
 }
 
 core.int buildCounterSourceGetMetadataRequest = 0;
 buildSourceGetMetadataRequest() {
   var o = new api.SourceGetMetadataRequest();
   buildCounterSourceGetMetadataRequest++;
   if (buildCounterSourceGetMetadataRequest < 3) {
     o.source = buildSource();
@@ skipping 92 matching lines @@
     checkSourceSplitResponse(o.split);
   }
   buildCounterSourceOperationResponse--;
 }
 
 core.int buildCounterSourceSplitOptions = 0;
 buildSourceSplitOptions() {
   var o = new api.SourceSplitOptions();
   buildCounterSourceSplitOptions++;
   if (buildCounterSourceSplitOptions < 3) {
+    o.desiredBundleSizeBytes = "foo";
     o.desiredShardSizeBytes = "foo";
   }
   buildCounterSourceSplitOptions--;
   return o;
 }
 
 checkSourceSplitOptions(api.SourceSplitOptions o) {
   buildCounterSourceSplitOptions++;
   if (buildCounterSourceSplitOptions < 3) {
+    unittest.expect(o.desiredBundleSizeBytes, unittest.equals('foo'));
     unittest.expect(o.desiredShardSizeBytes, unittest.equals('foo'));
   }
   buildCounterSourceSplitOptions--;
 }
 
 core.int buildCounterSourceSplitRequest = 0;
 buildSourceSplitRequest() {
   var o = new api.SourceSplitRequest();
   buildCounterSourceSplitRequest++;
   if (buildCounterSourceSplitRequest < 3) {
     o.options = buildSourceSplitOptions();
     o.source = buildSource();
   }
   buildCounterSourceSplitRequest--;
   return o;
 }
 
 checkSourceSplitRequest(api.SourceSplitRequest o) {
   buildCounterSourceSplitRequest++;
   if (buildCounterSourceSplitRequest < 3) {
     checkSourceSplitOptions(o.options);
     checkSource(o.source);
   }
   buildCounterSourceSplitRequest--;
 }
 
-buildUnnamed1816() {
+buildUnnamed1533() {
+  var o = new core.List<api.DerivedSource>();
+  o.add(buildDerivedSource());
+  o.add(buildDerivedSource());
+  return o;
+}
+
+checkUnnamed1533(core.List<api.DerivedSource> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkDerivedSource(o[0]);
+  checkDerivedSource(o[1]);
+}
+
+buildUnnamed1534() {
   var o = new core.List<api.SourceSplitShard>();
   o.add(buildSourceSplitShard());
   o.add(buildSourceSplitShard());
   return o;
 }
 
-checkUnnamed1816(core.List<api.SourceSplitShard> o) {
+checkUnnamed1534(core.List<api.SourceSplitShard> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkSourceSplitShard(o[0]);
   checkSourceSplitShard(o[1]);
 }
 
 core.int buildCounterSourceSplitResponse = 0;
 buildSourceSplitResponse() {
   var o = new api.SourceSplitResponse();
   buildCounterSourceSplitResponse++;
   if (buildCounterSourceSplitResponse < 3) {
+    o.bundles = buildUnnamed1533();
     o.outcome = "foo";
-    o.shards = buildUnnamed1816();
+    o.shards = buildUnnamed1534();
   }
   buildCounterSourceSplitResponse--;
   return o;
 }
 
 checkSourceSplitResponse(api.SourceSplitResponse o) {
   buildCounterSourceSplitResponse++;
   if (buildCounterSourceSplitResponse < 3) {
+    checkUnnamed1533(o.bundles);
     unittest.expect(o.outcome, unittest.equals('foo'));
-    checkUnnamed1816(o.shards);
+    checkUnnamed1534(o.shards);
   }
   buildCounterSourceSplitResponse--;
 }
 
 core.int buildCounterSourceSplitShard = 0;
 buildSourceSplitShard() {
   var o = new api.SourceSplitShard();
   buildCounterSourceSplitShard++;
   if (buildCounterSourceSplitShard < 3) {
     o.derivationMode = "foo";
     o.source = buildSource();
   }
   buildCounterSourceSplitShard--;
   return o;
 }
 
 checkSourceSplitShard(api.SourceSplitShard o) {
   buildCounterSourceSplitShard++;
   if (buildCounterSourceSplitShard < 3) {
     unittest.expect(o.derivationMode, unittest.equals('foo'));
     checkSource(o.source);
   }
   buildCounterSourceSplitShard--;
 }
 
-buildUnnamed1817() {
+buildUnnamed1535() {
   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;
 }
 
-checkUnnamed1817(core.Map<core.String, core.Object> o) {
+checkUnnamed1535(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted32 = (o["x"]) as core.Map; unittest.expect(casted32, unittest.hasLength(3)); unittest.expect(casted32["list"], unittest.equals([1, 2, 3])); unittest.expect(casted32["bool"], unittest.equals(true)); unittest.expect(casted32["string"], unittest.equals('foo')); 
-  var casted33 = (o["y"]) as core.Map; unittest.expect(casted33, unittest.hasLength(3)); unittest.expect(casted33["list"], unittest.equals([1, 2, 3])); unittest.expect(casted33["bool"], unittest.equals(true)); unittest.expect(casted33["string"], unittest.equals('foo')); 
+  var casted34 = (o["x"]) as core.Map; unittest.expect(casted34, unittest.hasLength(3)); unittest.expect(casted34["list"], unittest.equals([1, 2, 3])); unittest.expect(casted34["bool"], unittest.equals(true)); unittest.expect(casted34["string"], unittest.equals('foo')); 
+  var casted35 = (o["y"]) as core.Map; unittest.expect(casted35, unittest.hasLength(3)); unittest.expect(casted35["list"], unittest.equals([1, 2, 3])); unittest.expect(casted35["bool"], unittest.equals(true)); unittest.expect(casted35["string"], unittest.equals('foo')); 
 }
 
-buildUnnamed1818() {
+buildUnnamed1536() {
   var o = new core.List<core.Map<core.String, core.Object>>();
-  o.add(buildUnnamed1817());
-  o.add(buildUnnamed1817());
+  o.add(buildUnnamed1535());
+  o.add(buildUnnamed1535());
   return o;
 }
 
-checkUnnamed1818(core.List<core.Map<core.String, core.Object>> o) {
+checkUnnamed1536(core.List<core.Map<core.String, core.Object>> o) {
   unittest.expect(o, unittest.hasLength(2));
-  checkUnnamed1817(o[0]);
-  checkUnnamed1817(o[1]);
+  checkUnnamed1535(o[0]);
+  checkUnnamed1535(o[1]);
 }
 
 core.int buildCounterStatus = 0;
 buildStatus() {
   var o = new api.Status();
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     o.code = 42;
-    o.details = buildUnnamed1818();
+    o.details = buildUnnamed1536();
     o.message = "foo";
   }
   buildCounterStatus--;
   return o;
 }
 
 checkStatus(api.Status o) {
   buildCounterStatus++;
   if (buildCounterStatus < 3) {
     unittest.expect(o.code, unittest.equals(42));
-    checkUnnamed1818(o.details);
+    checkUnnamed1536(o.details);
     unittest.expect(o.message, unittest.equals('foo'));
   }
   buildCounterStatus--;
 }
 
-buildUnnamed1819() {
+buildUnnamed1537() {
   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;
 }
 
-checkUnnamed1819(core.Map<core.String, core.Object> o) {
+checkUnnamed1537(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted34 = (o["x"]) as core.Map; unittest.expect(casted34, unittest.hasLength(3)); unittest.expect(casted34["list"], unittest.equals([1, 2, 3])); unittest.expect(casted34["bool"], unittest.equals(true)); unittest.expect(casted34["string"], unittest.equals('foo')); 
-  var casted35 = (o["y"]) as core.Map; unittest.expect(casted35, unittest.hasLength(3)); unittest.expect(casted35["list"], unittest.equals([1, 2, 3])); unittest.expect(casted35["bool"], unittest.equals(true)); unittest.expect(casted35["string"], unittest.equals('foo')); 
+  var casted36 = (o["x"]) as core.Map; unittest.expect(casted36, unittest.hasLength(3)); unittest.expect(casted36["list"], unittest.equals([1, 2, 3])); unittest.expect(casted36["bool"], unittest.equals(true)); unittest.expect(casted36["string"], unittest.equals('foo')); 
+  var casted37 = (o["y"]) as core.Map; unittest.expect(casted37, unittest.hasLength(3)); unittest.expect(casted37["list"], unittest.equals([1, 2, 3])); unittest.expect(casted37["bool"], unittest.equals(true)); unittest.expect(casted37["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterStep = 0;
 buildStep() {
   var o = new api.Step();
   buildCounterStep++;
   if (buildCounterStep < 3) {
     o.kind = "foo";
     o.name = "foo";
-    o.properties = buildUnnamed1819();
+    o.properties = buildUnnamed1537();
   }
   buildCounterStep--;
   return o;
 }
 
 checkStep(api.Step o) {
   buildCounterStep++;
   if (buildCounterStep < 3) {
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.name, unittest.equals('foo'));
-    checkUnnamed1819(o.properties);
+    checkUnnamed1537(o.properties);
   }
   buildCounterStep--;
 }
 
 core.int buildCounterStreamLocation = 0;
 buildStreamLocation() {
   var o = new api.StreamLocation();
   buildCounterStreamLocation++;
   if (buildCounterStreamLocation < 3) {
     o.pubsubLocation = buildPubsubLocation();
+    o.sideInputLocation = buildStreamingSideInputLocation();
     o.streamingStageLocation = buildStreamingStageLocation();
   }
   buildCounterStreamLocation--;
   return o;
 }
 
 checkStreamLocation(api.StreamLocation o) {
   buildCounterStreamLocation++;
   if (buildCounterStreamLocation < 3) {
     checkPubsubLocation(o.pubsubLocation);
+    checkStreamingSideInputLocation(o.sideInputLocation);
     checkStreamingStageLocation(o.streamingStageLocation);
   }
   buildCounterStreamLocation--;
 }
 
+buildUnnamed1538() {
+  var o = new core.List<api.KeyRangeDataDiskAssignment>();
+  o.add(buildKeyRangeDataDiskAssignment());
+  o.add(buildKeyRangeDataDiskAssignment());
+  return o;
+}
+
+checkUnnamed1538(core.List<api.KeyRangeDataDiskAssignment> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkKeyRangeDataDiskAssignment(o[0]);
+  checkKeyRangeDataDiskAssignment(o[1]);
+}
+
+core.int buildCounterStreamingComputationRanges = 0;
+buildStreamingComputationRanges() {
+  var o = new api.StreamingComputationRanges();
+  buildCounterStreamingComputationRanges++;
+  if (buildCounterStreamingComputationRanges < 3) {
+    o.computationId = "foo";
+    o.rangeAssignments = buildUnnamed1538();
+  }
+  buildCounterStreamingComputationRanges--;
+  return o;
+}
+
+checkStreamingComputationRanges(api.StreamingComputationRanges o) {
+  buildCounterStreamingComputationRanges++;
+  if (buildCounterStreamingComputationRanges < 3) {
+    unittest.expect(o.computationId, unittest.equals('foo'));
+    checkUnnamed1538(o.rangeAssignments);
+  }
+  buildCounterStreamingComputationRanges--;
+}
+
+buildUnnamed1539() {
+  var o = new core.List<api.StreamingComputationRanges>();
+  o.add(buildStreamingComputationRanges());
+  o.add(buildStreamingComputationRanges());
+  return o;
+}
+
+checkUnnamed1539(core.List<api.StreamingComputationRanges> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkStreamingComputationRanges(o[0]);
+  checkStreamingComputationRanges(o[1]);
+}
+
+buildUnnamed1540() {
+  var o = new core.List<api.MountedDataDisk>();
+  o.add(buildMountedDataDisk());
+  o.add(buildMountedDataDisk());
+  return o;
+}
+
+checkUnnamed1540(core.List<api.MountedDataDisk> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  checkMountedDataDisk(o[0]);
+  checkMountedDataDisk(o[1]);
+}
+
+core.int buildCounterStreamingComputationTask = 0;
+buildStreamingComputationTask() {
+  var o = new api.StreamingComputationTask();
+  buildCounterStreamingComputationTask++;
+  if (buildCounterStreamingComputationTask < 3) {
+    o.computationRanges = buildUnnamed1539();
+    o.dataDisks = buildUnnamed1540();
+    o.taskType = "foo";
+  }
+  buildCounterStreamingComputationTask--;
+  return o;
+}
+
+checkStreamingComputationTask(api.StreamingComputationTask o) {
+  buildCounterStreamingComputationTask++;
+  if (buildCounterStreamingComputationTask < 3) {
+    checkUnnamed1539(o.computationRanges);
+    checkUnnamed1540(o.dataDisks);
+    unittest.expect(o.taskType, unittest.equals('foo'));
+  }
+  buildCounterStreamingComputationTask--;
+}
+
 core.int buildCounterStreamingSetupTask = 0;
 buildStreamingSetupTask() {
   var o = new api.StreamingSetupTask();
   buildCounterStreamingSetupTask++;
   if (buildCounterStreamingSetupTask < 3) {
     o.receiveWorkPort = 42;
     o.streamingComputationTopology = buildTopologyConfig();
     o.workerHarnessPort = 42;
   }
   buildCounterStreamingSetupTask--;
   return o;
 }
 
 checkStreamingSetupTask(api.StreamingSetupTask o) {
   buildCounterStreamingSetupTask++;
   if (buildCounterStreamingSetupTask < 3) {
     unittest.expect(o.receiveWorkPort, unittest.equals(42));
     checkTopologyConfig(o.streamingComputationTopology);
     unittest.expect(o.workerHarnessPort, unittest.equals(42));
   }
   buildCounterStreamingSetupTask--;
 }
 
+core.int buildCounterStreamingSideInputLocation = 0;
+buildStreamingSideInputLocation() {
+  var o = new api.StreamingSideInputLocation();
+  buildCounterStreamingSideInputLocation++;
+  if (buildCounterStreamingSideInputLocation < 3) {
+    o.tag = "foo";
+  }
+  buildCounterStreamingSideInputLocation--;
+  return o;
+}
+
+checkStreamingSideInputLocation(api.StreamingSideInputLocation o) {
+  buildCounterStreamingSideInputLocation++;
+  if (buildCounterStreamingSideInputLocation < 3) {
+    unittest.expect(o.tag, unittest.equals('foo'));
+  }
+  buildCounterStreamingSideInputLocation--;
+}
+
 core.int buildCounterStreamingStageLocation = 0;
 buildStreamingStageLocation() {
   var o = new api.StreamingStageLocation();
   buildCounterStreamingStageLocation++;
   if (buildCounterStreamingStageLocation < 3) {
     o.streamId = "foo";
   }
   buildCounterStreamingStageLocation--;
   return o;
 }
 
 checkStreamingStageLocation(api.StreamingStageLocation o) {
   buildCounterStreamingStageLocation++;
   if (buildCounterStreamingStageLocation < 3) {
     unittest.expect(o.streamId, unittest.equals('foo'));
   }
   buildCounterStreamingStageLocation--;
 }
 
-buildUnnamed1820() {
+buildUnnamed1541() {
   var o = new core.List<core.String>();
   o.add("foo");
   o.add("foo");
   return o;
 }
 
-checkUnnamed1820(core.List<core.String> o) {
+checkUnnamed1541(core.List<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 buildCounterTaskRunnerSettings = 0;
 buildTaskRunnerSettings() {
   var o = new api.TaskRunnerSettings();
   buildCounterTaskRunnerSettings++;
   if (buildCounterTaskRunnerSettings < 3) {
     o.alsologtostderr = true;
     o.baseTaskDir = "foo";
     o.baseUrl = "foo";
     o.commandlinesFileName = "foo";
     o.continueOnException = true;
     o.dataflowApiVersion = "foo";
     o.harnessCommand = "foo";
     o.languageHint = "foo";
     o.logDir = "foo";
     o.logToSerialconsole = true;
     o.logUploadLocation = "foo";
-    o.oauthScopes = buildUnnamed1820();
+    o.oauthScopes = buildUnnamed1541();
     o.parallelWorkerSettings = buildWorkerSettings();
     o.streamingWorkerMainClass = "foo";
     o.taskGroup = "foo";
     o.taskUser = "foo";
     o.tempStoragePrefix = "foo";
     o.vmId = "foo";
     o.workflowFileName = "foo";
   }
   buildCounterTaskRunnerSettings--;
   return o;
 }
 
 checkTaskRunnerSettings(api.TaskRunnerSettings o) {
   buildCounterTaskRunnerSettings++;
   if (buildCounterTaskRunnerSettings < 3) {
     unittest.expect(o.alsologtostderr, unittest.isTrue);
     unittest.expect(o.baseTaskDir, unittest.equals('foo'));
     unittest.expect(o.baseUrl, unittest.equals('foo'));
     unittest.expect(o.commandlinesFileName, unittest.equals('foo'));
     unittest.expect(o.continueOnException, unittest.isTrue);
     unittest.expect(o.dataflowApiVersion, unittest.equals('foo'));
     unittest.expect(o.harnessCommand, unittest.equals('foo'));
     unittest.expect(o.languageHint, unittest.equals('foo'));
     unittest.expect(o.logDir, unittest.equals('foo'));
     unittest.expect(o.logToSerialconsole, unittest.isTrue);
     unittest.expect(o.logUploadLocation, unittest.equals('foo'));
-    checkUnnamed1820(o.oauthScopes);
+    checkUnnamed1541(o.oauthScopes);
     checkWorkerSettings(o.parallelWorkerSettings);
     unittest.expect(o.streamingWorkerMainClass, unittest.equals('foo'));
     unittest.expect(o.taskGroup, unittest.equals('foo'));
     unittest.expect(o.taskUser, unittest.equals('foo'));
     unittest.expect(o.tempStoragePrefix, unittest.equals('foo'));
     unittest.expect(o.vmId, unittest.equals('foo'));
     unittest.expect(o.workflowFileName, unittest.equals('foo'));
   }
   buildCounterTaskRunnerSettings--;
 }
 
-buildUnnamed1821() {
+buildUnnamed1542() {
   var o = new core.List<api.ComputationTopology>();
   o.add(buildComputationTopology());
   o.add(buildComputationTopology());
   return o;
 }
 
-checkUnnamed1821(core.List<api.ComputationTopology> o) {
+checkUnnamed1542(core.List<api.ComputationTopology> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkComputationTopology(o[0]);
   checkComputationTopology(o[1]);
 }
 
-buildUnnamed1822() {
+buildUnnamed1543() {
   var o = new core.List<api.DataDiskAssignment>();
   o.add(buildDataDiskAssignment());
   o.add(buildDataDiskAssignment());
   return o;
 }
 
-checkUnnamed1822(core.List<api.DataDiskAssignment> o) {
+checkUnnamed1543(core.List<api.DataDiskAssignment> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDataDiskAssignment(o[0]);
   checkDataDiskAssignment(o[1]);
 }
 
 core.int buildCounterTopologyConfig = 0;
 buildTopologyConfig() {
   var o = new api.TopologyConfig();
   buildCounterTopologyConfig++;
   if (buildCounterTopologyConfig < 3) {
-    o.computations = buildUnnamed1821();
-    o.dataDiskAssignments = buildUnnamed1822();
+    o.computations = buildUnnamed1542();
+    o.dataDiskAssignments = buildUnnamed1543();
   }
   buildCounterTopologyConfig--;
   return o;
 }
 
 checkTopologyConfig(api.TopologyConfig o) {
   buildCounterTopologyConfig++;
   if (buildCounterTopologyConfig < 3) {
-    checkUnnamed1821(o.computations);
-    checkUnnamed1822(o.dataDiskAssignments);
+    checkUnnamed1542(o.computations);
+    checkUnnamed1543(o.dataDiskAssignments);
   }
   buildCounterTopologyConfig--;
 }
 
-buildUnnamed1823() {
+buildUnnamed1544() {
   var o = new core.List<api.Package>();
   o.add(buildPackage());
   o.add(buildPackage());
   return o;
 }
 
-checkUnnamed1823(core.List<api.Package> o) {
+checkUnnamed1544(core.List<api.Package> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPackage(o[0]);
   checkPackage(o[1]);
 }
 
 core.int buildCounterWorkItem = 0;
 buildWorkItem() {
   var o = new api.WorkItem();
   buildCounterWorkItem++;
   if (buildCounterWorkItem < 3) {
     o.configuration = "foo";
     o.id = "foo";
+    o.initialReportIndex = "foo";
     o.jobId = "foo";
     o.leaseExpireTime = "foo";
     o.mapTask = buildMapTask();
-    o.packages = buildUnnamed1823();
+    o.packages = buildUnnamed1544();
     o.projectId = "foo";
     o.reportStatusInterval = "foo";
     o.seqMapTask = buildSeqMapTask();
     o.shellTask = buildShellTask();
     o.sourceOperationTask = buildSourceOperationRequest();
+    o.streamingComputationTask = buildStreamingComputationTask();
     o.streamingSetupTask = buildStreamingSetupTask();
   }
   buildCounterWorkItem--;
   return o;
 }
 
 checkWorkItem(api.WorkItem o) {
   buildCounterWorkItem++;
   if (buildCounterWorkItem < 3) {
     unittest.expect(o.configuration, unittest.equals('foo'));
     unittest.expect(o.id, unittest.equals('foo'));
+    unittest.expect(o.initialReportIndex, unittest.equals('foo'));
     unittest.expect(o.jobId, unittest.equals('foo'));
     unittest.expect(o.leaseExpireTime, unittest.equals('foo'));
     checkMapTask(o.mapTask);
-    checkUnnamed1823(o.packages);
+    checkUnnamed1544(o.packages);
     unittest.expect(o.projectId, unittest.equals('foo'));
     unittest.expect(o.reportStatusInterval, unittest.equals('foo'));
     checkSeqMapTask(o.seqMapTask);
     checkShellTask(o.shellTask);
     checkSourceOperationRequest(o.sourceOperationTask);
+    checkStreamingComputationTask(o.streamingComputationTask);
     checkStreamingSetupTask(o.streamingSetupTask);
   }
   buildCounterWorkItem--;
 }
 
-buildUnnamed1824() {
+buildUnnamed1545() {
   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;
 }
 
-checkUnnamed1824(core.Map<core.String, core.Object> o) {
+checkUnnamed1545(core.Map<core.String, core.Object> o) {
   unittest.expect(o, unittest.hasLength(2));
-  var casted36 = (o["x"]) as core.Map; unittest.expect(casted36, unittest.hasLength(3)); unittest.expect(casted36["list"], unittest.equals([1, 2, 3])); unittest.expect(casted36["bool"], unittest.equals(true)); unittest.expect(casted36["string"], unittest.equals('foo')); 
-  var casted37 = (o["y"]) as core.Map; unittest.expect(casted37, unittest.hasLength(3)); unittest.expect(casted37["list"], unittest.equals([1, 2, 3])); unittest.expect(casted37["bool"], unittest.equals(true)); unittest.expect(casted37["string"], unittest.equals('foo')); 
+  var casted38 = (o["x"]) as core.Map; unittest.expect(casted38, unittest.hasLength(3)); unittest.expect(casted38["list"], unittest.equals([1, 2, 3])); unittest.expect(casted38["bool"], unittest.equals(true)); unittest.expect(casted38["string"], unittest.equals('foo')); 
+  var casted39 = (o["y"]) as core.Map; unittest.expect(casted39, unittest.hasLength(3)); unittest.expect(casted39["list"], unittest.equals([1, 2, 3])); unittest.expect(casted39["bool"], unittest.equals(true)); unittest.expect(casted39["string"], unittest.equals('foo')); 
 }
 
 core.int buildCounterWorkItemServiceState = 0;
 buildWorkItemServiceState() {
   var o = new api.WorkItemServiceState();
   buildCounterWorkItemServiceState++;
   if (buildCounterWorkItemServiceState < 3) {
-    o.harnessData = buildUnnamed1824();
+    o.harnessData = buildUnnamed1545();
     o.leaseExpireTime = "foo";
+    o.nextReportIndex = "foo";
     o.reportStatusInterval = "foo";
     o.suggestedStopPoint = buildApproximateProgress();
     o.suggestedStopPosition = buildPosition();
   }
   buildCounterWorkItemServiceState--;
   return o;
 }
 
 checkWorkItemServiceState(api.WorkItemServiceState o) {
   buildCounterWorkItemServiceState++;
   if (buildCounterWorkItemServiceState < 3) {
-    checkUnnamed1824(o.harnessData);
+    checkUnnamed1545(o.harnessData);
     unittest.expect(o.leaseExpireTime, unittest.equals('foo'));
+    unittest.expect(o.nextReportIndex, unittest.equals('foo'));
     unittest.expect(o.reportStatusInterval, unittest.equals('foo'));
     checkApproximateProgress(o.suggestedStopPoint);
     checkPosition(o.suggestedStopPosition);
   }
   buildCounterWorkItemServiceState--;
 }
 
-buildUnnamed1825() {
+buildUnnamed1546() {
   var o = new core.List<api.Status>();
   o.add(buildStatus());
   o.add(buildStatus());
   return o;
 }
 
-checkUnnamed1825(core.List<api.Status> o) {
+checkUnnamed1546(core.List<api.Status> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkStatus(o[0]);
   checkStatus(o[1]);
 }
 
-buildUnnamed1826() {
+buildUnnamed1547() {
   var o = new core.List<api.MetricUpdate>();
   o.add(buildMetricUpdate());
   o.add(buildMetricUpdate());
   return o;
 }
 
-checkUnnamed1826(core.List<api.MetricUpdate> o) {
+checkUnnamed1547(core.List<api.MetricUpdate> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkMetricUpdate(o[0]);
   checkMetricUpdate(o[1]);
 }
 
 core.int buildCounterWorkItemStatus = 0;
 buildWorkItemStatus() {
   var o = new api.WorkItemStatus();
   buildCounterWorkItemStatus++;
   if (buildCounterWorkItemStatus < 3) {
     o.completed = true;
-    o.errors = buildUnnamed1825();
-    o.metricUpdates = buildUnnamed1826();
+    o.dynamicSourceSplit = buildDynamicSourceSplit();
+    o.errors = buildUnnamed1546();
+    o.metricUpdates = buildUnnamed1547();
     o.progress = buildApproximateProgress();
     o.reportIndex = "foo";
     o.requestedLeaseDuration = "foo";
     o.sourceFork = buildSourceFork();
     o.sourceOperationResponse = buildSourceOperationResponse();
     o.stopPosition = buildPosition();
     o.workItemId = "foo";
   }
   buildCounterWorkItemStatus--;
   return o;
 }
 
 checkWorkItemStatus(api.WorkItemStatus o) {
   buildCounterWorkItemStatus++;
   if (buildCounterWorkItemStatus < 3) {
     unittest.expect(o.completed, unittest.isTrue);
-    checkUnnamed1825(o.errors);
-    checkUnnamed1826(o.metricUpdates);
+    checkDynamicSourceSplit(o.dynamicSourceSplit);
+    checkUnnamed1546(o.errors);
+    checkUnnamed1547(o.metricUpdates);
     checkApproximateProgress(o.progress);
     unittest.expect(o.reportIndex, unittest.equals('foo'));
     unittest.expect(o.requestedLeaseDuration, unittest.equals('foo'));
     checkSourceFork(o.sourceFork);
     checkSourceOperationResponse(o.sourceOperationResponse);
     checkPosition(o.stopPosition);
     unittest.expect(o.workItemId, unittest.equals('foo'));
   }
   buildCounterWorkItemStatus--;
 }
 
-buildUnnamed1827() {
+buildUnnamed1548() {
   var o = new core.List<api.Disk>();
   o.add(buildDisk());
   o.add(buildDisk());
   return o;
 }
 
-checkUnnamed1827(core.List<api.Disk> o) {
+checkUnnamed1548(core.List<api.Disk> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkDisk(o[0]);
   checkDisk(o[1]);
 }
 
-buildUnnamed1828() {
+buildUnnamed1549() {
   var o = new core.Map<core.String, core.String>();
   o["x"] = "foo";
   o["y"] = "foo";
   return o;
 }
 
-checkUnnamed1828(core.Map<core.String, core.String> o) {
+checkUnnamed1549(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'));
 }
 
-buildUnnamed1829() {
+buildUnnamed1550() {
   var o = new core.List<api.Package>();
   o.add(buildPackage());
   o.add(buildPackage());
   return o;
 }
 
-checkUnnamed1829(core.List<api.Package> o) {
+checkUnnamed1550(core.List<api.Package> o) {
   unittest.expect(o, unittest.hasLength(2));
   checkPackage(o[0]);
   checkPackage(o[1]);
 }
 
+buildUnnamed1551() {
+  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;
+}
+
+checkUnnamed1551(core.Map<core.String, core.Object> o) {
+  unittest.expect(o, unittest.hasLength(2));
+  var casted40 = (o["x"]) as core.Map; unittest.expect(casted40, unittest.hasLength(3)); unittest.expect(casted40["list"], unittest.equals([1, 2, 3])); unittest.expect(casted40["bool"], unittest.equals(true)); unittest.expect(casted40["string"], unittest.equals('foo')); 
+  var casted41 = (o["y"]) as core.Map; unittest.expect(casted41, unittest.hasLength(3)); unittest.expect(casted41["list"], unittest.equals([1, 2, 3])); unittest.expect(casted41["bool"], unittest.equals(true)); unittest.expect(casted41["string"], unittest.equals('foo')); 
+}
+
 core.int buildCounterWorkerPool = 0;
 buildWorkerPool() {
   var o = new api.WorkerPool();
   buildCounterWorkerPool++;
   if (buildCounterWorkerPool < 3) {
     o.autoscalingSettings = buildAutoscalingSettings();
-    o.dataDisks = buildUnnamed1827();
+    o.dataDisks = buildUnnamed1548();
     o.defaultPackageSet = "foo";
     o.diskSizeGb = 42;
     o.diskSourceImage = "foo";
     o.kind = "foo";
     o.machineType = "foo";
-    o.metadata = buildUnnamed1828();
+    o.metadata = buildUnnamed1549();
     o.numWorkers = 42;
     o.onHostMaintenance = "foo";
-    o.packages = buildUnnamed1829();
+    o.packages = buildUnnamed1550();
+    o.poolArgs = buildUnnamed1551();
     o.taskrunnerSettings = buildTaskRunnerSettings();
     o.teardownPolicy = "foo";
     o.zone = "foo";
   }
   buildCounterWorkerPool--;
   return o;
 }
 
 checkWorkerPool(api.WorkerPool o) {
   buildCounterWorkerPool++;
   if (buildCounterWorkerPool < 3) {
     checkAutoscalingSettings(o.autoscalingSettings);
-    checkUnnamed1827(o.dataDisks);
+    checkUnnamed1548(o.dataDisks);
     unittest.expect(o.defaultPackageSet, unittest.equals('foo'));
     unittest.expect(o.diskSizeGb, unittest.equals(42));
     unittest.expect(o.diskSourceImage, unittest.equals('foo'));
     unittest.expect(o.kind, unittest.equals('foo'));
     unittest.expect(o.machineType, unittest.equals('foo'));
-    checkUnnamed1828(o.metadata);
+    checkUnnamed1549(o.metadata);
     unittest.expect(o.numWorkers, unittest.equals(42));
     unittest.expect(o.onHostMaintenance, unittest.equals('foo'));
-    checkUnnamed1829(o.packages);
+    checkUnnamed1550(o.packages);
+    checkUnnamed1551(o.poolArgs);
     checkTaskRunnerSettings(o.taskrunnerSettings);
     unittest.expect(o.teardownPolicy, unittest.equals('foo'));
     unittest.expect(o.zone, unittest.equals('foo'));
   }
   buildCounterWorkerPool--;
 }
 
 core.int buildCounterWorkerSettings = 0;
 buildWorkerSettings() {
   var o = new api.WorkerSettings();
@@ skipping 75 matching lines @@
 
   unittest.group("obj-schema-DataDiskAssignment", () {
     unittest.test("to-json--from-json", () {
       var o = buildDataDiskAssignment();
       var od = new api.DataDiskAssignment.fromJson(o.toJson());
       checkDataDiskAssignment(od);
     });
   });
 
 
+  unittest.group("obj-schema-DerivedSource", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDerivedSource();
+      var od = new api.DerivedSource.fromJson(o.toJson());
+      checkDerivedSource(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Disk", () {
     unittest.test("to-json--from-json", () {
       var o = buildDisk();
       var od = new api.Disk.fromJson(o.toJson());
       checkDisk(od);
     });
   });
 
 
+  unittest.group("obj-schema-DynamicSourceSplit", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildDynamicSourceSplit();
+      var od = new api.DynamicSourceSplit.fromJson(o.toJson());
+      checkDynamicSourceSplit(od);
+    });
+  });
+
+
   unittest.group("obj-schema-Environment", () {
     unittest.test("to-json--from-json", () {
       var o = buildEnvironment();
       var od = new api.Environment.fromJson(o.toJson());
       checkEnvironment(od);
     });
   });
 
 
   unittest.group("obj-schema-FlattenInstruction", () {
@@ skipping 61 matching lines @@
 
   unittest.group("obj-schema-JobMetrics", () {
     unittest.test("to-json--from-json", () {
       var o = buildJobMetrics();
       var od = new api.JobMetrics.fromJson(o.toJson());
       checkJobMetrics(od);
     });
   });
 
 
+  unittest.group("obj-schema-KeyRangeDataDiskAssignment", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildKeyRangeDataDiskAssignment();
+      var od = new api.KeyRangeDataDiskAssignment.fromJson(o.toJson());
+      checkKeyRangeDataDiskAssignment(od);
+    });
+  });
+
+
   unittest.group("obj-schema-KeyRangeLocation", () {
     unittest.test("to-json--from-json", () {
       var o = buildKeyRangeLocation();
       var od = new api.KeyRangeLocation.fromJson(o.toJson());
       checkKeyRangeLocation(od);
     });
   });
 
 
   unittest.group("obj-schema-LeaseWorkItemRequest", () {
@@ skipping 52 matching lines @@
 
   unittest.group("obj-schema-MetricUpdate", () {
     unittest.test("to-json--from-json", () {
       var o = buildMetricUpdate();
       var od = new api.MetricUpdate.fromJson(o.toJson());
       checkMetricUpdate(od);
     });
   });
 
 
+  unittest.group("obj-schema-MountedDataDisk", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildMountedDataDisk();
+      var od = new api.MountedDataDisk.fromJson(o.toJson());
+      checkMountedDataDisk(od);
+    });
+  });
+
+
   unittest.group("obj-schema-MultiOutputInfo", () {
     unittest.test("to-json--from-json", () {
       var o = buildMultiOutputInfo();
       var od = new api.MultiOutputInfo.fromJson(o.toJson());
       checkMultiOutputInfo(od);
     });
   });
 
 
   unittest.group("obj-schema-Package", () {
@@ skipping 241 matching lines @@
 
   unittest.group("obj-schema-StreamLocation", () {
     unittest.test("to-json--from-json", () {
       var o = buildStreamLocation();
       var od = new api.StreamLocation.fromJson(o.toJson());
       checkStreamLocation(od);
     });
   });
 
 
+  unittest.group("obj-schema-StreamingComputationRanges", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildStreamingComputationRanges();
+      var od = new api.StreamingComputationRanges.fromJson(o.toJson());
+      checkStreamingComputationRanges(od);
+    });
+  });
+
+
+  unittest.group("obj-schema-StreamingComputationTask", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildStreamingComputationTask();
+      var od = new api.StreamingComputationTask.fromJson(o.toJson());
+      checkStreamingComputationTask(od);
+    });
+  });
+
+
   unittest.group("obj-schema-StreamingSetupTask", () {
     unittest.test("to-json--from-json", () {
       var o = buildStreamingSetupTask();
       var od = new api.StreamingSetupTask.fromJson(o.toJson());
       checkStreamingSetupTask(od);
     });
   });
 
 
+  unittest.group("obj-schema-StreamingSideInputLocation", () {
+    unittest.test("to-json--from-json", () {
+      var o = buildStreamingSideInputLocation();
+      var od = new api.StreamingSideInputLocation.fromJson(o.toJson());
+      checkStreamingSideInputLocation(od);
+    });
+  });
+
+
   unittest.group("obj-schema-StreamingStageLocation", () {
     unittest.test("to-json--from-json", () {
       var o = buildStreamingStageLocation();
       var od = new api.StreamingStageLocation.fromJson(o.toJson());
       checkStreamingStageLocation(od);
     });
   });
 
 
   unittest.group("obj-schema-TaskRunnerSettings", () {
@@ skipping 64 matching lines @@
       var o = buildWriteInstruction();
       var od = new api.WriteInstruction.fromJson(o.toJson());
       checkWriteInstruction(od);
     });
   });
 
 
   unittest.group("resource-V1b3ProjectsJobsResourceApi", () {
     unittest.test("method--create", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_request = buildJob();
       var arg_projectId = "foo";
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Job.fromJson(json);
         checkJob(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 18 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildJob());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.create(arg_request, arg_projectId, view: arg_view).then(unittest.expectAsync(((api.Job response) {
         checkJob(response);
       })));
     });
 
     unittest.test("method--get", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       var arg_view = "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("/"));
@@ skipping 15 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildJob());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.get(arg_projectId, arg_jobId, view: arg_view).then(unittest.expectAsync(((api.Job response) {
         checkJob(response);
       })));
     });
 
     unittest.test("method--getMetrics", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       var arg_startTime = "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("/"));
@@ skipping 15 matching lines @@
             addQueryParam(core.Uri.decodeQueryComponent(keyvalue[0]), core.Uri.decodeQueryComponent(keyvalue[1]));
           }
         }
         unittest.expect(queryMap["startTime"].first, unittest.equals(arg_startTime));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildJobMetrics());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.getMetrics(arg_projectId, arg_jobId, startTime: arg_startTime).then(unittest.expectAsync(((api.JobMetrics response) {
         checkJobMetrics(response);
       })));
     });
 
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_projectId = "foo";
       var arg_pageSize = 42;
       var arg_pageToken = "foo";
       var arg_view = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
         var pathOffset = 0;
         var index;
         var subPart;
@@ skipping 18 matching lines @@
         }
         unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(queryMap["view"].first, unittest.equals(arg_view));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListJobsResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_projectId, pageSize: arg_pageSize, pageToken: arg_pageToken, view: arg_view).then(unittest.expectAsync(((api.ListJobsResponse response) {
         checkListJobsResponse(response);
       })));
     });
 
     unittest.test("method--patch", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_request = buildJob();
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Job.fromJson(json);
         checkJob(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 17 matching lines @@
             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(buildJob());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.patch(arg_request, arg_projectId, arg_jobId).then(unittest.expectAsync(((api.Job response) {
         checkJob(response);
       })));
     });
 
     unittest.test("method--update", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs;
       var arg_request = buildJob();
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.Job.fromJson(json);
         checkJob(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 17 matching lines @@
             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(buildJob());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.update(arg_request, arg_projectId, arg_jobId).then(unittest.expectAsync(((api.Job response) {
         checkJob(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-V1b3ProjectsJobsMessagesResourceApi", () {
     unittest.test("method--list", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsMessagesResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs.messages;
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       var arg_endTime = "foo";
       var arg_minimumImportance = "foo";
       var arg_pageSize = 42;
       var arg_pageToken = "foo";
       var arg_startTime = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var path = (req.url).path;
@@ skipping 23 matching lines @@
         unittest.expect(queryMap["minimumImportance"].first, unittest.equals(arg_minimumImportance));
         unittest.expect(core.int.parse(queryMap["pageSize"].first), unittest.equals(arg_pageSize));
         unittest.expect(queryMap["pageToken"].first, unittest.equals(arg_pageToken));
         unittest.expect(queryMap["startTime"].first, unittest.equals(arg_startTime));
 
 
         var h = {
           "content-type" : "application/json; charset=utf-8",
         };
         var resp = convert.JSON.encode(buildListJobMessagesResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.list(arg_projectId, arg_jobId, endTime: arg_endTime, minimumImportance: arg_minimumImportance, pageSize: arg_pageSize, pageToken: arg_pageToken, startTime: arg_startTime).then(unittest.expectAsync(((api.ListJobMessagesResponse response) {
         checkListJobMessagesResponse(response);
       })));
     });
 
   });
 
 
   unittest.group("resource-V1b3ProjectsJobsWorkItemsResourceApi", () {
     unittest.test("method--lease", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsWorkItemsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs.workItems;
       var arg_request = buildLeaseWorkItemRequest();
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.LeaseWorkItemRequest.fromJson(json);
         checkLeaseWorkItemRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 17 matching lines @@
             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(buildLeaseWorkItemResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.lease(arg_request, arg_projectId, arg_jobId).then(unittest.expectAsync(((api.LeaseWorkItemResponse response) {
         checkLeaseWorkItemResponse(response);
       })));
     });
 
     unittest.test("method--reportStatus", () {
 
-      var mock = new common_test.HttpServerMock();
+      var mock = new HttpServerMock();
       api.V1b3ProjectsJobsWorkItemsResourceApi res = new api.DataflowApi(mock).v1b3.projects.jobs.workItems;
       var arg_request = buildReportWorkItemStatusRequest();
       var arg_projectId = "foo";
       var arg_jobId = "foo";
       mock.register(unittest.expectAsync((http.BaseRequest req, json) {
         var obj = new api.ReportWorkItemStatusRequest.fromJson(json);
         checkReportWorkItemStatusRequest(obj);
 
         var path = (req.url).path;
         var pathOffset = 0;
@@ skipping 17 matching lines @@
             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(buildReportWorkItemStatusResponse());
-        return new async.Future.value(common_test.stringResponse(200, h, resp));
+        return new async.Future.value(stringResponse(200, h, resp));
       }), true);
       res.reportStatus(arg_request, arg_projectId, arg_jobId).then(unittest.expectAsync(((api.ReportWorkItemStatusResponse response) {
         checkReportWorkItemStatusResponse(response);
       })));
     });
 
   });
 
 
 }