/*

* 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.game;

import junit.framework.*;

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.game.TiledLayer;

import com.nokia.openlcdui.mt.SWTTestCase;

/**

 * TiledLayer non interactive tests

 */

public class TiledLayerTest extends SWTTestCase

{

    // data used to create Images

    // image has width 40, height 30

    private byte[] iImgData40x30 = {71, 73, 70, 56, 57, 97, 40, 0, 30, 0, -14,

                                    0, 0, -128, -128, -128, 36, 0, -1, 0, 0, 85, 0, 0, -86, 0, 109, -1,

                                    0, -110, -1, 73, 0, -1, 0, 0, -1, 33, -7, 4, 1, 0, 0, 0, 0, 44, 0,

                                    0, 0, 0, 40, 0, 30, 0, 2, 3, -1, 120, -70, 107, -66, 37, 18, 18,

                                    11, -107, -41, -114, 33, -74, 96, -32, -31, 24, 16, 86, 101, -45,

                                    -23, 121, 33, 51, 46, 83, 44, -49, 113, -79, 110, -121, -96, -73,

                                    -96, -50, 117, 62, 93, -121, -29, 9, 26, 63, -68, -59, 102, -71,

                                    28, 58, 111, -49, 80, -51, -110, 10, 5, 2, -122, -21, 104, -101,

                                    100, 76, 107, 86, -84, 118, -5, -24, 42, 104, 85, 16, 121, 77,

                                    -110, 78, 88, 61, 96, 39, -76, 116, 96, -53, 46, 9, -100, 33, 20,

                                    -122, 124, 90, 90, 86, 73, 80, -123, 68, -121, 79, -121, 3, 93, 62,

                                    76, 69, 66, 63, -111, 70, -111, -116, 67, -114, 125, 114, -110,

                                    -103, 62, 57, 115, 60, 49, 108, 118, 119, 120, 74, 55, -117, 60,

                                    21, -95, -93, 47, 32, 43, 11, -100, 106, -92, 113, -102, -76, 72,

                                    -99, -89, 12, -126, 60, -122, -119, -98, -73, 116, -120, 80, -112,

                                    28, 118, 118, 21, 5, -81, -66, -91, -67, -113, 78, -59, 89, -57,

                                    -55, -72, -55, -112, -115, -63, -60, 100, -47, -83, -120, -53, 80,

                                    73, 21, -107, -108, 10, 77, -103, -33, 17, 102, 10, -61, 78, 11,

                                    99, 91, -85, 100, -74, 127, -101, -66, -19, 119, -10, -49, 1, -45,

                                    -77, -109, -20, -93, -9, 89, -8, 104, -95, 91, 19, -125, -48, 35,

                                    113, 93, -38, 25, 0, -73, -117, -120, -68, 1, -127, -60, 72, 108,

                                    115, -96, -114, 42, 49, 15, 35, 102, 89, 37, 45, 11, -108, 71, 7,

                                    -109, -10, -96, 11, 49, 66, 64, 2, 0, 59, 0,

                                   };

    // image has width 120, height 10

    private byte[] iImgData120x10 = {71, 73, 70, 56, 57, 97, 120, 0, 10, 0,

                                     -14, 0, 0, -128, -128, -128, 36, 0, -1, 0, 0, 85, 0, 0, -86, 0,

                                     109, -1, 0, -110, -1, 73, 0, -1, 0, 0, -1, 33, -7, 4, 1, 0, 0, 0,

                                     0, 44, 0, 0, 0, 0, 120, 0, 10, 0, 66, 3, -75, 120, -70, -36, -2,

                                     38, -54, -7, 78, -71, 56, -109, -51, -77, -18, -34, -59, -127, -95,

                                     72, 12, 104, 42, -84, 66, -86, 10, 85, 44, 47, 44, -21, -42, 43,

                                     -118, -73, 105, 21, -4, -64, -119, -48, -16, 27, 2, 3, 70, -92,

                                     -16, -104, 68, -51, -98, -115, -99, 107, 74, -83, -18, -82, 60, 29,

                                     78, 91, -69, 109, 7, -46, 87, 119, 0, -115, -115, 70, -95, -13, -7,

                                     82, 102, 28, -117, -110, -73, 114, 72, 23, -74, -37, 97, -25, -3,

                                     64, -51, 77, -57, 94, 125, 88, 54, 127, 44, 73, 73, 63, 37, 24,

                                     -125, 48, 123, -114, 121, 96, 95, -112, 88, -126, 126, 94, -109,

                                     87, 40, -118, 27, -107, -115, 119, -116, 88, -113, 95, 114, 19,

                                     -92, 6, -114, 63, 50, -112, -114, 117, -114, -86, -110, 95, 92,

                                     -124, -104, 99, 43, -82, 7, 97, -85, 15, 85, 98, -77, -79, 100,

                                     -73, 13, -118, 108, -63, 21, 97, -90, 17, -90, -56, 68, 111, 17,

                                     50, -68, 117, -47, -46, -52, 76, -52, 9, 0, 59, 0

                                    };

    // image has width 20, height 60

    private byte[] iImgData20x60 = {71, 73, 70, 56, 57, 97, 20, 0, 60, 0, -14,

                                    0, 0, -128, -128, -128, 36, 0, -1, 0, 0, 85, 0, 0, -86, 0, 109, -1,

                                    0, -110, -1, 73, 0, -1, 0, 0, -1, 33, -7, 4, 1, 0, 0, 0, 0, 44, 0,

                                    0, 0, 0, 20, 0, 60, 0, 2, 3, -1, 120, -86, 102, 87, -123, -60, 89,

                                    -122, 24, -117, 57, 40, 59, -76, 88, -42, 60, -109, 87, 93, -39,

                                    49, 114, -27, -121, -118, 91, 43, -99, -31, -78, -54, 110, -83,

                                    -111, -34, 12, 10, -126, -44, -31, 2, -4, -3, -128, 66, 34, -47, 8,

                                    12, -90, -108, 76, 11, -14, 41, -115, 54, -109, -43, -91, -46,

                                    -103, -127, 106, 45, -103, 14, 97, 17, 48, -108, 71, 66, 49, -39,

                                    -36, 112, -92, 35, 99, 69, -7, -20, 78, -87, -27, 108, -76, 29,

                                    -66, -90, 11, 15, 119, 7, 115, 109, 11, 46, 11, 87, 10, 2, 115,

                                    -123, 39, -121, 83, 67, -117, 10, -122, -119, -113, -118, 102,

                                    -116, 96, -108, 92, -106, 1, -104, -101, -107, -111, 36, -103, 67,

                                    -96, -105, 127, 23, 3, -87, 69, -85, 68, 84, -87, 89, 94, -82, -86,

                                    94, -83, 93, -81, -80, 89, -78, -72, -85, -70, -84, -71, 67, 53,

                                    117, -108, -65, 47, 42, 79, -79, -64, 54, -57, -60, -63, -53, -68,

                                    -55, 12, -50, -75, -59, -62, -92, -52, 11, -86, -77, 22, 13, 1, 5,

                                    -119, 53, -39, 89, -36, -34, -48, 7, -31, -85, -29, -33, -40, 32,

                                    -30, 102, -28, -59, -25, 68, -23, -27, -15, -37, -18, 93, 40, -38,

                                    25, 16, -53, -26, 85, -5, -28, 28, 97, -48, -57, -88, 31, 65, 73,

                                    1, -121, -7, 43, 2, -48, -32, -65, -126, 84, 24, -46, 57, 83, 38,

                                    34, -118, -119, -36, -86, 65, 17, -44, -122, 45, -94, -58, 127, 24,

                                    -39, 88, -60, 16, -78, -94, 45, -119, 29, 51, 118, -103, 19, 105,

                                    64, 27, 110, 43, -51, -76, 124, 105, 42, 17, 75, 83, 46, 95, 118,

                                    58, 116, 115, 103, -50, -114, 49, 3, -52, -44, -103, 0, 0, 59, 0

                                   };

    // image has width 60, height 20

    private byte[] iImgData60x20 = {71, 73, 70, 56, 57, 97, 60, 0, 20, 0, -14,

                                    0, 0, -128, -128, -128, 36, 0, -1, 0, 0, 85, 0, 0, -86, 0, 109, -1,

                                    0, -110, -1, 73, 0, -1, 0, 0, -1, 33, -7, 4, 1, 0, 0, 0, 0, 44, 0,

                                    0, 0, 0, 60, 0, 20, 0, 2, 3, -26, 120, -70, -52, -10, -113, -107,

                                    57, -119, -91, -27, 82, 75, 112, 30, -96, 32, -128, -125, -48,

                                    -100, 14, 100, 72, 24, -41, 118, -101, -74, -111, 34, 125, -120,

                                    56, -86, 47, 120, 88, -9, 37, 96, -112, 6, -60, -115, -116, -90,

                                    -99, -114, -60, 108, -42, 66, 68, 90, 20, -86, -28, -64, 50, -42,

                                    -62, 46, -64, 125, 112, 3, -86, -16, 74, -71, -77, -102, 93, 59,

                                    -79, 58, -84, 108, 17, 119, 72, 35, -68, -10, -11, 118, -73, -28,

                                    -59, -76, -76, 31, -7, -92, 127, 80, -127, 32, 121, 60, 79, 77, 76,

                                    113, 126, 61, 69, 63, 79, 61, 55, -112, -123, 86, 107, 98, 117,

                                    108, 75, 54, 12, 64, 105, 16, -123, -111, 71, -113, -114, -117, 63,

                                    13, -100, 58, 117, -97, -128, 67, -126, -84, 124, -90, 79, 59, -85,

                                    -121, 126, 65, 70, 68, 16, 96, 118, 30, -80, 126, 115, 72, 62, -75,

                                    -82, -75, 34, -107, -68, -65, -74, -124, 122, -119, -93, -54, 100,

                                    -57, -97, -122, 66, -60, 73, 10, -105, 106, 93, -107, 16, -43, 100,

                                    -115, -95, -66, 11, -41, 94, -71, -70, 6, -27, -39, -26, -74, -33,

                                    -50, -47, -107, 86, -86, -102, 58, 61, -105, 117, -12, 119, 12, 76,

                                    -38, 42, -11, 74, -13, -39, -11, -24, 60, 109, -86, -95, 111, 77,

                                    2, 0, 59, 0

                                   };

    // create images from byte array data

    Image[] iImages =

    {

        Image.createImage(iImgData60x20, 0, iImgData60x20.length), // grid

        Image.createImage(iImgData40x30, 0, iImgData40x30.length), // grid

        Image.createImage(iImgData120x10, 0, iImgData120x10.length), // vertical

        Image.createImage(iImgData20x60, 0, iImgData20x60.length), // horizontal

    };

    // data used to create TiledLayer with 6 tiles.

    int iTileCount6 = 6;

    int iTileWidth6 = 20;

    int iTileHeight6 = 10;

    // data used to create TiledLayer with 12 tiles.

    int iTileCount12 = 12;

    int iTileWidth12 = 10;

    int iTileHeight12 = 10;

    // data used to create TiledLayer with 24 tiles.

    int iTileCount24 = 24;

    int iTileWidth24 = 5;

    int iTileHeight24 = 10;

    //

    // 4x2 cells

    int iCols = 4;

    int iRows = 2;

    int[][] iDefaultCells = { {0, 0, 0, 0}, {0, 0, 0, 0}};

    int[][] iSetCells = { {1, 2, 3, 4}, {1, 2, 3, 4}};

    /**

     * Constructor.

     */

    public TiledLayerTest()

    {

    }

    /**

     * Constructor.

     *

     * @param sTestName Test name.

     * @param rTestMethod Test method.

     */

    public TiledLayerTest(String sTestName)

    {

        super(sTestName);

    }

    /**

     * 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 = TiledLayerTest.methodNames();

        e = methodNames.elements();

        while(e.hasMoreElements())

        {

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

        }

        return suite;

    }

    public static java.util.Vector methodNames()

    {

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

        methodNames.addElement("testConstructors");

        methodNames.addElement("testCell");

        methodNames.addElement("testAnimatedTiles");

        methodNames.addElement("testChangeImage");

        methodNames.addElement("testFillCells");

        return methodNames;

    }

    protected void runTest() throws Throwable

    {

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

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

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

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

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

        else super.runTest();

    }

    /**

     * 1.0 TiledLayer - Construction Test

     */

    public void testConstructors()

    {

        Image image = iImages[0];

        int tileWidth = iTileWidth6;

        int tileHeight = iTileHeight6;

        TiledLayer tiledLayer = null;

        // checking("Test 1.01 Construct with wrong row");

        try

        {

            tiledLayer = new TiledLayer(iCols, 0, image, tileWidth, tileHeight);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.02 Construct with wrong col");

        try

        {

            tiledLayer = new TiledLayer(0, iRows, image, tileWidth, tileHeight);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.03 Construct with tile width=0");

        try

        {

            tiledLayer = new TiledLayer(iCols, iRows, image, 0, tileHeight);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.04 Construct with tile height=0");

        try

        {

            int wrongWidth = image.getWidth() / 2 + 1;

            tiledLayer = new TiledLayer(iCols, iRows, image, tileWidth, 0);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.05 Construct with incorrect tile width for image");

        try

        {

            // image width is not an integer multiple of the tileWidth

            int wrongWidth = image.getWidth() / 2 + 1;

            tiledLayer = new TiledLayer(iCols, iRows, image, wrongWidth,

            tileHeight);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.06 Construct with incorrect tile height for image");

        try

        {

            // image height is not an integer multiple of the tileHeight

            int wrongHeight = image.getHeight() / 2 + 1;

            tiledLayer = new TiledLayer(iCols, iRows, image, tileWidth,

            wrongHeight);

            fail("IllegalArgumentException expected");

        }

        catch(java.lang.IllegalArgumentException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 1.07 Construct with correct tile size");

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

        {

            Image img = iImages[i];

            // single tile

            runConstructTest(img, img.getWidth(), img.getHeight(), 1);

            // vary number of tiles and way in which tiles stored

            // - grid, horizontally or vertically.

            runConstructTest(img, iTileWidth6, iTileHeight6, iTileCount6);

            runConstructTest(img, iTileWidth12, iTileHeight12, iTileCount12);

            runConstructTest(img, iTileWidth24, iTileHeight24, iTileCount24);

        }

    }

    // checks TiledLayer properties are correct after construction

    private void runConstructTest(Image image,

    int tileWidth, int tileHeight, int tileCount)

    {

        // vary number of rows and columns

        for(int r = 1; r < iRows; r++)

        {

            for(int c = 1; c < iCols; c++)

            {

                TiledLayer tl = new TiledLayer(c, r, image, tileWidth, tileHeight);

                assertEquals("getWidth ", tl.getWidth(), tileWidth * c);

                assertEquals("getHeight ", tl.getHeight(), tileHeight * r);

                assertEquals("getCellHeight ", tl.getCellHeight(), tileHeight);

                assertEquals("getCellWidth ", tl.getCellWidth(), tileWidth);

                assertEquals("getRows ", tl.getRows(), r);

                assertEquals("getColumns ", tl.getColumns(), c);

                int[][] defaultCells = new int[r][c];

                checkCells(tl, defaultCells);

            }

        }

    }

    /**

     * 2.0 TiledLayer - Cell Test

     */

    public void testCell()

    {

        Image image = iImages[0];

        int tileWidth = iTileWidth6;

        int tileHeight = iTileHeight6;

        int tileCount = iTileCount6;

        TiledLayer tiledLayer;

        // checking("Test 2.01 CellTest: wrong tile index");

        try

        {

            tiledLayer = new TiledLayer(iCols, iRows, image, tileWidth,

            tileHeight);

            tiledLayer.setCell(0, 0, tileCount + 1);

            fail("IndexOutOfBoundsException expected");

        }

        catch(java.lang.IndexOutOfBoundsException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 2.02 CellTest: col is outside the bounds of the TiledLayer grid");

        try

        {

            tiledLayer = new TiledLayer(iCols, iRows, image, tileWidth,

            tileHeight);

            tiledLayer.setCell(iCols, iRows - 1, tileCount);

            fail("IndexOutOfBoundsException expected");

        }

        catch(java.lang.IndexOutOfBoundsException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 2.03 CellTest: row is outside the bounds of the TiledLayer grid");

        try

        {

            tiledLayer = new TiledLayer(iCols, iRows, image, tileWidth,

            tileHeight);

            tiledLayer.setCell(iCols - 1, iRows, tileCount);

            fail("IndexOutOfBoundsException expected");

        }

        catch(java.lang.IndexOutOfBoundsException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 2.04 CellTest: default cells");

        tiledLayer = createTiledLayer(iCols, iRows, image, tileWidth,

        tileHeight, null);

        checkCells(tiledLayer, iDefaultCells);

        // checking("Test 2.05 CellTest: setCells");

        tiledLayer = createTiledLayer(iCols, iRows, image, tileWidth,

        tileHeight, iSetCells);

        checkCells(tiledLayer, iSetCells);

        // checking("Test 2.06 CellTest: fillCells");

        tiledLayer = createTiledLayer(iCols, iRows, image, tileWidth,

        tileHeight, null);

        tiledLayer.fillCells(0, 0, 1, 2, 1);

        tiledLayer.fillCells(1, 0, 2, 1, 2);

        tiledLayer.fillCells(2, 1, 2, 1, 3);

        int[][] fillCells = { {1, 2, 2, 0}, {1, 0, 3, 3}};

        checkCells(tiledLayer, fillCells);

    }

    /**

     * 3.0 TiledLayer - Animated Tiles Test

     */

    public void testAnimatedTiles()

    {

        TiledLayer tiledLayer = new TiledLayer(iCols, iRows, iImages[0],

        iTileWidth6, iTileHeight6);

        // checking("Test 3.01 Animated Tiles Test: invalid static tile index");

        try

        {

            tiledLayer.createAnimatedTile(iTileCount6 + 1);

            fail("IndexOutOfBoundsException expected");

        }

        catch(java.lang.IndexOutOfBoundsException ex)

        {

        }

        catch(Exception ex)

        {

            fail("Wrong exception " + ex);

        }

        // checking("Test 3.02 Animated Tiles Test: create and set animated tiles");

        for(int i = 0; i < iTileCount6 * 3; i++)

        {

            int tileIndex = i % iTileCount6;

            int animTile = tiledLayer.createAnimatedTile(tileIndex);

            assertEquals("index of newly created animated tile", animTile, ~i);

            assertEquals("index returned by getAnimatedTile", tiledLayer

            .getAnimatedTile(animTile), tileIndex);

            int newTileIndex = i % (iTileCount6 / 2);

            tiledLayer.setAnimatedTile(animTile, newTileIndex);

            assertEquals("index after setAnimatedTile", tiledLayer

            .getAnimatedTile(animTile), newTileIndex);

        }

        // checking("Test 3.03 Animated Tiles Test: set cells to animated tiles");

        tiledLayer = new TiledLayer(iCols, iRows, iImages[0], iTileWidth6,

        iTileHeight6);

        int animTile1 = tiledLayer.createAnimatedTile(0);

        int animTile2 = tiledLayer.createAnimatedTile(1);

        tiledLayer.fillCells(0, 0, 4, 1, animTile1);

        tiledLayer.fillCells(0, 1, 4, 1, animTile2);

        int[][] animCells = { {-1, -1, -1, -1}, {-2, -2, -2, -2}};

        int[][] staticCells = { {0, 0, 0, 0}, {1, 1, 1, 1}};

        checkAnimCells(tiledLayer, animCells, staticCells);

        tiledLayer.setAnimatedTile(animTile1, 2);

        tiledLayer.setAnimatedTile(animTile2, 3);

        int[][] newStaticCells = { {2, 2, 2, 2}, {3, 3, 3, 3}};

        checkAnimCells(tiledLayer, animCells, newStaticCells);

    }

    /**

     * 4.0 TiledLayer - Change Image Test

     */

    public void testChangeImage()

    {

        // checking("Test 4.01 Change TiledLayer image: same tiles, clear cells, no anim tiles");

        // Check: Animated tiles and cell contents preserved

        TiledLayer tiledLayer = createTiledLayer(iCols, iRows, iImages[0],

        iTileWidth12, iTileHeight12, null);

        tiledLayer.setStaticTileSet(iImages[1], iTileWidth12, iTileHeight12);