* @param phase
     * @return
     */
    public Lifecycle get(String phase) {
        return getPhaseToLifecycleMap().get(phase);
    }

    /**
     * We use this to map all phases to the lifecycle that contains it. This is used so that a user can specify the
     * phase they want to execute and we can easily determine what lifecycle we need to run.
     *
     * @return A map of lifecycles, indexed on id
     */

        assertThat(set.size(), is(2));
        assertThat(set.contains(ResultPrinter.class.getName()), is(true));
        assertThat(set.contains(TestRunner.class.getName()), is(true));
        assertThat(set.contains("junit.textui.package-info"), is(false));
        assertThat(set.contains(junit.extensions.TestDecorator.class.getName()), is(not(true)));
    }

        boolean isWindows = actualOsName.contains(FAMILY_WINDOWS);
        boolean is9x = false;
        boolean isNT = false;
        if (isWindows) {
            // there are only four 9x platforms that we look for
            is9x = (actualOsName.contains("95")
                    || actualOsName.contains("98")
                    || actualOsName.contains("me")

    Session session;

    @Inject
    SessionScope sessionScope;

    @Inject
    PlexusContainer container;

    @Test
    void testProxiedSessionScopedBean() throws ComponentLookupException {
        ComponentLookupException e =
                assertThrows(ComponentLookupException.class, () -> container.lookup(MySingletonBean2.class));
        assertTrue(e.getMessage().matches("[\\s\\S]*: Can not set .* field .* to [\\s\\S]*"));

            }
        }

        @Override
        public boolean contains(Version version) {
            if (version instanceof DefaultVersion) {
                return delegate.containsVersion(((DefaultVersion) version).delegate);
            } else {
                return contains(new DefaultVersion(versionScheme, version.asString()));
            }
        }

        @Override

    void testCompileClasspathTransform() throws Exception {
        ClasspathContainer res;

        res = transform.transform(graph, ArtifactScopeEnum.compile, false);

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

        Map<AccessorKey, ReplacedAccessor> keptAccessors = new HashMap<>(oldAccessorsOfUpgradedProperties);
        keptAccessors.entrySet().removeIf(e -> {
            if (seenUpgradedAccessorsChanges.contains(e.getKey())) {
                return true;
            }
            ReplacedAccessor accessor = e.getValue();
            return accessor.getBinaryCompatibility() == BinaryCompatibility.ACCESSORS_KEPT;
        });

    private final String roleHint;

    @Inject
    private ArtifactFactory artifactFactory;

    private ConflictResolver conflictResolver;

    @Inject
    protected PlexusContainer container;

    // constructors -----------------------------------------------------------

    public AbstractConflictResolverTest(String roleHint) throws Exception {
        this.roleHint = roleHint;
    }

                    .map(l -> {
                        boolean global;
                        String splitExpr;
                        if (l.contains(">>")) {
                            global = true;
                            splitExpr = ">>";
                        } else if (l.contains(">")) {
                            global = false;
                            splitExpr = ">";
                        } else {

    assertTrue(Arrays.equals(expectedArray2, array2));
  }

  public void testPrependZeroElements() {
    String[] result = ObjectArrays.concat("foo", new String[] {});
    assertThat(result).asList().contains("foo");
  }

  public void testPrependOneElement() {
    String[] result = ObjectArrays.concat("foo", new String[] {"bar"});
    assertThat(result).asList().containsExactly("foo", "bar").inOrder();
  }