assertThat(readFully(reader)).isEqualTo(string);
    assertFullyRead(reader);

    // reset, skip, mark, then read the rest
    reader.reset();
    assertEquals(5, reader.skip(5));
    reader.mark(Integer.MAX_VALUE);
    assertThat(readFully(reader)).isEqualTo(string.substring(5));
    assertFullyRead(reader);

    // reset to the mark and then read the rest
    reader.reset();

        final String value = System.getProperty("corelib.timeout_task.num_of_threads");
        if (StringUtil.isNotBlank(value)) {
            try {
                nThreads = Integer.parseInt(value);
            } catch (final NumberFormatException e) {
                logger.warn("Failed to parse " + value, e);
            }
        }
        if (nThreads < 1) {
            nThreads = 1;

    if (occurrences == 0) {
      return count(element);
    }
    int index = element.ordinal();
    int oldCount = counts[index];
    long newCount = (long) oldCount + occurrences;
    checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
    counts[index] = (int) newCount;
    if (oldCount == 0) {
      distinctElements++;
    }
    size += occurrences;
    return oldCount;
  }

        // Check information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel);
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, 0, 100, 255, Integer.MAX_VALUE })
    void testMapInformationLevelWithUnsupportedLevels(int level) {
        if (level == FileInformation.FILE_BASIC_INFO || level == FileInformation.FILE_STANDARD_INFO

    @Inject
    private PlexusContainer container;

    @Inject
    private LegacySupport legacySupport;

    private final Executor executor;

    public DefaultArtifactResolver() {
        int threads = Integer.getInteger("maven.artifact.threads", 5);
        if (threads <= 1) {
            executor = Runnable::run;
        } else {
            executor = new ThreadPoolExecutor(

    }

    private void parseHtmlEncodedChar(StringBuilder buffer) {
        scanner.next(2);
        scanner.mark();
        scanner.find(';');
        String value = new String(new char[]{(char) Integer.parseInt(scanner.region())});
        buffer.append(value);
        scanner.next();
    }

    private void parseJavadocTag(TokenVisitor visitor) {
        // start of tag marker
        scanner.next(2);

        case ERROR_ACCESS_DENIED:
            return "Access denied";
        case ERROR_INVALID_STATE:
            return "Invalid state";
        default:
            return "Unknown error: 0x" + Integer.toHexString(returnCode);
        }
    }

    /**
     * Encodes the witness RPC message parameters to NDR format.
     * Subclasses must implement this method to encode their specific parameters.
     *

        key8[6] = (byte) (key[5] << 2 | (key[6] & 0xFF) >>> 6);
        key8[7] = (byte) (key[6] << 1);
        for (int i = 0; i < key8.length; i++) {
            key8[i] ^= Integer.bitCount(key8[i] ^ 1) & 1;
        }
        return key8;
    }

    /**
     * Default provider is BouncyCastleProvider.
     * For registering custom provider

            assertTrue(s);
        }
    }

    @DisplayName("Test exception handling for invalid information levels")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 5, 6, 8, 100, -2, -100, Integer.MIN_VALUE, Integer.MAX_VALUE })
    void testInvalidInformationLevels(int invalidLevel) {
        // Skip valid levels

    @Internal
    protected File getPidFile() {
        return new File(baseDir, 'pid')
    }

    /** Reads the pid file and returns the process' pid */
    @Internal
    int getPid() {
        return Integer.parseInt(pidFile.getText('UTF-8').trim())
    }

    /** Returns the file the process writes its bound ports to. Defaults to "ports" inside baseDir. */
    @Internal
    protected File getPortsFile() {