/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
package com.nokia.openlcdui.mt.graphics;

import junit.framework.*;

import java.io.IOException;

import javax.microedition.lcdui.*;

import com.nokia.openlcdui.mt.SWTTestCase;

import com.nokia.mid.ui.DirectGraphics;
import com.nokia.mid.ui.DirectUtils;

public class DirectGraphicsTest extends SWTTestCase
{

    private TestCanvas testCanvas;

    /**
     * Constructor.
     */
    public DirectGraphicsTest()
    {
    }

    /**
     * Constructor.
     *
     * @param sTestName Test name.
     * @param rTestMethod Test method.
     */
    public DirectGraphicsTest(String sTestName)
    {
        super(sTestName);
    }

    protected void setUp() throws Exception
    {
        testCanvas = new TestCanvas();
        Display.getDisplay(getMIDlet()).setCurrent(testCanvas);
    }

    protected void tearDown() throws Exception
    {
        testCanvas = null;
    }

    /**
     * To create the test suite. You need to add a new aSuite.addTest entry for
     * any new test methods.
     *
     * @return new testsuite.
     */
    public static Test suite()
    {
        TestSuite suite = new TestSuite();

        java.util.Vector methodNames;
        java.util.Enumeration e;

        // Add widget tests
        methodNames = DirectGraphicsTest.methodNames();
        e = methodNames.elements();
        while(e.hasMoreElements())
        {
            suite.addTest(new DirectGraphicsTest((String)e.nextElement()));
        }

        return suite;
    }

    public static java.util.Vector methodNames()
    {
        java.util.Vector methodNames = new java.util.Vector();
        methodNames.addElement("testGraphics");
        methodNames.addElement("testDrawImage");
        methodNames.addElement("testDrawGetPixels");
        methodNames.addElement("testDrawGetPixelsByte");
        methodNames.addElement("testDrawGetPixelsShort");
        methodNames.addElement("testDrawGetPixelsShort555");
        methodNames.addElement("testDrawGetPixelsShort444");
        methodNames.addElement("testDrawGetPixelsShort4444");
        methodNames.addElement("testDrawPolygon");
        methodNames.addElement("testDrawTriangle");
        methodNames.addElement("testFillPolygon");
        methodNames.addElement("testFillTriangle");
        methodNames.addElement("testGetNativePixelFormat");
        methodNames.addElement("testSetGetARGBColor");
        return methodNames;
    }

    protected void runTest() throws Throwable
    {
        if(getName().equals("testGraphics")) testCanvas.runTest(TestCanvas.TEST_GRAPHICS);
        else if(getName().equals("testDrawImage")) testCanvas.runTest(TestCanvas.TEST_DRAWIMAGE);
        else if(getName().equals("testDrawGetPixels")) testCanvas.runDrawGetPixels();
        else if(getName().equals("testDrawGetPixelsByte")) testCanvas.runDrawGetPixelsByte();
        else if(getName().equals("testDrawGetPixelsShort")) testCanvas.runDrawGetPixelsShort();
        else if(getName().equals("testDrawGetPixelsShort555")) testCanvas.runDrawGetPixelsShort555();
        else if(getName().equals("testDrawGetPixelsShort444")) testCanvas.runDrawGetPixelsShort444();
        else if(getName().equals("testDrawGetPixelsShort4444")) testCanvas.runDrawGetPixelsShort4444();
        else if(getName().equals("testDrawPolygon")) testCanvas.runTest(TestCanvas.TEST_DRAWPOLYGON);
        else if(getName().equals("testDrawTriangle")) testCanvas.runTest(TestCanvas.TEST_DRAWTRIANGLE);
        else if(getName().equals("testFillPolygon")) testCanvas.runTest(TestCanvas.TEST_FILLPOLYGON);
        else if(getName().equals("testFillTriangle")) testCanvas.runTest(TestCanvas.TEST_FILLTRIANGLE);
        else if(getName().equals("testGetNativePixelFormat")) testCanvas.runTest(TestCanvas.TEST_GETNATIVEPIXELFORMAT);
        else if(getName().equals("testSetGetARGBColor")) testCanvas.runTest(TestCanvas.TEST_SETGETARGBCOLOR);
        else super.runTest();
    }

    class TestCanvas extends Canvas
    {

        static final int TEST_NONE = 0;
        static final int TEST_GRAPHICS = 1;
        static final int TEST_DRAWIMAGE = 2;
        static final int TEST_DRAWPIXELS = 3;
        static final int TEST_GETPIXELS = 4;
        static final int TEST_DRAWPOLYGON = 5;
        static final int TEST_DRAWTRIANGLE = 6;
        static final int TEST_FILLPOLYGON = 7;
        static final int TEST_FILLTRIANGLE = 8;
        static final int TEST_GETNATIVEPIXELFORMAT = 9;
        static final int TEST_SETGETARGBCOLOR = 10;
        static final int TEST_DRAWPIXELSBYTE = 11;
        static final int TEST_GETPIXELSBYTE = 12;
        static final int TEST_DRAWPIXELSSHORT = 13;
        static final int TEST_GETPIXELSSHORT = 14;
        static final int TEST_DRAWPIXELSSHORT555 = 15;
        static final int TEST_GETPIXELSSHORT555 = 16;
        static final int TEST_DRAWPIXELSSHORT444 = 17;
        static final int TEST_GETPIXELSSHORT444 = 18;
        static final int TEST_DRAWPIXELSSHORT4444 = 19;
        static final int TEST_GETPIXELSSHORT4444 = 20;

        private int testMode = TEST_NONE;
        private boolean passed;
        private String failMsg;

        private int testWidth = 50;
        private int testHeight = 50;
        private int[] rgbDataSet = new int[testWidth * testHeight];
        private int[] rgbDataGet = new int[testWidth * testHeight];
        private short[] sRgbDataSet = new short[testWidth * testHeight];
        private short[] sRgbDataSet4444 = new short[testWidth * testHeight];
        private short[] sRgbDataGet = new short[testWidth * testHeight];
        private byte[] bRgbDataSet = new byte[testWidth * testHeight];
        private byte[] bRgbDataGet = new byte[testWidth * testHeight];
        private byte[] bRgbDataMaskSet = new byte[testWidth * testHeight];
        private byte[] bRgbDataMaskGet = new byte[testWidth * testHeight];

        public TestCanvas()
        {
            for(int i = 0; i< rgbDataSet.length; i++)
            {
                rgbDataSet[i] = 0xFFFF0000;
                bRgbDataSet[i] = (byte) 0xFF;
                bRgbDataMaskSet[i] = (byte) 0xFF;
                sRgbDataSet[i] = (short) 0x0;
                sRgbDataSet4444[i] = (short) 0xFC00;
            }
            addCommand(new Command("back", "back", Command.BACK, 0));
        }

        /**
         * Set failing message.
         */
        private void setFailMessage(String msg)
        {
            failMsg = msg;
            passed = (failMsg == null);
        }

        /**
         * Run the specified test.
         */
        public void runTest(int test)
        {
            setFailMessage(null);
            doRunTest(test);
            assertTrue(failMsg, passed);
        }

        private void doRunTest(int test)
        {
            testMode = test;
            repaint();
            serviceRepaints();
        }

        public void runDrawGetPixels()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELS);
            doRunTest(TEST_GETPIXELS);
            // TODO: QT bug: first getPixels() call returns invalid values
            setFailMessage(null);
            doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }

        public void runDrawGetPixelsByte()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELSBYTE);
            doRunTest(TEST_GETPIXELSBYTE);

            //setFailMessage(null);
            //doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }

        public void runDrawGetPixelsShort()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELSSHORT);
            doRunTest(TEST_GETPIXELSSHORT);

            //setFailMessage(null);
            //doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }
        public void runDrawGetPixelsShort555()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELSSHORT555);
            doRunTest(TEST_GETPIXELSSHORT555);

            //setFailMessage(null);
            //doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }
        public void runDrawGetPixelsShort444()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELSSHORT444);
            doRunTest(TEST_GETPIXELSSHORT444);

            //setFailMessage(null);
            //doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }
        public void runDrawGetPixelsShort4444()
        {
            setFailMessage(null);
            doRunTest(TEST_DRAWPIXELSSHORT4444);
            doRunTest(TEST_GETPIXELSSHORT4444);

            //setFailMessage(null);
            //doRunTest(TEST_GETPIXELS);
            assertTrue(failMsg, passed);
        }


        protected void paint(Graphics g)
        {
            try
            {
                DirectGraphics dg = DirectUtils.getDirectGraphics(g);
                switch(testMode)
                {
                case TEST_NONE:
                    break;
                case TEST_GRAPHICS:
                    if(dg == null)
                    {
                        fail("DirectGraphics object is null in paint()");
                    }
                    break;
                case TEST_DRAWIMAGE:
                    testDrawImage(dg);
                    break;
                case TEST_DRAWPIXELS:
                    testDrawPixels(dg);
                    break;
                case TEST_DRAWPIXELSBYTE:
                    testDrawPixelsByte(dg);
                    break;
                case TEST_GETPIXELS:
                    testGetPixels(dg);
                    break;
                case TEST_DRAWPIXELSSHORT:
                    testDrawPixelsShort(dg);
                    break;
                case TEST_GETPIXELSBYTE:
                    testGetPixelsByte(dg);
                    break;
                case TEST_DRAWPIXELSSHORT555:
                    testDrawPixelsShort555(dg);
                    break;
                case TEST_GETPIXELSSHORT555:
                    testGetPixelsShort555(dg);
                    break;
                case TEST_DRAWPIXELSSHORT444:
                    testDrawPixelsShort444(dg);
                    break;
                case TEST_GETPIXELSSHORT444:
                    testGetPixelsShort444(dg);
                    break;
                case TEST_DRAWPIXELSSHORT4444:
                    testDrawPixelsShort4444(dg);
                    break;
                case TEST_GETPIXELSSHORT4444:
                    testGetPixelsShort4444(dg);
                    break;
                case TEST_GETPIXELSSHORT:
                    testGetPixelsShort(dg);
                    break;
                case TEST_DRAWPOLYGON:
                    testDrawPolygon(dg);
                    break;
                case TEST_DRAWTRIANGLE:
                    testDrawTriangle(dg);
                    break;
                case TEST_FILLPOLYGON:
                    testFillPolygon(dg);
                    break;
                case TEST_FILLTRIANGLE:
                    testFillTriangle(dg);
                    break;
                case TEST_GETNATIVEPIXELFORMAT:
                    testGetNativePixelFormat(dg);
                    break;
                case TEST_SETGETARGBCOLOR:
                    testSetGetAlphaColor(dg);
                    break;
                default:
                }
            }
            /*catch (AssertionFailedException afe) {
                setFailMessage(afe.getMessage());
            }*/
            catch(Exception e)
            {
                setFailMessage(e.getMessage());
            }
            finally
            {
                testMode = TEST_NONE;
            }
        }

        private void testDrawImage(DirectGraphics dg) throws IOException
        {
            Image testImage = Image.createImage("image1.jpg");
            try
            {
                dg.drawImage(null, 0, 0, 0, 0);
                fail("NullPointerException should be thrown on null image");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }

            try
            {
                dg.drawImage(testImage, 0, 0, 0, -1);
                fail("IllegalArgumentException should be thrown on invalid manipulation");
            }
            catch(IllegalArgumentException iae)
            {
                // Ok
            }

            try
            {
                dg.drawImage(testImage, 0, 0, -1, 0);
                fail("IllegalArgumentException should be thrown on invalid anchor");
            }
            catch(IllegalArgumentException iae)
            {
                // Ok
            }

            dg.drawImage(testImage, 0, 0, 0, 0);
            dg.drawImage(testImage, 0, 0, 0, DirectGraphics.ROTATE_90);
            dg.drawImage(testImage, 0, 0, 0,
                         DirectGraphics.ROTATE_90 | DirectGraphics.FLIP_HORIZONTAL);
        }

        private void testDrawPixels(DirectGraphics dg)
        {
            try
            {
                dg.drawPixels((int[]) null, false, 0, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_INT_888_RGB);
                fail("NullPointerException should be thrown on null array - drawPixels");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(rgbDataSet, false, -1, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_INT_888_RGB);
                fail("ArrayIndexOutOfBoundsException should be thrown on invalid offset");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(rgbDataSet, false, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              -1, DirectGraphics.TYPE_INT_888_RGB);
                fail("IllegalArgumentException should be thrown on invalid manipulation");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(rgbDataSet, false, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              0, -1);
                fail("IllegalArgumentException should be thrown on invalid format");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }
            // draw image to GC
            dg.drawPixels(rgbDataSet, false, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_INT_888_RGB);
        }

        private void testDrawPixelsByte(DirectGraphics dg)
        {
            try
            {
                dg.drawPixels((byte[]) null, (byte[]) null, 0, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_BYTE_1_GRAY);
                fail("NullPointerException should be thrown on null array - drawPixels");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }

            try
            {
                dg.drawPixels(bRgbDataSet, bRgbDataMaskSet, -1, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_BYTE_1_GRAY);
                fail("ArrayIndexOutOfBoundsException should be thrown on invalid offset");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }

            try
            {
                dg.drawPixels(bRgbDataSet, bRgbDataMaskSet, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              -1, DirectGraphics.TYPE_BYTE_1_GRAY);
                fail("IllegalArgumentException should be thrown on invalid manipulation");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }

            try
            {
                dg.drawPixels(bRgbDataSet, bRgbDataMaskSet, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              0, -1);
                fail("IllegalArgumentException should be thrown on invalid format");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }

            // draw image to GC
            dg.drawPixels(bRgbDataSet, bRgbDataMaskSet, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_BYTE_1_GRAY);


            // while(true);
        }

        private void testDrawPixelsShort(DirectGraphics dg)
        {
            try
            {
                dg.drawPixels((short[]) null, false, 0, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_USHORT_565_RGB);
                fail("NullPointerException should be thrown on null array - drawPixels");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(sRgbDataSet, false, -1, 0,
                              0, 0, 0, 0,
                              0, DirectGraphics.TYPE_USHORT_565_RGB);
                fail("ArrayIndexOutOfBoundsException should be thrown on invalid offset");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(sRgbDataSet, false, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              -1, DirectGraphics.TYPE_USHORT_565_RGB);
                fail("IllegalArgumentException should be thrown on invalid manipulation");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }
            try
            {
                dg.drawPixels(sRgbDataSet, false, 0, testWidth,
                              0, 0, testWidth, testHeight,
                              0, -1);
                fail("IllegalArgumentException should be thrown on invalid format");
            }
            catch(IllegalArgumentException obe)
            {
                // Ok
            }
            // draw image to GC
            dg.drawPixels(sRgbDataSet, false, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_USHORT_565_RGB);
        }

        private void testDrawPixelsShort555(DirectGraphics dg)
        {
            dg.drawPixels(sRgbDataSet, false, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_USHORT_555_RGB);
        }

        private void testGetPixelsShort555(DirectGraphics dg)
        {
            dg.getPixels(sRgbDataGet, 0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_USHORT_555_RGB);

            // compare gotten data with previously set data
            for(int i = 0; i < sRgbDataSet.length; i++)
            {
                if(sRgbDataGet[i] != sRgbDataSet[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + sRgbDataSet[i] + " get " + sRgbDataGet[i]);
                }
            }
        }

        private void testDrawPixelsShort444(DirectGraphics dg)
        {
            dg.drawPixels(sRgbDataSet, false, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_USHORT_444_RGB);
        }

        private void testGetPixelsShort444(DirectGraphics dg)
        {
            dg.getPixels(sRgbDataGet, 0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_USHORT_444_RGB);

            // compare gotten data with previously set data
            for(int i = 0; i < sRgbDataSet.length; i++)
            {
                if(sRgbDataGet[i] != sRgbDataSet[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + sRgbDataSet[i] + " get " + sRgbDataGet[i]);
                }
            }
        }

        private void testDrawPixelsShort4444(DirectGraphics dg)
        {
            dg.drawPixels(sRgbDataSet4444, false, 0, testWidth,
                          0, 0, testWidth, testHeight,
                          0, DirectGraphics.TYPE_USHORT_4444_ARGB);
        }

        private void testGetPixelsShort4444(DirectGraphics dg)
        {
            dg.getPixels(sRgbDataGet, 0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_USHORT_4444_ARGB);

            // compare gotten data with previously set data
            for(int i = 0; i < sRgbDataSet4444.length; i++)
            {
                if(sRgbDataGet[i] != sRgbDataSet4444[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + sRgbDataSet4444[i] + " get " + sRgbDataGet[i]);
                }
            }
        }

        private void testGetPixels(DirectGraphics dg)
        {
            try
            {
                dg.getPixels((int[]) null, 0, 1,
                             0, 0, 1, 1,
                             DirectGraphics.TYPE_INT_888_RGB);
                fail("IllegalArgumentException should be thrown on null array - getPixels");
            }
            catch(IllegalArgumentException iae)
            {
                // Ok
            }

            // get data from GC
            dg.getPixels(rgbDataGet, 0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_INT_888_RGB);

            // compare gotten data with previously set data

            for(int i = 0; i < rgbDataSet.length; i++)
            {
                if(rgbDataGet[i] != rgbDataSet[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + rgbDataSet[i] + " get " + rgbDataGet[i]);
                }
            }
        }

        private void testGetPixelsByte(DirectGraphics dg)
        {
            try
            {
                dg.getPixels((byte[]) null, (byte []) null,0, 1,
                             0, 0, 1, 1,
                             DirectGraphics.TYPE_BYTE_1_GRAY);
                fail("IllegalArgumentException should be thrown on null array - getPixels");
            }
            catch(IllegalArgumentException iae)
            {
                // Ok
            }

            // get data from GC
            dg.getPixels(bRgbDataGet, bRgbDataMaskGet,0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_BYTE_1_GRAY);

            // compare gotten data with previously set data
            for(int i = 0; i < (bRgbDataSet.length / 8); i++)
            {
                if(bRgbDataGet[i] != bRgbDataSet[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + bRgbDataSet[i] + " get " + bRgbDataGet[i]);
                }
                if(i != 0 && ((i % 4) == 0))
                {
                    i = i + 4;
                }
            }

        }

        private void testGetPixelsShort(DirectGraphics dg)
        {
            try
            {
                dg.getPixels((short[]) null, 0, 1,
                             0, 0, 1, 1,
                             DirectGraphics.TYPE_USHORT_565_RGB);
                fail("IllegalArgumentException should be thrown on null array - getPixels");
            }
            catch(IllegalArgumentException iae)
            {
                // Ok
            }

            // get data from GC
            dg.getPixels(sRgbDataGet, 0, testWidth,
                         0, 0, testWidth, testHeight,
                         DirectGraphics.TYPE_USHORT_565_RGB);

            // compare gotten data with previously set data
            for(int i = 0; i < sRgbDataSet.length; i++)
            {
                if(sRgbDataGet[i] != sRgbDataSet[i])
                {
                    fail("RGB Data mismatch at " + i + " : set "
                         + sRgbDataSet[i] + " get " + sRgbDataGet[i]);
                }
            }
        }

        private void testDrawPolygon(DirectGraphics dg)
        {
            try
            {
                dg.drawPolygon(null, 0, null, 0, 1, 0);
                fail("NullPointerException should be thrown on null arrays");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }

            int[] xP = new int[] {10, 20, 30, 40};
            int[] yP = new int[] {40, 30, 20, 10};

            try
            {
                dg.drawPolygon(xP, 0, yP, 0, 5, 0);
                fail("ArrayIndexOutOfBoundsException should be thrown on "
                     + "invalid nPoints");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }

            try
            {
                dg.drawPolygon(xP, 4, yP, 3, 4, 0);
                fail("ArrayIndexOutOfBoundsException should be thrown on "
                     + "invalid offsets");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }

            dg.drawPolygon(xP, 0, yP, 0, 4, 0);
            dg.drawPolygon(xP, 1, yP, 1, 3, 0);
            dg.drawPolygon(xP, 2, yP, 2, 2, 0);
        }

        private void testDrawTriangle(DirectGraphics dg)
        {
            dg.drawTriangle(10, 10, 20, 20, 30, 0, 0);
        }

        private void testFillPolygon(DirectGraphics dg)
        {
            try
            {
                dg.fillPolygon(null, 0, null, 0, 1, 0);
                fail("NullPointerException should be thrown on null arrays");
            }
            catch(NullPointerException npe)
            {
                // Ok
            }

            int[] xP = new int[] {10, 20, 30, 40};
            int[] yP = new int[] {40, 30, 20, 10};

            try
            {
                dg.fillPolygon(xP, 0, yP, 0, 5, 0);
                fail("ArrayIndexOutOfBoundsException should be thrown on "
                     + "invalid nPoints");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }

            try
            {
                dg.fillPolygon(xP, 4, yP, 3, 4, 0);
                fail("ArrayIndexOutOfBoundsException should be thrown on "
                     + "invalid offsets");
            }
            catch(ArrayIndexOutOfBoundsException obe)
            {
                // Ok
            }

            dg.fillPolygon(xP, 0, yP, 0, 4, 0);
            dg.fillPolygon(xP, 1, yP, 1, 3, 0);
            dg.fillPolygon(xP, 2, yP, 2, 2, 0);
        }

        private void testFillTriangle(DirectGraphics dg)
        {
            dg.fillTriangle(10, 10, 20, 20, 30, 0, 0);
        }

        private void testGetNativePixelFormat(DirectGraphics dg)
        {
            dg.getNativePixelFormat();
        }

        private void testSetGetAlphaColor(DirectGraphics dg)
        {
            dg.setARGBColor(0xAAFF1166);
            if(dg.getAlphaComponent() != 0xAA)
            {
                fail("Alpha component mismatch");
            }
        }

    }

}