import java.util.Properties


@DisableCachingByDefault(because = "Not worth caching")
abstract class UpdateInitPluginTemplateVersionFile : DefaultTask() {

    private
    val devSuffixes = arrayOf(
        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc(-?\\d+)?",
        "-M.+",
        "-eap-?\\d+"

    assertThat(Shorts.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Shorts.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Shorts.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Shorts.concat(ARRAY1, ARRAY1, ARRAY1))
        .isEqualTo(new short[] {(short) 1, (short) 1, (short) 1});
    assertThat(Shorts.concat(ARRAY1, ARRAY234))

    assertThat(Doubles.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Doubles.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Doubles.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Doubles.concat(ARRAY1, ARRAY1, ARRAY1)).isEqualTo(new double[] {1.0, 1.0, 1.0});
    assertThat(Doubles.concat(ARRAY1, ARRAY234)).isEqualTo(new double[] {1.0, 2.0, 3.0, 4.0});
  }

    assertThat(Ints.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Ints.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Ints.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Ints.concat(ARRAY1, ARRAY1, ARRAY1))
        .isEqualTo(new int[] {(int) 1, (int) 1, (int) 1});
    assertThat(Ints.concat(ARRAY1, ARRAY234))

    assertThat(Chars.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Chars.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Chars.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Chars.concat(ARRAY1, ARRAY1, ARRAY1))
        .isEqualTo(new char[] {(char) 1, (char) 1, (char) 1});
    assertThat(Chars.concat(ARRAY1, ARRAY234))

      System.arraycopy(values.array, values.start, array, count, values.length());
      count += values.length();
      return this;
    }

    private void ensureRoomFor(int numberToAdd) {
      int newCount = count + numberToAdd; // TODO(kevinb): check overflow now?
      if (newCount > array.length) {
        array = Arrays.copyOf(array, expandedCapacity(array.length, newCount));
      }
    }

    return Arrays.stream(array, start, end);
  }

  /** Returns a new, mutable copy of this array's values, as a primitive {@code int[]}. */
  public int[] toArray() {
    return Arrays.copyOfRange(array, start, end);
  }

  /**
   * Returns a new immutable array containing the values in the specified range.
   *

        Arrays.sort(inputs);

        if (id == 0) {
            // create
            newInputs = inputs;
            newOutput = output;
        }
    }

    /**
     * Returns the array of new input character sequences for update operations.
     * Returns a defensive copy to prevent external modification.
     *

    T[] result = newArray(array, array.length + 1);
    result[0] = element;
    arraycopy(array, 0, result, 1, array.length);
    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end

        }
        final Ingester[] newIngesters = Arrays.copyOf(ingesters, ingesters.length + 1);
        newIngesters[ingesters.length] = ingester;
        Arrays.sort(newIngesters, (o1, o2) -> o1.priority - o2.priority);
        ingesters = newIngesters;
    }

    /**
     * Returns the array of registered ingesters sorted by priority.
     * The returned array contains all ingesters in priority order