return true;
            }
            Type[] actualTypes = parameterizedType.getActualTypeArguments();
            Type[] typeParameters = ((Class<?>) parameterizedType.getRawType()).getTypeParameters();
            for (int i = 0; i < typeParameters.length; i++) {
                Type firstActualInTypeChain = collectedTypeParameters.getOrDefault(actualTypes[i], actualTypes[i]);

            final Type[] actualTypes = parameterizedType.getActualTypeArguments();
            for (int i = 0; i < actualTypes.length; ++i) {
                map.put(typeVariables[i], actualTypes[i]);
            }
        }
    }

    /**
     * <code>type</code>の実際の型を返します。
     * <ul>

			isNotNil: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			i = 0
			actualBytes, actualErr := readHttpWithRetries(tt.httpRetries, tt.args.duration, tt.args.u, tt.args.attempts)

			if tt.isNotNil {
				assert.Nil(t, actualErr)
				assert.NotNil(t, actualBytes)
			} else {
				if tt.expectedErr != nil {
					assert.Equal(t, tt.expectedErr, actualErr)
				} else {

 */

package org.gradle.kotlin.dsl.support

import kotlin.reflect.KClass


fun illegalElementType(container: Any, name: String, expectedType: KClass<*>, actualType: KClass<*>) =
    IllegalArgumentException(
        "Element '$name' of type '${actualType.java.name}' from container '$container' cannot be cast to '${expectedType.qualifiedName}'."
    )


internal
fun internalError(): Nothing =

			rt.buf = bytes.NewBufferString("")
			printConfiguration(rt.cfg, rt.buf, &output.TextPrinter{})
			actualBytes := rt.buf.Bytes()
			if !bytes.Equal(actualBytes, rt.expectedBytes) {
				t.Errorf(
					"failed PrintConfiguration:\n\texpected: %q\n\t  actual: %q",
					string(rt.expectedBytes),
					string(actualBytes),
				)
			}
		})
	}

			rt.buf = bytes.NewBufferString("")
			logDryRunAction(rt.action, rt.buf, DefaultMarshalFunc)
			actualBytes := rt.buf.Bytes()

			if !bytes.Equal(actualBytes, rt.expectedBytes) {
				t.Errorf(
					"failed LogDryRunAction:\n\texpected bytes: %q\n\t  actual: %q",
					rt.expectedBytes,
					actualBytes,
				)
			}
		})
	}
}

func TestDiscoveryServerVersion(t *testing.T) {

    action: String,
    baseType: KClass<*>,
    actualType: Class<*>,
    documentationSection: DocumentationSection = DocumentationSection.RequirementsDisallowedTypes,
    appendix: StructuredMessageBuilder = {}
) {
    logUnsupported(action, documentationSection, appendix) {
        text(" object of type ")
        reference(actualType)
        text(", a subtype of ")
        reference(baseType)
        text(",")

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify
    byte[] actualBytes = Files.toByteArray(file);
    assertTrue(Arrays.equals(expectedBytes, actualBytes));
  }

  public void testMap_readWrite_creates() throws IOException {
    // Test data
    int size = 1024;
    byte[] expectedBytes = newPreFilledByteArray(1024);

fun KType.hasCompatibleTypeArguments(api: KType) =
    arguments.size == api.arguments.size && arguments.indices.all { idx ->
        val expectedType = arguments[idx].type
        val actualType = api.arguments[idx].type
        expectedType?.let { e ->
            actualType?.let { a -> e.isTypeArgumentCompatibleWith(a) }
        } ?: false
    }


private
fun KType.isTypeArgumentCompatibleWith(api: KType) =

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify
    byte[] actualBytes = Files.toByteArray(file);
    assertTrue(Arrays.equals(expectedBytes, actualBytes));
  }

  public void testMap_readWrite_creates() throws IOException {
    // Test data
    int size = 1024;
    byte[] expectedBytes = newPreFilledByteArray(1024);