def rawTypeForParameterizedArrayType() {
        type.arrayDimensions = 2
        type.addTypeArg(new TypeMetaData('Type1'))

        expect:
        type.rawType.signature == 'org.gradle.SomeType[][]'
    }

    def rawTypeForParameterizedType() {
        type.addTypeArg(new TypeMetaData('Type1'))
        type.addTypeArg(new TypeMetaData('Type2'))

        expect:
        type.rawType.signature == 'org.gradle.SomeType'
    }

                return (T) new DefaultArtifactResolver();
            } else if (clazz == ArtifactManager.class) {
                return (T) new DefaultArtifactManager(this);
            } else if (clazz == RepositoryFactory.class) {
                return (T) new DefaultRepositoryFactory(new DefaultRemoteRepositoryManager(
                        new DefaultUpdatePolicyAnalyzer(),
                        new DefaultChecksumPolicyProvider(),

        }

        problems.setRootModel(inputModel);

        ModelData resultData = new ModelData(request.getModelSource(), inputModel);
        ModelData superData = new ModelData(null, getSuperModel());

        Collection<String> parentIds = new LinkedHashSet<>();
        List<ModelData> lineage = new ArrayList<>();

        for (ModelData currentData = resultData; currentData != null; ) {

  @GwtIncompatible // NullPointerTester
  public void testNullPointerExceptions() {
    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicInstanceMethods(new FakeTicker());
  }

  @GwtIncompatible // java.time.Duration
  public void testAdvance() {
    FakeTicker ticker = new FakeTicker();
    assertEquals(0, ticker.read());
    assertSame(ticker, ticker.advance(10));
    assertEquals(10, ticker.read());

        return new Result<>(true, model, problems);
    }

    /**
     * New result - determine whether error or success by checking problems for errors
     *
     * @param model
     * @param problems
     */
    public static <T> Result<T> newResult(T model, Iterable<? extends ModelProblem> problems) {
        return new Result<>(hasErrors(problems), model, problems);
    }

public class Lifecycles {

    static Lifecycle.Phase phase(String name) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
    }

    static Lifecycle.Phase phase(String name, Lifecycle.Phase... phases) {
        return new DefaultPhase(name, Collections.emptyList(), Collections.emptyList(), asList(phases));
    }

    @Test
    @DisplayName("readn should handle EOF correctly")
    void testReadnEOF() throws IOException {
        byte[] buffer = new byte[10];
        ByteArrayInputStream bais = new ByteArrayInputStream(new byte[0]);

        int bytesRead = SessionServicePacket.readn(bais, buffer, 0, 5);

        assertEquals(0, bytesRead);
    }

    @Test
    @DisplayName("readn should handle multiple read calls")

    }

    @Test
    void testEqualsNullSafe() {
        assertNotEquals(null, new Model());

        new Model().equals(new Model());
    }

    @Test
    void testEqualsIdentity() {
        Model thing = new Model();
        assertEquals(thing, thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Model().toString());
    }

    @Test
    void testPropertiesClear() {

        return Stream.of(Arguments.of(new byte[0], ""), Arguments.of(new byte[] { (byte) 0x41 }, "QQ=="), // "A"
                Arguments.of(new byte[] { (byte) 0x41, (byte) 0x42 }, "QUI="), // "AB"
                Arguments.of("Man".getBytes(), "TWFu"), // 3 bytes, no padding
                Arguments.of(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00 }, "AAAA"), // all zeros

        MockitoAnnotations.openMocks(this);
        testMessage = new TestServerMessageBlock2(mockConfig);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create with configuration only")
        void testConstructorWithConfig() {
            ServerMessageBlock2 msg = new TestServerMessageBlock2(mockConfig);
            assertNotNull(msg);