@Override
    public Character[] createArray(int length) {
      return new Character[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Character> order(List<Character> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleChars extends SampleElements<Character> {
    public SampleChars() {

        if (getContainer().hasComponent(ProjectBuilder.class, "test")) {
            projectBuilder = getContainer().lookup(ProjectBuilder.class, "test");
        } else {
            // default over to the main project builder...
            projectBuilder = getContainer().lookup(ProjectBuilder.class);
        }
    }

    protected ProjectBuilder getProjectBuilder() {
        return projectBuilder;
    }

### Transition Status

```

### Set object lock

PutObject API allows setting per object retention mode and retention duration using `x-amz-object-lock-mode` and `x-amz-object-lock-retain-until-date` headers. This takes precedence over any bucket object lock configuration w.r.t retention.

```sh
aws s3api put-object --bucket testbucket --key lockme --object-lock-mode GOVERNANCE --object-lock-retain-until-date "2019-11-20"  --body /etc/issue
```

    @Override
    public Short[] createArray(int length) {
      return new Short[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Short> order(List<Short> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleShorts extends SampleElements<Short> {
    public SampleShorts() {

    @Override
    public Long[] createArray(int length) {
      return new Long[length];
    }

    /** Returns the original element list, unchanged. */
    @Override
    public List<Long> order(List<Long> insertionOrder) {
      return insertionOrder;
    }
  }

  public static class SampleLongs extends SampleElements<Long> {
    public SampleLongs() {

	for metricName, mv := range m.values {
		desc := m.descriptors[metricName]
		promDesc := desc.toPromDesc(namePrefix, extraLabels)
		for _, v := range mv {
			// labelValues is in the same order as the variable labels in the
			// descriptor.
			labelValues := make([]string, 0, len(v.Labels))
			for _, k := range desc.VariableLabels {
				labelValues = append(labelValues, v.Labels[k])
			}

  if (num_dims > TensorShape::MaxDimensions()) {
    return errors::InvalidArgument("Value specified for `", attr_name, "` has ",
                                   num_dims,
                                   " dimensions which is over the limit of ",
                                   TensorShape::MaxDimensions(), ".");
  }
  TensorShapeProto proto;
  if (num_dims < 0) {
    proto.set_unknown_rank(true);
  } else {

   * that conversion is safe.
   *
   * <p>This method is intended to help with usages of type parameters that have {@linkplain
   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.

      return emptySet();
    }
  }

  /**
   * Creates a suite whose map has some elements filtered out of view.
   *
   * <p>Because the map may be ascending or descending, this test must derive the relative order of
   * these extreme values rather than relying on their regular sort ordering.
   */
  final TestSuite createSubmapSuite(
      FeatureSpecificTestSuiteBuilder<