/*
 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.awt.Point;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferDouble;
import java.awt.image.DataBufferFloat;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferShort;
import java.awt.image.DataBufferUShort;
import java.awt.image.SampleModel;
import java.awt.image.MultiPixelPackedSampleModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.Raster;

 /*
 * @test
 * @bug  6353518
 * @summary  Test possible combinations of WritableRaster creation
 *           Test fails if Raster.createWritableRaster() throws exception.
 */
public class CreateWritableRasterTest {

    public static void main(String[] args) {

        final int width = 20;
        final int height = 10;
        final int imageSize = width * height;
        Point location = new Point(0, 0);
        int bandOffsets[] = {0};
        int bitMask[] = { 0x00ff0000, 0x0000ff00, 0xff, 0x0};

        SampleModel inputSampleModels[] = {
            new PixelInterleavedSampleModel(DataBuffer.TYPE_BYTE,
                                            1, 1, 1, 1, bandOffsets),
            new PixelInterleavedSampleModel(DataBuffer.TYPE_USHORT,
                                            1, 1, 1, 1, bandOffsets),
            new PixelInterleavedSampleModel(DataBuffer.TYPE_INT,
                                            1, 1, 1, 1, bandOffsets),
            new SinglePixelPackedSampleModel(DataBuffer.TYPE_BYTE,
                                             width, height, bitMask),
            new SinglePixelPackedSampleModel(DataBuffer.TYPE_USHORT,
                                             width, height, bitMask),
            new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT,
                                             width, height, bitMask),
            new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE,
                                            width, height, 4)
        };

        // ---------------------------------------------------------------------
        // Test ability to create WritableRaster with DataBuffer classes
        // ---------------------------------------------------------------------
        DataBuffer inputDataBuffer[] = {
            new DataBufferByte(imageSize),
            new DataBufferDouble(imageSize),
            new DataBufferFloat(imageSize),
            new DataBufferShort(imageSize),
            new DataBufferUShort(imageSize),
            new DataBufferInt(imageSize, 1)
        };

        for (SampleModel sm : inputSampleModels) {
            for (DataBuffer db : inputDataBuffer) {
                Raster.createWritableRaster(sm, db, location);
            }
        }

        // ---------------------------------------------------------------------
        // Test ability to create WritableRaster with custom DataBuffer classes
        // ---------------------------------------------------------------------
        DataBuffer myDataBuffer[] = {
            new MyDataBufferByte(imageSize),
            new MyDataBufferDouble(imageSize),
            new MyDataBufferFloat(imageSize),
            new MyDataBufferShort(imageSize),
            new MyDataBufferUShort(imageSize),
            new MyDataBufferInt(imageSize)
        };

        for (SampleModel sm : inputSampleModels) {
            for (DataBuffer db : myDataBuffer) {
                Raster.createWritableRaster(sm, db, location);
            }
        }
    }
}


// ---------------------------------------------------------------------
// Custom DataBuffer classes for testing purpose
// ---------------------------------------------------------------------
final class MyDataBufferByte extends DataBuffer {

    byte data[];
    byte bankdata[][];

    public MyDataBufferByte(int size) {
        super(TYPE_BYTE, size);
        data = new byte[size];
        bankdata = new byte[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (byte) val;
    }
}

final class MyDataBufferDouble extends DataBuffer {

    double data[];
    double bankdata[][];

    public MyDataBufferDouble(int size) {
        super(TYPE_DOUBLE, size);
        data = new double[size];
        bankdata = new double[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return (int) bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (double) val;
    }
}

final class MyDataBufferFloat extends DataBuffer {

    float data[];
    float bankdata[][];

    public MyDataBufferFloat(int size) {
        super(TYPE_FLOAT, size);
        data = new float[size];
        bankdata = new float[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return (int) bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (float) val;
    }
}

final class MyDataBufferShort extends DataBuffer {

    short data[];
    short bankdata[][];

    public MyDataBufferShort(int size) {
        super(TYPE_SHORT, size);
        data = new short[size];
        bankdata = new short[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (short) val;
    }
}

final class MyDataBufferUShort extends DataBuffer {

    short data[];
    short bankdata[][];

    public MyDataBufferUShort(int size) {
        super(TYPE_USHORT, size);
        data = new short[size];
        bankdata = new short[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (short) val;
    }
}

final class MyDataBufferInt extends DataBuffer {

    int data[];
    int bankdata[][];

    public MyDataBufferInt(int size) {
        super(TYPE_INT, size);
        data = new int[size];
        bankdata = new int[1][];
        bankdata[0] = data;
    }

    @Override
    public int getElem(int bank, int i) {
        return bankdata[bank][i + offsets[bank]];
    }

    @Override
    public void setElem(int bank, int i, int val) {
        bankdata[bank][i + offsets[bank]] = (int) val;
    }
}