/*
* 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);
}
}
}