/*
  Java gfx-test framework

   Copyright (C) 2012, 2013, 2014, 2015  Red Hat

This file is part of IcedTea.

IcedTea is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

IcedTea is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with IcedTea; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version.
*/

package org.gfxtest.testsuites;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;



import org.gfxtest.framework.CommonBitmapOperations;
import org.gfxtest.framework.GfxTest;
import org.gfxtest.framework.TestImage;
import org.gfxtest.framework.TestResult;
import org.gfxtest.framework.annotations.BitBltOperation;
import org.gfxtest.framework.annotations.BitBltOperations;
import org.gfxtest.framework.annotations.GraphicsPrimitive;
import org.gfxtest.framework.annotations.GraphicsPrimitives;
import org.gfxtest.framework.annotations.RenderStyle;
import org.gfxtest.framework.annotations.RenderStyles;
import org.gfxtest.framework.annotations.TestType;
import org.gfxtest.framework.annotations.TestTypes;
import org.gfxtest.framework.annotations.Transformation;
import org.gfxtest.framework.annotations.Transformations;
import org.gfxtest.framework.annotations.Zoom;



/**
 * This test check the rendering of buffered images (so called bit block
 * transfers or Bit Blt) created by various constructors. Such images are
 * rendered with explicitly set background color with alpha channel which should
 * affect transparent or semi-transparent images.
 * 
 * @author Pavel Tisnovsky
 */
@TestType(TestTypes.RENDER_TEST)
@GraphicsPrimitive(GraphicsPrimitives.COMMON_BITMAP)
@RenderStyle(RenderStyles.NORMAL)
@BitBltOperation(BitBltOperations.BITBLT)
@Transformation(Transformations.NONE)
@Zoom(1)
public class BitBltUsingBgColorAlpha extends GfxTest
{

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_RGB}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageType3ByteRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageType4ByteABGRPre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntARGBPre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, newColor);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor, float alpha)
    {
        Color newColor = calculateTransparentColor(backgroundColor, alpha);
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, newColor);
    }

    /**
     * Calculate color with given alpha value.
     *
     * @param backgroundColor
     *            background color
     * @param alpha
     *            alpha value for background
     */
    private Color calculateTransparentColor(Color backgroundColor, float alpha)
    {
        final float red = backgroundColor.getRed() / 255.0f;
        final float green = backgroundColor.getGreen() / 255.0f;
        final float blue = backgroundColor.getBlue() / 255.0f;
        return new Color(red, green, blue, alpha);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlackAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.black, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlackAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.black, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlackAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.black, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlackAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.black, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlackAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.black, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundRedAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.red, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundRedAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.red, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundRedAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.red, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundRedAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.red, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundRedAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.red, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreenAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.green, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreenAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.green, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreenAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.green, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreenAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.green, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreenAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.green, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlueAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.blue, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlueAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.blue, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlueAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.blue, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlueAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.blue, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlueAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.blue, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellowAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.yellow, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellowAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.yellow, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellowAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.yellow, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellowAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.yellow, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellowAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.yellow, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyanAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.cyan, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyanAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.cyan, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyanAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.cyan, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyanAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.cyan, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyanAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.cyan, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagentaAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.magenta, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagentaAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.magenta, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagentaAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.magenta, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagentaAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.magenta, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagentaAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.magenta, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhiteAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.white, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhiteAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.white, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhiteAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.white, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhiteAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.white, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhiteAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteRGB(image, graphics2d, Color.white, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlackAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlackAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlackAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlackAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlackAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundRedAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundRedAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundRedAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundRedAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundRedAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreenAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreenAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreenAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreenAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreenAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlueAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlueAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlueAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlueAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlueAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellowAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellowAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellowAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellowAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellowAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyanAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyanAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyanAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyanAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyanAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagentaAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagentaAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagentaAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagentaAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagentaAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhiteAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhiteAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhiteAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhiteAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhiteAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPreBackgroundBlackAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.black, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPreBackgroundBlackAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.black, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPreBackgroundBlackAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.black, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPreBackgroundBlackAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.black, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPreBackgroundBlackAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.black, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundRedAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.red, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundRedAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.red, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundRedAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.red, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundRedAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.red, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundRedAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.red, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundGreenAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.green, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundGreenAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.green, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundGreenAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.green, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundGreenAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.green, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundGreenAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.green, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundBlueAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.blue, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundBlueAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.blue, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundBlueAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.blue, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundBlueAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.blue, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundBlueAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.blue, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundYellowAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.yellow, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundYellowAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.yellow, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundYellowAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.yellow, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundYellowAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.yellow, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGRPre}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundYellowAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.yellow, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundCyanAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.cyan, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundCyanAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.cyan, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundCyanAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.cyan, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundCyanAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.cyan, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundCyanAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.cyan, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundMagentaAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.magenta, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundMagentaAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.magenta, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundMagentaAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.magenta, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundMagentaAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.magenta, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundMagentaAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.magenta, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundWhiteAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.white, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundWhiteAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.white, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundWhiteAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.white, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundWhiteAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.white, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageType4ByteABGRPrebackgroundWhiteAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGRPre(image, graphics2d, Color.white, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlackAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlackAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlackAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlackAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlackAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundRedAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundRedAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundRedAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundRedAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundRedAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreenAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreenAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreenAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreenAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreenAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlueAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlueAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlueAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlueAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.blue.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlueAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellowAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellowAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellowAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellowAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.yellow.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellowAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyanAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyanAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyanAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyanAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.cyan.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyanAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagentaAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagentaAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagentaAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagentaAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.magenta.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagentaAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhiteAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhiteAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhiteAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhiteAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB}.
     * Background color is set to Color.white.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhiteAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundBlackAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.black, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundBlackAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.black, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundBlackAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.black, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundBlackAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.black, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.black.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundBlackAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.black, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundRedAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.red, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundRedAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.red, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundRedAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.red, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundRedAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.red, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.red.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundRedAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.red, 1.00f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundGreenAlpha000(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.green, 0.0f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundGreenAlpha025(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.green, 0.25f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundGreenAlpha050(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.green, 0.5f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundGreenAlpha075(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.green, 0.75f);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * Background color is set to Color.green.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @return test result status - PASSED, FAILED or ERROR
     */
    public TestResult testBitBltEmptyBufferedImageTypeIntARGBPreBackgroundGreenAlpha100(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGBPre(image, graphics2d, Color.green, 1.00f);
    }

    /**
     * Entry point to the test suite.
     *
     * @param args not used in this case
     */
    public static void main(String[] args)
    {
        new BitBltUsingBgColorAlpha().runTestSuite(args);
    }
}