/*

* 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 javax.microedition.lcdui.*;

import com.nokia.openlcdui.mt.SWTTestCase;

public class CommandBufferingTest extends SWTTestCase

{

    private Image testImage;

    private final int testImageWidth = 20;

    private final int testImageHeight = 20;

    private int[] pixelData;

    private final int GRAPHICS_SETTINGS_1 = 1;

    private final int GRAPHICS_SETTINGS_2 = 2;

    private final int WHITE = 0x00ffffff;

    private final int BLACK = 0x00000000;

    private final int RED =   0x00ff0000; 

    private final int GREEN = 0x0000ff00;

    private final int BLUE =  0x000000ff; 

    /**

     * Constructor.

     */

    public CommandBufferingTest()

    {

    }

    /**

     * Constructor.

     *

     * @param sTestName Test name.

     * @param rTestMethod Test method.

     */

    public CommandBufferingTest(String sTestName)

    {

        super(sTestName);

    }

    protected void setUp() throws Exception

    {

        super.setUp();

        testImage = Image.createImage(testImageWidth, testImageHeight);

        pixelData = new int[testImageWidth*testImageHeight];

    }

    protected void tearDown() throws Exception

    {

        super.tearDown();

        testImage = null;

        pixelData = 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 = CommandBufferingTest.methodNames();

        e = methodNames.elements();

        while(e.hasMoreElements())

        {

            suite.addTest(new CommandBufferingTest((String)e.nextElement()));

        }

        return suite;

    }

    public static java.util.Vector methodNames()

    {

        java.util.Vector methodNames = new java.util.Vector();

        methodNames.addElement("testDefaultValues");

        methodNames.addElement("testClip1");

        methodNames.addElement("testClip2");

        methodNames.addElement("testDrawArc");

        methodNames.addElement("testDrawImage");

        methodNames.addElement("testDrawLine");

        methodNames.addElement("testDrawRect");

        methodNames.addElement("testDrawRGB");

        methodNames.addElement("testDrawRoundRect");

        methodNames.addElement("testDrawString");

        methodNames.addElement("testFillArc");

        methodNames.addElement("testFillRect");

        methodNames.addElement("testFillRoundRect");

        methodNames.addElement("testFillTriangle");

        return methodNames;

    }

    protected void runTest() throws Throwable

    {

    	if(getName().equals("testDefaultValues")) testDefaultValues();

    	else if(getName().equals("testClip1")) testClip1();

    	else if(getName().equals("testClip2")) testClip2();

    	else if(getName().equals("testDrawArc")) testDrawArc();

    	else if(getName().equals("testDrawImage")) testDrawImage();

    	else if(getName().equals("testDrawLine")) testDrawLine();

    	else if(getName().equals("testDrawRect")) testDrawRect();

    	else if(getName().equals("testDrawRGB")) testDrawRGB();

    	else if(getName().equals("testDrawRoundRect")) testDrawRoundRect();

    	else if(getName().equals("testDrawString")) testDrawString();

    	else if(getName().equals("testFillArc")) testFillArc();

    	else if(getName().equals("testFillRect")) testFillRect();

    	else if(getName().equals("testFillRoundRect")) testFillRoundRect();

    	else if(getName().equals("testFillTriangle")) testFillTriangle();

        else super.runTest();

    }

    /**

     * Tests the default value of a newly created Graphics object

     */

    void testDefaultValues()

    {

    	boolean pass = true;

    	String errorMsg = "";

    	Graphics g = testImage.getGraphics();

    	// Validate default color

    	final int color = g.getColor();

    	if(color != BLACK) 

    	{

    	    pass = false;

    	    errorMsg += "Default color was " + color + ", while expected " + BLACK+". ";

    	}

    	// Validate default clip

    	final int clipX = g.getClipX();

    	final int clipY = g.getClipY();

    	final int clipW = g.getClipWidth();

    	final int clipH = g.getClipHeight();

        if((clipX != 0) || (clipY != 0) || 

           (clipW != testImageWidth) || (clipH != testImageHeight))

        {

        	pass = false;

        	errorMsg += "Default clip was ("+clipX+","+clipY+","+clipW+","+clipH+"), " +

        			"while expected (0,0,"+testImageWidth+","+testImageHeight+"). ";

        }

        // Validate that origin is in the top left corner

        final int transX = g.getTranslateX();

        final int transY = g.getTranslateY();

        if((transX != 0) || (transY != 0))

        {

        	pass = false;

        	errorMsg += "Default origo was ("+transX+","+transY+"), while expected (0,0). ";

        }

        // Validate default font

        final Font font = g.getFont();

        final Font refFont = Font.getDefaultFont();

        if((font.getFace() != refFont.getFace()) || 

           (font.getHeight() != refFont.getHeight()) ||

           (font.getSize() != refFont.getSize()) ||

           (font.getStyle() != refFont.getStyle())) 

        {

        	pass = false;

        	errorMsg += "Default font from Graphics does not match with the font returned by Font.getDefaultFont()	. ";

        }

        // Validate stroke style

        final int style = g.getStrokeStyle();

        if(style != Graphics.SOLID)

        {

            pass = false;

            errorMsg += "Default stroke style was "+ style +", while expected (SOLID) "+Graphics.SOLID;

        }

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

    }

    /**

     * Test default clip by the values returned from Graphics 

     * and by rendering dots in corners and validating them

     */

    void testClip1()

    {

    	boolean pass = true;

    	String errorMsg = "Pixel validation failed at: ";

    	Graphics g = testImage.getGraphics();

    	g.drawLine(0, 0, 0, 0); // top-left

    	g.drawLine(testImageWidth-1, 0, testImageWidth-1, 0); // top-right

    	g.drawLine(0, testImageHeight-1, 0, testImageHeight-1); // bottom-left

    	g.drawLine(testImageWidth-1, testImageHeight-1, testImageWidth-1, testImageHeight-1); // bottom-right

    	readTestImagePixels();

    	if(!validatePixel(0, 0, BLACK))

    	{

    		pass = false;

    		errorMsg += "top-left, ";

    	}

    	if(!validatePixel(testImageWidth-1, 0, BLACK))

    	{

    		pass = false;

    		errorMsg += "top-right, ";

    	}

    	if(!validatePixel(0, testImageHeight-1, BLACK))

    	{

    		pass = false;

    		errorMsg += "bottom-left, ";

    	}

    	if(!validatePixel(testImageWidth-1, testImageHeight-1, BLACK))

    	{

    		pass = false;

    		errorMsg += "bottom-right.";

    	}

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

    }

    /**

     * Test clip with two different graphics objects 

     */

    void testClip2()

    {	

    	boolean pass = true;

    	String errorMsg = "Pixel check failed at: ";

    	Graphics g1 = testImage.getGraphics();

    	Graphics g2 = testImage.getGraphics();

    	final int[] clip1 = {1,1,testImageWidth-2, testImageHeight-2};

    	final int[] clip2 = {4,4,testImageWidth-9, testImageHeight-9};

    	final int[] clip3 = {8,8,testImageWidth-17, testImageHeight-17};

    	// Set clip one pixel smaller than the test image

    	// and fill whole image with red, using graphics object 1

    	g1.setClip(clip1[0], clip1[1], clip1[2], clip1[3]);

    	g1.setColor(RED);

    	g1.fillRect(0, 0, testImageWidth, testImageHeight);

    	// Set clip four pixels smaller than the test image

    	// and fill whole image with green, using graphics object 2

    	g2.setClip(clip2[0], clip2[1], clip2[2], clip2[3]);

    	g2.setColor(GREEN);

    	g2.fillRect(0, 0, testImageWidth, testImageHeight);

    	// Set clip eight pixels smaller than the test image

    	// and fill whole image with blue, using again graphics object 1

    	g1.setClip(clip3[0], clip3[1], clip3[2], clip3[3]);

    	g1.setColor(BLUE);

    	g1.fillRect(0, 0, testImageWidth, testImageHeight);

     	// read image pixels to member array

    	readTestImagePixels();

    	final int[] spotsToValidate = {

    			clip1[0]-1,        clip1[1],          WHITE,  // left border (outside) of clip 1, white

    			clip1[0]+clip1[2], clip1[1],          WHITE,  // right border (outside) of clip 1, white  

    			clip1[0]+1,        clip1[1]-1,        WHITE,  // top border (outside) of clip 1, white

    			clip1[0]+1,        clip1[1]+clip1[3], WHITE,  // bottom border (outside) of clip 1, white

    			clip1[0],            clip1[1],            RED,  // left border (inside) of clip 1, red

    			clip1[0]+clip1[2]-1, clip1[1],            RED,  // right border (inside) of clip 1, red

    			clip1[0],            clip1[1]+1,          RED,  // top border (inside) of clip 1, red

    			clip1[0]+1,          clip1[1]+clip1[3]-1, RED,  // bottom border (inside) of clip 1, red

    			clip2[0]-1,        clip2[1],          RED,  // left border (outside) of clip 2, red

    			clip2[0]+clip2[2], clip2[1],          RED,  // right border (outside) of clip 2, red  

    			clip2[0]+1,        clip2[1]-1,        RED,  // top border (outside) of clip 2, red

    			clip2[0]+1,        clip2[1]+clip2[3], RED,  // bottom border (outside) of clip 2, red

    			clip2[0],            clip2[1],            GREEN,  // left border (inside) of clip 2, green

    			clip2[0]+clip2[2]-1, clip2[1],            GREEN,  // right border (inside) of clip 2, green

    			clip2[0],            clip2[1]+1,          GREEN,  // top border (inside) of clip 2, green

    			clip2[0]+1,          clip2[1]+clip2[3]-1, GREEN,  // bottom border (inside) of clip 2, green

    			clip3[0]-1,        clip3[1],          GREEN,  // left border (outside) of clip 3, green

    			clip3[0]+clip3[2], clip3[1],          GREEN,  // right border (outside) of clip 3, green  

    			clip3[0]+1,        clip3[1]-1,        GREEN,  // top border (outside) of clip 3, green

    			clip3[0]+1,        clip3[1]+clip3[3], GREEN,  // bottom border (outside) of clip 3, green

    			clip3[0],            clip3[1],            BLUE,  // left border (inside) of clip 3, blue

    			clip3[0]+clip3[2]-1, clip3[1],            BLUE,  // right border (inside) of clip 3, blue

    			clip3[0],            clip3[1]+1,          BLUE,  // top border (inside) of clip 3, blue

    			clip3[0]+1,          clip3[1]+clip3[3]-1, BLUE,  // bottom border (inside) of clip 3, blue

    	};

    	// Validate test points against reference color

    	for(int i = 0; i < spotsToValidate.length ; i=i+3) 

    	{

    		if(!validatePixel(spotsToValidate[i], spotsToValidate[i+1], spotsToValidate[i+2]))

        	{

        		pass = false;

        		errorMsg += "("+spotsToValidate[i]+","+spotsToValidate[i+1]+"), expected "+colorToString(spotsToValidate[i+2])+

        		            ", got "+ colorToString(getPixelIgnoreAlpha(spotsToValidate[i], spotsToValidate[i+1]))+" : ";

        	}

    	}

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

    }

    /**

     * Test drawArc with two graphics 

     */

    void testDrawArc()

    {

    	boolean pass = true;

    	String errorMsg = "Pixel check failed at: ";

    	Graphics g1 = testImage.getGraphics();

    	Graphics g2 = testImage.getGraphics();

    	// run different settings in the graphics instances

    	applyGraphicsSettings(g1, GRAPHICS_SETTINGS_1);

    	applyGraphicsSettings(g2, GRAPHICS_SETTINGS_2);

    	g1.drawArc(0, 0, 8, 8, 0, 180);

    	g2.drawArc(0, 0, 8, 8, 0, 180);

    	g1.drawArc(0, 8, 8, 8, 0, 180);

     	// read image pixels to member array

    	readTestImagePixels();

    	// Most of the points to validate are based on the values 

    	// set by applyGraphicsSettings() -method

    	final int[] spotsToValidate = {

    			1,  9, BLUE, // Starting point of the first arc drawn with g1. Y location is arc y + ((height/2)+1) as specified in lcdui spec

    			9,  9, BLUE, // end point

    			5,  5, BLUE, // tip of the arc 

    			10, 8, RED,  // start arc 2

    			18, 8, RED,  // end arc 2

    			14, 4, RED,  // tip of arc 2

    			1,  17, BLUE, // start arc 3

    			9,  17, BLUE, // end arc 3

    			5,  13, BLUE, // tip of arc 3		

    	};

    	// Validate test points against reference color

    	for(int i = 0; i < spotsToValidate.length ; i=i+3) 

    	{

    		if(!validatePixel(spotsToValidate[i], spotsToValidate[i+1], spotsToValidate[i+2]))

        	{

        		pass = false;

        		errorMsg += "("+spotsToValidate[i]+","+spotsToValidate[i+1]+"), expected "+colorToString(spotsToValidate[i+2])+

        		            ", got "+ colorToString(getPixelIgnoreAlpha(spotsToValidate[i], spotsToValidate[i+1]))+" : ";

        	}

    	}

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

    }

    /**

     * Test drawImage with two graphics

     */

	void testDrawImage()

	{

    	boolean pass = true;

    	String errorMsg = "Pixel check failed at: ";

    	// prepare image to be drawn

    	Image img = Image.createImage(5,5);

    	Graphics ig = img.getGraphics();

    	ig.fillRect(0, 0, 5, 5);

    	Graphics g1 = testImage.getGraphics();

    	Graphics g2 = testImage.getGraphics();

    	// run different settings in the graphics instances

    	applyGraphicsSettings(g1, GRAPHICS_SETTINGS_1);

    	applyGraphicsSettings(g2, GRAPHICS_SETTINGS_2);

    	g1.drawImage(img, 0, 0, 0);

    	g2.drawImage(img, 0, 0, 0);

    	g1.drawImage(img, 0, 8, 0);

     	// read image pixels to member array

    	readTestImagePixels();

    	// Most of the points to validate are based on the values 

    	// set by applyGraphicsSettings() -method

    	final int[] spotsToValidate = {

    			1, 5, BLACK, // top-left corner of image 1

    			5, 5, BLACK, // top-right corner of image 1

    			1, 9, BLACK, // bottom-left corner of image 1 

    		    5, 9, BLACK,  // bottom-right corner of image 1

    		    0, 7, WHITE, // Left border (outside) of image 1

    		    6, 7, WHITE, // Right border (outside) of image 1

    		    3, 4, WHITE, // Top border (outside) of image 1

    		    3, 10, WHITE, // Bottom border (outside) of image 1

    			10, 4, BLACK, // top-left corner of image 2

    			14, 4, BLACK, // top-right corner of image 2

    			10, 8, BLACK, // bottom-left corner of image 2 

    		    14, 8, BLACK,  // bottom-right corner of image 2

    		    9,  6, WHITE, // Left border (outside) of image 2

    		    15, 6, WHITE, // Right border (outside) of image 2

    		    12, 3, WHITE, // Top border (outside) of image 2

    		    12, 9, WHITE, // Bottom border (outside) of image 2

    			1, 13, BLACK, // top-left corner of image 3

    			5, 13, BLACK, // top-right corner of image 3

    			1, 17, BLACK, // bottom-left corner of image 3 

    		    5, 17, BLACK,  // bottom-right corner of image 3	

    		    0, 15, WHITE, // Left border (outside) of image 3

    		    6, 15, WHITE, // Right border (outside) of image 3

    		    3, 12, WHITE, // Top border (outside) of image 3

    		    3, 18, WHITE, // Bottom border (outside) of image 3

    	};

    	// Validate test points against reference color

    	for(int i = 0; i < spotsToValidate.length ; i=i+3) 

    	{

    		if(!validatePixel(spotsToValidate[i], spotsToValidate[i+1], spotsToValidate[i+2]))

        	{

        		pass = false;

        		errorMsg += "("+spotsToValidate[i]+","+spotsToValidate[i+1]+"), expected "+colorToString(spotsToValidate[i+2])+

        		            ", got "+ colorToString(getPixelIgnoreAlpha(spotsToValidate[i], spotsToValidate[i+1]))+" : ";

        	}

    	}

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

	}

	void testDrawLine()

	{

    	boolean pass = true;

    	String errorMsg = "Pixel check failed at: ";

    	Graphics g1 = testImage.getGraphics();

    	Graphics g2 = testImage.getGraphics();

    	// run different settings in the graphics instances

    	applyGraphicsSettings(g1, GRAPHICS_SETTINGS_1);

    	applyGraphicsSettings(g2, GRAPHICS_SETTINGS_2);

    	g1.drawLine(0, 0, 0, 7);

    	g2.drawLine(0, 0, 0, 5);

    	g1.drawLine(0, 12, 7, 12);

     	// read image pixels to member array

    	readTestImagePixels();

    	// Most of the points to validate are based on the values 

    	// set by applyGraphicsSettings() -method

    	final int[] spotsToValidate = {

    			// Dotted blue line 1

    			1, 4, WHITE, // point before line 1 start 

    			1, 5, BLUE,  // start of line 1

    			1, 7, WHITE, // middle of line 1, verify that its dotted

    		    1, 11, BLUE,  // end of line 1

    		    1, 12, WHITE, // point after line 1 end

    		    // Solid red line 2

    			10, 3, WHITE, // point before line 2 start 

    			10, 4, RED,  // start of line 2

    		    10, 9, RED,  // end of line 2

    		    10, 10, WHITE, // point after line 2 end

    		    // Dotted blue line 3

    			0, 17, WHITE, // point before line 1 start 

    			1, 17, BLUE,  // start of line 1

    			3, 17, WHITE, // middle of line 1, verify that its dotted

    		    7, 17, BLUE,  // end of line 1

    		    8, 17, WHITE, // point after line 1 end

    	};

    	// Validate test points against reference color

    	for(int i = 0; i < spotsToValidate.length ; i=i+3) 

    	{

    		if(!validatePixel(spotsToValidate[i], spotsToValidate[i+1], spotsToValidate[i+2]))

        	{

        		pass = false;

        		errorMsg += "("+spotsToValidate[i]+","+spotsToValidate[i+1]+"), expected "+colorToString(spotsToValidate[i+2])+

        		            ", got "+ colorToString(getPixelIgnoreAlpha(spotsToValidate[i], spotsToValidate[i+1]))+" : ";

        	}

    	}

    	if(!pass) 

    	{

    		fail(errorMsg);

    	}

	}

	/**

	 * Test drawRect with two graphics

	 */

	void testDrawRect()	

	{

    	boolean pass = true;

    	String errorMsg = "Pixel check failed at: ";

    	Graphics g1 = testImage.getGraphics();

    	Graphics g2 = testImage.getGraphics();

    	// run different settings in the graphics instances