/*
  Java gfx-test framework

   Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016  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 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 BitBltUsingBgColor extends GfxTest
{

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

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltEmptyBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithEmptyImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

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

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

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltCheckerBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithCheckerImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalCheckerBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalCheckerImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

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

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltGridBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithGridImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalGridBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalGridImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontal color stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalColorStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalColorStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for vertical color stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalColorStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalColorStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for diagonal color stripes buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltDiagonalColorStripesBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithDiagonalColorStripesImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for black and white dots buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltBWDotsBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithBWDotsImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

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

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for color dots buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltColorDotsBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithColorDotsImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGrayscale gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGrayscaleGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGrayscale gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGrayscaleGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGrayscaleGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalRed gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalRedGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalRedGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalRed gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalRedGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalRedGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalGreen gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalGreenGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalGreen gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalGreenGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalGreenGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalBlue gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalBlueGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalBlue gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalBlueGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalBlueGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalCyan gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalCyanGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalCyan gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalCyanGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalCyanGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalMagenta gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalMagentaGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalMagenta gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalMagentaGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalMagentaGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for horizontalYellow gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltHorizontalYellowGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithHorizontalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for verticalYellow gradient buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltVerticalYellowGradientBufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithVerticalYellowGradientImage(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #1 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture1BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture1Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #2 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture2BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture2Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #3 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture3BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture3Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #4 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture4BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture4Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #5 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture5BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture5Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 buffered image with type {@link BufferedImage#TYPE_3BYTE_BGR}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageType3ByteBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_3BYTE_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageType4ByteABGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageType4ByteABGR_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_4BYTE_ABGR_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeIntARGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeIntARGB_Pre(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_INT_ARGB_PRE, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeIntBGR(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_INT_BGR, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeIntRGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_INT_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeByteBinary(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_BYTE_BINARY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeByteGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_BYTE_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeByteIndexed(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_BYTE_INDEXED, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeUshort555RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_USHORT_555_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeUshort565RGB(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_USHORT_565_RGB, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 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
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeUshortGray(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_USHORT_GRAY, backgroundColor);
    }

    /**
     * Test basic BitBlt operation for texture RGB pattern #6 buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     *
     * @param image
     *            image to be used as a destination for BitBlt-type operations
     * @param graphics2d
     *            graphics canvas
     * @param backgroundColor
     *            background color
     * @return test result status - PASSED, FAILED or ERROR
     */
    private TestResult doBitBltRGBTexture6BufferedImageTypeCustom(TestImage image, Graphics2D graphics2d,
                    Color backgroundColor)
    {
        return CommonBitmapOperations.doBitBltTestWithRGBTexture6Image(image, graphics2d, BufferedImage.TYPE_CUSTOM, backgroundColor);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.black);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.blue);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.green);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.cyan);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.red);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.magenta);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.yellow);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType3ByteBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType3ByteBGR(image, graphics2d, Color.white);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.black);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.blue);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.green);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.cyan);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.red);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.magenta);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.yellow);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR(image, graphics2d, Color.white);
    }

    /**
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltEmptyBufferedImageType4ByteABGR_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltEmptyBufferedImageTypeIntBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeIntRGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntRGB(image, graphics2d, Color.white);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.black);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.blue);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.green);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.cyan);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.red);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.magenta);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.yellow);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB(image, graphics2d, Color.white);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.blue);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltEmptyBufferedImageTypeIntARGB_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltEmptyBufferedImageTypeByteBinaryBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteBinary(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeByteGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltEmptyBufferedImageTypeByteIndexedBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeByteIndexed(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort555RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort555RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltEmptyBufferedImageTypeUshort565RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshort565RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeUshortGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeUshortGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for empty buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltEmptyBufferedImageTypeCustomBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltEmptyBufferedImageTypeCustom(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType3ByteBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltCheckerBufferedImageType4ByteABGR_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltCheckerBufferedImageTypeIntBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeIntRGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltCheckerBufferedImageTypeIntARGB_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltCheckerBufferedImageTypeByteBinaryBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeByteGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltCheckerBufferedImageTypeByteIndexedBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort555RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltCheckerBufferedImageTypeUshort565RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeUshortGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltCheckerBufferedImageTypeCustomBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltCheckerBufferedImageTypeCustom(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for BltDiagonalGrid 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType3ByteBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType3ByteBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltDiagonalCheckerBufferedImageTypeIntBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntRGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntRGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteBinaryBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteBinary(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeByteIndexedBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeByteIndexed(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort555RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort555RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshort565RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshort565RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeUshortGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeUshortGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal checker buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltDiagonalCheckerBufferedImageTypeCustomGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalCheckerBufferedImageTypeCustom(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType3ByteBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType3ByteBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltGridBufferedImageType4ByteABGR_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_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 testBitBltGridBufferedImageTypeIntBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_RGB}.
     * 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 testBitBltGridBufferedImageTypeIntRGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntRGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGBbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_INT_ARGB_PRE}.
     * 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 testBitBltGridBufferedImageTypeIntARGB_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeIntARGB_Pre(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_BINARY}.
     * 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 testBitBltGridBufferedImageTypeByteBinaryBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteBinary(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeByteGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_INDEXED}.
     * 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 testBitBltGridBufferedImageTypeByteIndexedBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeByteIndexed(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_555_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort555RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort555RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_565_RGB}.
     * 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 testBitBltGridBufferedImageTypeUshort565RGBBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshort565RGB(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_BYTE_GRAY}.
     * 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 testBitBltGridBufferedImageTypeUshortGrayBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeUshortGray(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_USHORT_GRAY}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for grid buffered image with type {@link BufferedImage#TYPE_CUSTOM}.
     * 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 testBitBltGridBufferedImageTypeCustomBackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltGridBufferedImageTypeCustom(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType3ByteBGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType3ByteBGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGRbackgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR(image, graphics2d, Color.white);
    }

    /**
     * Test basic BitBlt operation for diagonal grid 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundBlack(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.black);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundBlue(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.blue);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundGreen(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.green);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundCyan(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.cyan);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundRed(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.red);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundMagenta(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.magenta);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundYellow(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.yellow);
    }

    /**
     * Test basic BitBlt operation for diagonal grid buffered image with type {@link BufferedImage#TYPE_4BYTE_ABGR_Pre}.
     * 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 testBitBltDiagonalGridBufferedImageType4ByteABGR_Pre_backgroundWhite(TestImage image, Graphics2D graphics2d)
    {
        return doBitBltDiagonalGridBufferedImageType4ByteABGR_Pre(image, graphics2d, Color.white);
    }

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

}