val internalType = SchemaType.of<InternalType>()
        assertThat(
            accessibilityFor(
                internalType,
                classPath = jarClassPathWith(InternalType::class)
            ),
            equalTo(inaccessible(internalType, InaccessibilityReason.NonPublic(internalType.kotlinString)))
        )
    }

    @Test

// decode all of the external types listed, and also decode them into the given
// object. (Will modify internalObject.) (Assumes JSON serialization.)
// TODO: verify that the correct external version is chosen on encode...
func CheckCodec(c Codec, internalType Object, externalTypes ...schema.GroupVersionKind) error {
	if _, err := Encode(c, internalType); err != nil {

    def collectionPath = ModelPath.path("collection")
    def internalType
    def internalTypeSchema
    def collectionProperty
    ModelType<C> collectionType
    private ModelReference<C> reference

    abstract Class<?> holderType()

    C checkable(List<T> list) {
        list
    }

    def setup() {
        internalType = holderType()
        internalTypeSchema = schemaStore.getSchema(internalType)

	}
	for _, r := range extractor.PodSpecResources() {
		internalType, ok := internalTypes[r]
		if !ok {
			t.Errorf("no internal type registered for %s", r.String())
			continue
		}
		externalType, err := convert(internalType)
		if err != nil {
			t.Errorf("error converting %T: %v", internalType, err)
			continue
		}
		_, _, err = extractor.ExtractPodSpec(externalType)
		if err != nil {

            superTypeStack.addSuperTypesOf(superType.delegate)
        }
        return true
    }

    private
    fun typeForInternalName(internalType: String): ApiType? =
        context.type(sourceNameOfBinaryName(binaryNameOfInternalName(internalType)))

    private
    val hasSuperType: Boolean by unsafeLazy {
        delegate.interfaces.isNotEmpty() || delegate.superName != null
    }

    private