// update the resource if we stop supporting modelVersion 4.0.0
        File f1 = getTestFile("src/test/resources/projects/past-model-version-pom.xml");

        ProjectBuildingException e = assertThrows(
                ProjectBuildingException.class, () -> getProject(f1), "Expected to fail for past versions");
        assertTrue(e.getMessage().contains("Building this project requires an older version of Maven"));
    }

	resCh := resultsDone
	var done atomic.Bool
	resErr := io.EOF

	go func() {
		var results metaCacheEntriesSorted
		var returned bool
		for entry := range in {
			if returned {
				// past limit
				continue
			}
			returned = done.Load()
			if returned {
				resCh = nil
				continue
			}
			if yes := o.shouldSkip(ctx, entry); yes {

				}
			}
		}
	}

	if len(events) > 0 {
		slices.SortFunc(events, func(a, b Event) int {
			// Prefer Expiration over Transition for both current
			// and noncurrent versions when,
			// - now is past the expected time to action
			// - expected time to action is the same for both actions
			if now.After(a.Due) && now.After(b.Due) || a.Due.Equal(b.Due) {
				switch a.Action {

			// if the config param was found.
			val, _, _ := s.ResolveConfigParam(config.IdentityOpenIDSubSys, cfgName, cfgParam, false)
			return val
		}

		// In the past, when only one openID provider was allowed, there
		// was no `enable` parameter - the configuration is turned off
		// by clearing the values. With multiple providers, we support

        assertEquals(10, ndrBuffer.getLength());

        ndrBuffer.advance(5);
        assertEquals(15, ndrBuffer.getIndex());
        assertEquals(15, ndrBuffer.getLength());

        // Advance past current length
        ndrBuffer.setLength(10);
        ndrBuffer.setIndex(10);
        ndrBuffer.advance(10);
        assertEquals(20, ndrBuffer.getIndex());

        // Read in chunks
        byte[] buffer = new byte[10];

        // The read will either:
        // 1. Successfully read all 5 bytes
        // 2. Throw IOException if it tries to read past the message
        try {
            int read = sis.read(buffer, 0, 10);

            // Should read all 5 available bytes
            assertEquals(5, read);

            // Verify correct data

//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans
// on a reader, should use [bufio.Reader] instead.
type Scanner struct {

       *
       * - in the "reentrant submit" case of `execute` (in which case we must have started running a
       *   user task -- which means that we already got past this code (or else we exited early
       *   above))
       */
      // Unconditionally set; there is no risk of throwing away a queued task from another thread,

	case io.SeekEnd:
		rsc.offset = rsc.size + offset
	}
	if rsc.offset < 0 {
		return rsc.offset, errors.New("seek to invalid negative offset")
	}
	if rsc.offset >= rsc.size {
		return rsc.offset, errors.New("seek past end of object")
	}
	if rsc.reader != nil {
		_ = rsc.reader.Close()
		rsc.reader = nil
	}
	return rsc.offset, nil
}

// Read call to implement io.Reader

       *
       * - in the "reentrant submit" case of `execute` (in which case we must have started running a
       *   user task -- which means that we already got past this code (or else we exited early
       *   above))
       */
      // Unconditionally set; there is no risk of throwing away a queued task from another thread,