*/
  // Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
  @SuppressWarnings("ShortCircuitBoolean")
  public static boolean isPowerOfTwo(long x) {
    return x > 0 & (x & (x - 1)) == 0;
  }

  /**
   * Returns 1 if {@code x < y} as unsigned longs, and 0 otherwise. Assumes that x - y fits into a

    }

    @Test
    void testNewSyncContext() throws Exception {
        // SyncContext newSyncContext( RepositorySystemSession session, boolean shared );
    }

            throws ExecutionException, InterruptedException {
        int nThreads = Math.min(
                session.getRequest().getDegreeOfConcurrency(),
                session.getProjects().size());
        boolean parallel = nThreads > 1;
        // Propagate the parallel flag to the root session and all the cloned sessions in each project segment
        session.setParallel(parallel);
        for (ProjectSegment segment : projectBuilds) {

     *
     * @param artifactType the type of the artifact
     * @param name the name of the artifact
     * @return true if the artifact should be excluded, false otherwise
     */
    protected boolean isExcludedName(final ArtifactType artifactType, final String name) {
        if (artifactType != ArtifactType.CRAWLER) {
            return false;
        }

        if ("fess-crawler".equals(name)//

            return null;
        }
    }

    private ArtifactRepository createRepository(
            String url,
            String repositoryId,
            boolean releases,
            String releaseUpdates,
            boolean snapshots,
            String snapshotUpdates,
            String checksumPolicy) {
        ArtifactRepositoryPolicy snapshotsPolicy =

    @ParameterizedTest
    @ValueSource(strings = { "192.168.0.1", "123.45.67.89", "1.2.3.4" })
    void isDotQuadIPRecognizesDotQuadIP(String ip) {
        // Arrange & Act
        boolean result = UniAddress.isDotQuadIP(ip);
        // Assert
        assertTrue(result, "isDotQuadIP should return true for dot-quad IP");
    }

    @ParameterizedTest

            assertNotNull(result, "Icon result should not be null for " + icon);

            // Result should be consistent with charset's canEncode capability
            boolean canEncode = StandardCharsets.ISO_8859_1.newEncoder().canEncode(icon.getUnicodeChar());
            String expected = canEncode ? String.valueOf(icon.getUnicodeChar()) : icon.getAsciiFallback();

            public Optional<UnaryOperator<String>> getInterpolationSource() {
                return Optional.ofNullable(interpolationSource);
            }

            @Override
            public boolean equals(Object o) {
                return o instanceof DefaultSettingsBuilderRequest that
                        && Objects.equals(installationSettingsSource, that.installationSettingsSource)

            System.err.println("Unable determine version from JAR file: " + e.getMessage());
        }

        return properties;
    }

    public static void showError(Logger logger, String message, Throwable e, boolean showStackTrace) {
        if (logger == null) {
            System.err.println(message);
            if (showStackTrace && e != null) {
                e.printStackTrace(System.err);
            }

    /** Adds a path segment. If the input is ".." or equivalent, this pops a path segment. */
    private fun push(
      input: String,
      pos: Int,
      limit: Int,
      addTrailingSlash: Boolean,
      alreadyEncoded: Boolean,
    ) {
      val segment =
        input.canonicalize(
          pos = pos,
          limit = limit,
          encodeSet = PATH_SEGMENT_ENCODE_SET,