// ----------------------------------------------------------------------

    @Test
    @DisabledOnOs(value = WINDOWS, disabledReason = "need to investigate why it fails on windows")
    void testProjectInheritance() throws Exception {
        File localRepo = getLocalRepositoryPath();

        System.out.println("Local repository is at: " + localRepo.getAbsolutePath());

        File pom0 = new File(localRepo, "p0/pom.xml");

            cb.query().addOrderBy_Name_Asc();
        }, scheduledJob -> {
            try {
                ComponentUtil.getJobHelper().register(cron, scheduledJob);
            } catch (final Exception e) {
                logger.error("Failed to start job: id={}", scheduledJob.getId(), e);
            }
        });
    }

    props=$3
    fess_parms="-Dfess"

    if [ "x$pidpath" != "x" ]; then
        fess_parms="$fess_parms -Dfess.pidfile=$pidpath"
    fi

    # Make sure we don't use any predefined locale, as we check some exception message strings and rely on english language
    # As those strings are created by the OS, they are dependent on the configured locale
    LANG=en_US.UTF-8
    LC_ALL=en_US.UTF-8

    export HOSTNAME=`hostname -s`

        try (InputStream is = getClass().getResourceAsStream(resource)) {
            return new PluginDescriptorBuilder().build(is, null);
        }
    }

    @Test
    void testBuildReader() throws Exception {
        PluginDescriptor pd = build("/plugin.xml");

        assertEquals("org.apache.maven.plugins", pd.getGroupId());
        assertEquals("maven-jar-plugin", pd.getArtifactId());

                log.warn("Tree was not properly released, performing emergency cleanup: " + this);
                emergencyCleanup();
            }
        } catch (Exception e) {
            log.error("Error during tree finalization", e);
        } finally {
            super.finalize();
        }
    }

    /**

      }
    }
  }

  // Relies on the correctness of isPowerOfTwo(BigInteger).
  public void testLog2Exact() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      // We only expect an exception if x was not a power of 2.
      boolean isPowerOf2 = BigIntegerMath.isPowerOfTwo(x);
      try {
        assertEquals(x, ZERO.setBit(BigIntegerMath.log2(x, UNNECESSARY)));
        assertTrue(isPowerOf2);

    @Mock
    private Configuration config;

    @Mock
    private CIFSContext context;

    @Mock
    private SmbTransportImpl transport;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);
        when(session.getConfig()).thenReturn(config);
        when(session.getContext()).thenReturn(context);
        when(session.getTransport()).thenReturn(transport);

    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {

  private NavigableMap<K, V> navigableMap;
  private List<Entry<K, V>> entries;
  private Entry<K, V> a;
  private Entry<K, V> b;
  private Entry<K, V> c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableMap = (NavigableMap<K, V>) getMap();
    entries =
        copyToList(
            getSubjectGenerator()

  private NavigableSet<E> navigableSet;
  private List<E> values;
  private E a;
  private E b;
  private E c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableSet = (NavigableSet<E>) getSet();
    values =
        copyToList(
            getSubjectGenerator()