/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
 * @author Evgeny S. Sidorenko
 */

package org.apache.harmony.sound.tests.javax.sound.midi;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.ShortMessage;

import junit.framework.TestCase;

public class ShortMessageTest extends TestCase {

    /**
     * test constants
     *
     */
    public void test_constants() {
        assertEquals(254, ShortMessage.ACTIVE_SENSING);
        assertEquals(208, ShortMessage.CHANNEL_PRESSURE);
        assertEquals(251, ShortMessage.CONTINUE);
        assertEquals(176, ShortMessage.CONTROL_CHANGE);
        assertEquals(247, ShortMessage.END_OF_EXCLUSIVE);
        assertEquals(241, ShortMessage.MIDI_TIME_CODE);
        assertEquals(128, ShortMessage.NOTE_OFF);
        assertEquals(144, ShortMessage.NOTE_ON);
        assertEquals(224, ShortMessage.PITCH_BEND);
        assertEquals(160, ShortMessage.POLY_PRESSURE);
        assertEquals(192, ShortMessage.PROGRAM_CHANGE);
        assertEquals(242, ShortMessage.SONG_POSITION_POINTER);
        assertEquals(243, ShortMessage.SONG_SELECT);
        assertEquals(250, ShortMessage.START);
        assertEquals(252, ShortMessage.STOP);
        assertEquals(255, ShortMessage.SYSTEM_RESET);
        assertEquals(248, ShortMessage.TIMING_CLOCK);
        assertEquals(246, ShortMessage.TUNE_REQUEST);
    }

    /**
     * test constructors
     *
     */
    public void test_constructor_ShortMessage1() {
        ShortMessage1 message = new ShortMessage1();
        assertEquals(0, message.getChannel());
        assertEquals(144, message.getCommand());
        assertEquals(64, message.getData1());
        assertEquals(127, message.getData2());
        assertEquals(3, message.getLength());
        assertEquals(144, message.getStatus());
        assertEquals(3, message.getMessage().length);
        assertEquals(-112, message.getMessage()[0]);
        assertEquals(64, message.getMessage()[1]);
        assertEquals(127, message.getMessage()[2]);

        byte[] bt = new byte[] { -95, -5, 9, 56, -18 };
        ShortMessage1 message1 = new ShortMessage1(bt);
        assertEquals(1, message1.getChannel());
        assertEquals(160, message1.getCommand());
        assertEquals(251, message1.getData1());
        assertEquals(9, message1.getData2());
        assertEquals(5, message1.getLength());
        assertEquals(161, message1.getStatus());
        assertEquals(5, message1.getMessage().length);
        assertEquals(-95, message1.getMessage()[0]);
        assertEquals(-5, message1.getMessage()[1]);
        assertEquals(9, message1.getMessage()[2]);
        assertEquals(56, message1.getMessage()[3]);
        assertEquals(-18, message1.getMessage()[4]);
        bt[0] = 1;
        bt[1] = 2;
        bt[2] = 3;
        bt[3] = 4;
        bt[4] = 5;
        /*
         * values change
         */
        assertEquals(1, message1.getChannel());
        assertEquals(0, message1.getCommand());
        assertEquals(2, message1.getData1());
        assertEquals(3, message1.getData2());
        assertEquals(5, message1.getLength());
        assertEquals(1, message1.getStatus());
        assertEquals(1, message1.getMessage()[0]);
        assertEquals(2, message1.getMessage()[1]);
        assertEquals(3, message1.getMessage()[2]);
        assertEquals(4, message1.getMessage()[3]);
        assertEquals(5, message1.getMessage()[4]);

        ShortMessage1 message2 = new ShortMessage1(new byte[] { 95, 14 });
        assertEquals(15, message2.getChannel());
        assertEquals(80, message2.getCommand());
        assertEquals(14, message2.getData1());
        assertEquals(0, message2.getData2());
        assertEquals(2, message2.getLength());
        assertEquals(95, message2.getStatus());
        assertEquals(2, message2.getMessage().length);

        ShortMessage1 message3 = new ShortMessage1(null);
        assertEquals(0, message3.getChannel());
        assertEquals(0, message3.getCommand());
        assertEquals(0, message3.getData1());
        assertEquals(0, message3.getData2());
        assertEquals(0, message3.getLength());
        assertEquals(0, message3.getStatus());
        try {
            message3.getMessage();
            fail("NullPointerException expected");
        } catch (NullPointerException e) {}

        ShortMessage1 message4 = new ShortMessage1(new byte[] {0});
        assertEquals(0, message4.getChannel());
        assertEquals(0, message4.getCommand());
        assertEquals(0, message4.getData1());
        assertEquals(0, message4.getData2());
        assertEquals(1, message4.getLength());
        assertEquals(0, message4.getStatus());
        assertEquals(1, message4.getMessage().length);
        
        ShortMessage1 message5 = new ShortMessage1(new byte[0]);
        assertEquals(0, message5.getChannel());
        assertEquals(0, message5.getCommand());
        assertEquals(0, message5.getData1());
        assertEquals(0, message5.getData2());
        assertEquals(0, message5.getLength());
        assertEquals(0, message5.getStatus());
        assertEquals(0, message5.getMessage().length);
    }

    /**
     * test method setMessage(int) of class ShortMessage
     */
    public void test_setMessage1() throws Exception {
        ShortMessage1 message = new ShortMessage1();
        /*
         * value of variable status is more or equals 246 and
         * less or equals 255
         */
        try {
            message.setMessage(245);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.setMessage(256);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        
        message.setMessage(250);
        /*
         * channel change from 0 up to 15, and
         * channel + command == status, so
         * the value of command divisible by 16
         */
        assertEquals(10, message.getChannel());
        assertEquals(240, message.getCommand());
        assertEquals(0, message.getData1());
        assertEquals(0, message.getData2());
        assertEquals(1, message.getLength());
        assertEquals(250, message.getStatus());
        assertEquals(1, message.getMessage().length);
    }

    /**
     * test method setMessage(int, int, int) of 
     * class ShortMessage
     */
    public void test_setMessage2() throws Exception {
        ShortMessage1 message = new ShortMessage1();
        /*
         * value of variable status is more or equals 246 and
         * less or equals 255
         */
        try {
            message.setMessage(245, 34, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        try {
            message.setMessage(256, 34, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        
        message.setMessage(250, 34, 56);
        /*
         * channel change from 0 up to 15, and
         * channel + command == status, so
         * the value of command divisible by 16.
         */
        assertEquals(10, message.getChannel());
        assertEquals(240, message.getCommand());
        assertEquals(0, message.getData1());
        assertEquals(0, message.getData2());
        assertEquals(1, message.getLength());
        assertEquals(250, message.getStatus());
        assertEquals(1, message.getMessage().length);
    }

    /**
     * test method setMessage(int, int, int, int) of 
     * class ShortMessage
     */
    public void test_setMessage3() throws Exception {
        ShortMessage1 message = new ShortMessage1();
        /*
         * value of variable command is more or equals 128 and
         * less or equals 239
         */
        try {
            message.setMessage(127, 10, 34, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        try {
            message.setMessage(240, 34, 56, 13);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        /*
         * value of variable channel is more or equals 0 and 
         * less or equals 15
         */
        try {
            message.setMessage(200, -1, 34, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        try {
            message.setMessage(200, 16, 34, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        /*
         * value of data1 and data2 is more or equals 0 and
         * less or equals 127, but when command more or
         * equals 192 and less or equals 223 the second data,
         * data2, is unused, because getDataLength(int) return 1
         * in this case, and in other cases it return 2
         */
        try {
            message.setMessage(200, 12, -1, 56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.setMessage(225, 8, 34, 456);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}
        
        /*
         * it's all right
         */
        message.setMessage(200, 8, 34, 456);

        message.setMessage(200, 9, 34, 56);
        /*
         * channel change from 0 up to 15
         * command must to divisible by 16, and so it less or 
         * equals parameter command
         * status is sum of channel and command
         */
        assertEquals(9, message.getChannel());
        assertEquals(192, message.getCommand());
        assertEquals(34, message.getData1());
        assertEquals(0, message.getData2());
        assertEquals(2, message.getLength());
        assertEquals(201, message.getStatus());
        assertEquals(2, message.getMessage().length);

        message.setMessage(148, 9, 34, 56);
        assertEquals(9, message.getChannel());
        assertEquals(144, message.getCommand());
        assertEquals(34, message.getData1());
        assertEquals(56, message.getData2());
        assertEquals(3, message.getLength());
        assertEquals(153, message.getStatus());
        assertEquals(3, message.getMessage().length);
    }

    /**
     * test method getChannel() of class ShortMessage
     *
     */
    public void test_getChannel() throws Exception {
        ShortMessage message = new ShortMessage();
        assertEquals(0, message.getChannel());

        byte[] bt = new byte[] {23, 16, 35};
        ShortMessage1 message1 = new ShortMessage1(bt);
        assertEquals(7, message1.getChannel());
        bt[0] = 15;
        /*
         * value change
         */
        assertEquals(15, message1.getChannel());
        
        ShortMessage1 message2 = new ShortMessage1(null);
        assertEquals(0, message2.getChannel());

        message.setMessage(249);
        assertEquals(9, message.getChannel());

        message.setMessage(250, 14, 62);
        assertEquals(10, message.getChannel());

        message.setMessage(234, 15, 14, 62);
        assertEquals(15, message.getChannel());

    }

    /**
     * test method getCommand() of class ShortMessage
     *
     */
    public void test_getCommand() throws Exception {
        ShortMessage message = new ShortMessage();
        assertEquals(144, message.getCommand());

        byte[] bt = new byte[] {23, 16, 35};
        ShortMessage1 message1 = new ShortMessage1(bt);
        assertEquals(16, message1.getCommand());
        bt[0] = 4;
        /*
         * value change
         */
        assertEquals(0, message1.getCommand());

        ShortMessage1 message2 = new ShortMessage1(null);
        assertEquals(0, message2.getCommand());

        message.setMessage(249);
        assertEquals(240, message.getCommand());

        message.setMessage(250, 14, 62);
        assertEquals(240, message.getCommand());

        message.setMessage(234, 15, 14, 62);
        assertEquals(224, message.getCommand());
    }

    /**
     * test method getLength() of class ShortMessage
     *
     */
    public void test_getLength() throws Exception {
        ShortMessage message = new ShortMessage();
        assertEquals(3, message.getLength());

        ShortMessage1 message1 = new ShortMessage1(new byte[] {23, 16, 35});
        assertEquals(3, message1.getLength());

        ShortMessage1 message2 = new ShortMessage1(null);
        assertEquals(0, message2.getLength());

        message.setMessage(249);
        assertEquals(1, message.getLength());

        message.setMessage(250, 14, 62);
        assertEquals(1, message.getLength());

        message.setMessage(234, 15, 14, 62);
        assertEquals(3, message.getLength());

        message.setMessage(214, 15, 14, 62);
        assertEquals(2, message.getLength());
    }

    /**
     * test method getStatus() of class ShortMessage
     *
     */
    public void test_getStatus() throws Exception {
        ShortMessage message = new ShortMessage();
        assertEquals(144, message.getStatus());

        byte[] bt = new byte[] {23, 16, 35};
        ShortMessage1 message1 = new ShortMessage1(bt);
        assertEquals(23, message1.getStatus());
        bt[0] = 84;
        /*
         * value change
         */
        assertEquals(84, message1.getStatus());

        ShortMessage1 message2 = new ShortMessage1(null);
        assertEquals(0, message2.getStatus());

        message.setMessage(249);
        assertEquals(249, message.getStatus());

        message.setMessage(250, 14, 62);
        assertEquals(250, message.getStatus());

        message.setMessage(234, 15, 14, 62);
        assertEquals(239, message.getStatus());
    }

    /**
     * test methods getData1() and getData2() of 
     * class ShortMessage
     *
     */
    public void test_getData1_2() throws Exception {
        ShortMessage message = new ShortMessage();
        assertEquals(64, message.getData1());
        assertEquals(127, message.getData2());

        byte[] bt = new byte[] { 23, 16, 35 };
        ShortMessage1 message1 = new ShortMessage1(bt);
        assertEquals(16, message1.getData1());
        assertEquals(35, message1.getData2());
        bt[1] = 84;
        bt[2] = -16;
        /*
         * values change
         */
        assertEquals(84, message1.getData1());
        assertEquals(240, message1.getData2());

        ShortMessage1 message11 = new ShortMessage1(new byte[] { 23, 16 });
        assertEquals(16, message11.getData1());
        assertEquals(0, message11.getData2());

        ShortMessage1 message12 = new ShortMessage1(new byte[] { 23 });
        assertEquals(0, message12.getData1());
        assertEquals(0, message12.getData2());

        ShortMessage1 message2 = new ShortMessage1(null);
        assertEquals(0, message2.getData1());
        assertEquals(0, message2.getData2());

        message.setMessage(249);
        assertEquals(0, message.getData1());
        assertEquals(0, message.getData2());

        message.setMessage(250, 14, 62);
        assertEquals(0, message.getData1());
        assertEquals(0, message.getData2());

        message.setMessage(234, 15, 14, 62);
        assertEquals(14, message.getData1());
        assertEquals(62, message.getData2());

        message.setMessage(198, 15, 14, 62);
        assertEquals(14, message.getData1());
        assertEquals(0, message.getData2());
        
        ShortMessage1 message15 = new ShortMessage1(new byte[] {-16, 16, 35});
        assertEquals(16, message15.getData1());
        assertEquals(35, message15.getData2());
    }

    /**
     * test method getDataLength() of class ShortMessage
     *
     */
    public void test_getDataLength() throws Exception {
        ShortMessage1 message = new ShortMessage1();

        /*
         * I have some question about this method. I didn't understand how
         * should to work this method, but some results I get by
         * experimental method.
         * From 0 up to 127, from 256 up to 383 and so on this method throw
         * out exception, i.e. after 256 begin cycle with some small 
         * differences in the first lap, from 0 up to 255. From the second
         * lap and so on this method, getDataLength(int), throw out 
         * exception with value of status from 496 up to 511, from 752 up to 
         * 767 and so on, i.e. on the last 16 number of 256-lap.
         * And now differences in the first lap. This method don't throw out 
         * exception with value of status from 240 up to 255. It has next 
         * behavior:
         * - value of status equals 240 -- throw out exception;
         * - 241 -- return 1; 
         * - 242 -- return 2;
         * - 243 -- return 1;
         * - from 244 up to 245 -- throw out exception;
         * - from 246 up to 255 -- return 0;
         */
        try {
            message.getDataLength1(-1);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(56);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(127);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(240);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(244);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(245);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(256);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        try {
            message.getDataLength1(519);
            fail("InvalidMidiDataException expected");
        } catch (InvalidMidiDataException e) {}

        assertEquals(2, message.getDataLength1(128));
        assertEquals(1, message.getDataLength1(200));
        assertEquals(2, message.getDataLength1(230));
        assertEquals(1, message.getDataLength1(241));
        assertEquals(2, message.getDataLength1(242));
        assertEquals(1, message.getDataLength1(243));
        assertEquals(0, message.getDataLength1(250));
        assertEquals(2, message.getDataLength1(647));
    }

    /**
     * tests method clone() of class ShortMessage
     *
     */
    public void test_clone1() {
        ShortMessage message = new ShortMessage();
        assertTrue(message.clone() != message);
        assertEquals(message.clone().getClass(), message.getClass());
        ShortMessage tmessage;
        tmessage = (ShortMessage) message.clone();
        assertEquals(message.getLength(), tmessage.getLength());
        assertEquals(message.getMessage().length, tmessage.getMessage().length);
        assertEquals(message.getData1(), tmessage.getData1());
        assertEquals(message.getData2(), tmessage.getData2());
        assertEquals(message.getChannel(), tmessage.getChannel());
        assertEquals(message.getCommand(), tmessage.getCommand());
        assertEquals(message.getStatus(), tmessage.getStatus());
        if (message.getMessage().length != 0) {
            for (int i = 0; i < message.getMessage().length; i++) {
                assertEquals(message.getMessage()[i], tmessage.getMessage()[i]);
            }
        }
    }
    
    public void test_clone2() {
        byte[] bt = new byte[] {1, 2, 3, 4, 5};
        ShortMessage1 message = new ShortMessage1(bt);
        assertTrue(message.clone() != message);
        
        ShortMessage tmessage;
        tmessage = (ShortMessage) message.clone();
        assertEquals(message.getLength(), tmessage.getLength());
        assertEquals(message.getMessage().length, tmessage.getMessage().length);
        assertEquals(message.getData1(), tmessage.getData1());
        assertEquals(message.getData2(), tmessage.getData2());
        assertEquals(message.getChannel(), tmessage.getChannel());
        assertEquals(message.getCommand(), tmessage.getCommand());
        assertEquals(message.getStatus(), tmessage.getStatus());
        if (message.getMessage().length != 0) {
            for (int i = 0; i < message.getMessage().length; i++) {
                assertEquals(message.getMessage()[i], tmessage.getMessage()[i]);
            }
        }
        bt[0] = 10;
        bt[1] = 20;
        bt[2] = 30;
        bt[3] = 40;
        bt[4] = 50;
        /*
         * 'real' ShortMessage change, but 'clone' not
         */
        //'real'
        assertEquals(10, message.getChannel());
        assertEquals(0, message.getCommand());
        assertEquals(20, message.getData1());
        assertEquals(30, message.getData2());
        assertEquals(10, message.getStatus());
        assertEquals(10, message.getMessage()[0]);
        assertEquals(20, message.getMessage()[1]);
        assertEquals(30, message.getMessage()[2]);
        assertEquals(40, message.getMessage()[3]);
        assertEquals(50, message.getMessage()[4]);
        //'clone'
        assertEquals(1, tmessage.getChannel());
        assertEquals(0, tmessage.getCommand());
        assertEquals(2, tmessage.getData1());
        assertEquals(3, tmessage.getData2());
        assertEquals(1, tmessage.getStatus());
        assertEquals(1, tmessage.getMessage()[0]);
        assertEquals(2, tmessage.getMessage()[1]);
        assertEquals(3, tmessage.getMessage()[2]);
        assertEquals(4, tmessage.getMessage()[3]);
        assertEquals(5, tmessage.getMessage()[4]);
    }
    
    public void test_clone3() throws Exception {
        ShortMessage message = new ShortMessage();
        message.setMessage(150, 14, 45, 60);
        assertTrue(message.clone() != message);
        assertEquals(message.clone().getClass(), message.getClass());
        ShortMessage tmessage;
        tmessage = (ShortMessage) message.clone();
        assertEquals(message.getLength(), tmessage.getLength());
        assertEquals(message.getMessage().length, tmessage.getMessage().length);
        assertEquals(message.getData1(), tmessage.getData1());
        assertEquals(message.getData2(), tmessage.getData2());
        assertEquals(message.getChannel(), tmessage.getChannel());
        assertEquals(message.getCommand(), tmessage.getCommand());
        assertEquals(message.getStatus(), tmessage.getStatus());
        if (message.getMessage().length != 0) {
            for (int i = 0; i < message.getMessage().length; i++) {
                assertEquals(message.getMessage()[i], tmessage.getMessage()[i]);
            }
        }
    }

    /**
     * Subsidiary class in order to use constructor
     * and method getDataLength( int ) of class Instrument, 
     * because its declared as protected
     */
    static class ShortMessage1 extends ShortMessage {

        ShortMessage1() {
            super();
        }

        ShortMessage1(byte[] data) {
            super(data);
        }

        public int getDataLength1(int status) throws InvalidMidiDataException {
            return super.getDataLength(status);
        }
    }
}