sourceFile = "text_test.ai"
        outputFile = "text_test.png"

        with AiImage.load(sourceFile) as image:
            image.save(outputFile, PngOptions())

        inputFile = "Mixer_ipad_Hand_W_crash.psd"
        outputFile = "output.psd"
		
        loadOpt = PsdLoadOptions()
        loadOpt.data_recovery_mode = DataRecoveryMode.MAXIMAL_RECOVER
        with PsdImage.load(inputFile, loadOpt) as img:
            psdImage = cast(PsdImage, img)
            layer = cast(SmartObjectLayer, psdImage.layers[3])
            resource = cast(SoLdResource, layer.resources[9])

            struct1 = cast(DescriptorStructure, resource.items[15])
            struct2 = cast(ListStructure, struct1.structures[5])
            struct3 = cast(DescriptorStructure, struct2.types[0])
            struct4 = cast(DescriptorStructure, struct3.structures[6])
            struct5 = cast(ReferenceStructure, struct4.structures[8])
            nameStructure = cast(NameStructure, struct5.items[0])

            assert nameStructure is not None
            assert nameStructure.length == 37
            assert nameStructure.value == "None\x00"

            psdImage.save(outputFile)

        sourceFile = "rect2_color.ai"
        outPng_WithAlpha_Back_White = "output_WithAlpha_Back_White.png"
        outPng_WithAlpha_Back_Transparent = "output_WithAlpha_Back_Transparent.png"
        outPng_NoAlpha_Back_Transparent = "output_NoAlpha_Back_Transparent.png"
        outGif_Back_Transparent = "output_Back_Transparent.gif"
        outGif_Back_White = "output_Back_White.gif"

        with AiImage.load(sourceFile) as image:
            # AiImage.BackgroundColor = White, Png file with Alpha
            # We should get White background
            pngOpt = PngOptions()
            pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
            image.save(outPng_WithAlpha_Back_White, pngOpt)

            # AiImage.BackgroundColor = Transparent, Png file with Alpha
            # We should get Transparent background
            image.background_color = Color.transparent
            image.save(outPng_WithAlpha_Back_Transparent, pngOpt)

            # AiImage.BackgroundColor = Transparent, Png file without Alpha
            # We should get black background
            image.save(outPng_NoAlpha_Back_Transparent, PngOptions())

            # AiImage.BackgroundColor = Transparent, Gif file
            # We should get black background
            gifOpt = GifOptions()
            gifOpt.do_palette_correction = False
            image.save(outGif_Back_Transparent, gifOpt)

            # AiImage.BackgroundColor = White, Gif file
            # We should get White background
            image.background_color = Color.white
            image.save(outGif_Back_White, gifOpt)

        sourceFile = "2503.psd"
        outputFile = "out_2503.png"

        psdOpt = PsdLoadOptions()
        psdOpt.load_effects_resource = True

        pngOpt = PngOptions()
        pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

        with PsdImage.load(sourceFile, psdOpt) as image:
            image.save(outputFile, pngOpt)

        srcFile = "2512.psd"
        outputFile = "out_2512.png"

        psdOpt = PsdLoadOptions()
        psdOpt.load_effects_resource = True

        with PsdImage.load(srcFile, psdOpt) as img:
            psdImage = cast(PsdImage, img)
            layer1 = psdImage.layers[1]
            layer1.blending_options.are_effects_enabled = False

            pngOpt = PngOptions()
            pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

            # The result should contain only layer pixels, without reserved for effects bounds.
            layer1.save(outputFile, pngOpt)

        sourceFile = "2514.psd"
        outputFile = "out_2514.png"

        psdOpt = PsdLoadOptions()
        psdOpt.load_effects_resource = True

        pngOpt = PngOptions()
        pngOpt.color_type = PngColorType.TRUECOLOR_WITH_ALPHA

        with PsdImage.load(sourceFile, psdOpt) as img:
            psdImage = cast(PsdImage, img)
            psdImage.save(outputFile, pngOpt)