'Integer'        | []                                   | 'null'              | 'not provided'
        'Long'           | ['--myProp=123']                     | '123'               | 'provided'
        'Long'           | []                                   | 'null'              | 'not provided'

      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 2L,
      codec =
        object : BasicDerAdapter.Codec<Long> {
          override fun decode(reader: DerReader): Long = reader.readLong()

          override fun encode(
            writer: DerWriter,
            value: Long,
          ) = writer.writeLong(value)
        },
    )

  val INTEGER_AS_BIG_INTEGER =
    BasicDerAdapter(

    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? {
          return null
        }

        override fun contentLength(): Long {
          return 5
        }

        override fun source(): BufferedSource {
          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {

        0x2ff             | 0x1000
        0x1000            | -1
        Integer.MAX_VALUE | -1
        Long.MAX_VALUE    | -1
        Long.MAX_VALUE    | -0xc3412
        Integer.MAX_VALUE | Integer.MIN_VALUE
        Long.MAX_VALUE    | Long.MIN_VALUE
    }

    def "decode fails when small long cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->

   * happens first. Returns the total number of bytes skipped.
   */
  static long skipUpTo(InputStream in, long n) throws IOException {
    long totalSkipped = 0;
    // A buffer is allocated if skipSafely does not skip any bytes.
    byte[] buf = null;

    while (totalSkipped < n) {
      long remaining = n - totalSkipped;
      long skipped = skipSafely(in, remaining);

      if (skipped == 0) {

        private final WorkerProcess delegate;
        private final MemoryManager memoryResourceManager;
        private final long memoryAmount;

        private MemoryRequestingWorkerProcess(WorkerProcess delegate, MemoryManager memoryResourceManager, long memoryAmount) {
            this.delegate = delegate;
            this.memoryResourceManager = memoryResourceManager;
            this.memoryAmount = memoryAmount;

    }

    private long initializeHome() {
        executer.requireIsolatedDaemons() // needs to stop daemon
        requireOwnGradleUserHomeDir() // needs its own journal
        run() // Make sure cache directory is initialized
        run '--stop' // ensure daemon does not cache file access times in memory
        return gcFile().makeOlder().lastModified()
    }

    long markCacheLastCleaned(long timeMillis) {

    class Splitr extends MapWithIndexSpliterator<Spliterator.OfLong, R, Splitr>
        implements LongConsumer, Spliterator<R> {
      long holder;

      Splitr(Spliterator.OfLong splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(long t) {
        this.holder = t;
      }

      @Override
      public boolean tryAdvance(Consumer<? super R> action) {

        final long execTime = systemHelper.getCurrentTimeAsLong() - startTime;
        crawlingInfoHelper.putToInfoMap(Constants.DATA_CRAWLING_EXEC_TIME, Long.toString(execTime));
        if (logger.isInfoEnabled()) {
            logger.info("[EXEC TIME] crawling time: {}ms", execTime);
        }

        crawlingInfoHelper.putToInfoMap(Constants.DATA_INDEX_EXEC_TIME, Long.toString(indexUpdateCallback.getExecuteTime()));

    }

    @Nullable
    public String getArtifactHash(long contextId, File file) {
        return getResolutionData(contextId).getArtifactHash(file);
    }

    public FileCollection getTypeHierarchyAnalysis(long contextId) {
        return getResolutionData(contextId).getTypeHierarchyAnalysisResult();
    }

    private ResolutionData getResolutionData(long contextId) {