ProcessGroovyMethodsExecute.execute(["some", "string"])
            ProcessGroovyMethodsExecute.execute(["some", "string"], ["array"] as String[], file("test"))
            ProcessGroovyMethodsExecute.execute(["some", "string"], ["array"], file("test"))

            execute("some string")
            execute("some string", ["array"] as String[], file("test"))

/**
 * Simple helper class to build a "sparse" array of objects based on the indexes that were added to
 * it. The array will be from 0 to the maximum index given. All non-set indexes will contain null
 * (so it's not really a sparse array, just a pseudo sparse array). The builder can also return a
 * CharEscaper based on the generated array.
 *
 * @author Sven Mawson
 * @since 15.0
 */
@GwtCompatible

  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,
    socket: Socket,
  ) {
    if (socket.peerName() !in insecureHosts) {
      delegate.checkServerTrusted(chain, authType, socket)
    }
  }

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,

      _, right_padding = tf.raw_ops.SplitV(
          value=rarray,
          size_splits=[-1, right_padding_size],
          axis=i,
          num_split=2)
    else:
      _, left_padding = tf.raw_ops.SplitV(
          value=rarray,
          size_splits=[-1, left_padding_size],
          axis=i,
          num_split=2)
      right_padding, _ = tf.raw_ops.SplitV(
          value=rarray,
          size_splits=[right_padding_size, -1],

          "description": "MergingList field.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/mergeItem"
          },
          "x-kubernetes-patch-merge-key": "name",
          "x-kubernetes-patch-strategy": "merge"
        },
        "nonMergingList": {
          "description": "NonMergingList field.",
          "type": "array",
          "items": {
            "$ref": "#/definitions/mergeItem"

  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = Helpers.mapEntry(null, oldEntry.getValue());
    return array;
  }

  /**

      // Shift value left while iterating logically through the array.
      result |= (input[offset + i] & 0xFFL) << (i * 8);
    }
    return result;
  }

  /**
   * Store 8 bytes into the provided array at the indicated offset, using the value provided.
   *
   * @param sink the output byte array
   * @param offset the offset into the array at which to start writing
   * @param value the value to write
   */

        public int count;
        public ShareInfo0[] array;


        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.count);
            _dst.enc_ndr_referent(this.array, 1);

            if ( this.array != null ) {
                _dst = _dst.deferred;
                int _arrays = this.count;

  // The first `size` elements are non-null.
  @VisibleForTesting final transient @Nullable Object[] array;
  private final transient int size;

  RegularImmutableList(@Nullable Object[] array, int size) {
    this.array = array;
    this.size = size;
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  boolean isPartialView() {

          "nonMergingList": {
            "description": "NonMergingList field.",
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/mergeItem"
            }
          },
          "mergingIntList": {
            "description": "MergingIntList field.",
            "type": "array",
            "items": {
              "type": "integer",
              "format": "int32"
            },