/*
* Copyright (c) 2003, 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.util.List;
import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Receiver;
import javax.sound.midi.Sequencer;
import javax.sound.midi.Synthesizer;
import javax.sound.midi.Transmitter;
import javax.sound.midi.spi.MidiDeviceProvider;
import com.sun.media.sound.JDK13Services;
/**
* @test
* @bug 4776511
* @bug 4934509
* @bug 4938236
* @modules java.desktop/com.sun.media.sound
* @run main/timeout=600 DefaultDevices
* @summary RFE: Setting the default MixerProvider
*/
/** Test the retrieving of MidiDevices with default device properties.
* This is a part of the test for 4776511.
* The test also functions as a unit test for 4934509: SPEC: Document
* explicitely MidiSystem.getReceiver's behavior
* and a regession test for 4938236: Crash when opening synthesizer implicitly
* The test has been updated to reflect a fix for 6411624: MidiSystem.getSequencer()
* doesn't throw MidiUnavaivableException if no audio card installed (see also
* 6422786: regression test javax/sound/midi/MidiSystem/DefaultDevices.java fails)
*/
public class DefaultDevices {
private static final String ERROR_PROVIDER_CLASS_NAME = "abc";
private static final String ERROR_INSTANCE_NAME = "def";
private static final Class RECEIVER_CLASS = javax.sound.midi.Receiver.class;
private static final Class TRANSMITTER_CLASS = javax.sound.midi.Transmitter.class;
private static final Class SEQUENCER_CLASS = javax.sound.midi.Sequencer.class;
private static final Class SYNTHESIZER_CLASS = javax.sound.midi.Synthesizer.class;
public static void main(String[] args) throws Exception {
boolean allOk = true;
MidiDevice.Info[] infos;
out("\nTesting MidiDevices retrieved via MidiSystem");
infos = MidiSystem.getMidiDeviceInfo();
allOk &= testDevices(infos, null);
out("\nTesting MidiDevices retrieved from MidiDeviceProviders");
List providers = JDK13Services.getProviders(MidiDeviceProvider.class);
for (int i = 0; i < providers.size(); i++) {
MidiDeviceProvider provider = (MidiDeviceProvider)providers.get(i);
infos = provider.getDeviceInfo();
allOk &= testDevices(infos, provider.getClass().getName());
}
if (!allOk) {
throw new Exception("Test failed");
} else {
out("Test passed");
}
}
private static boolean testDevices(MidiDevice.Info[] infos,
String providerClassName) {
boolean allOk = true;
for (int i = 0; i < infos.length; i++) {
MidiDevice device = null;
try {
device = MidiSystem.getMidiDevice(infos[i]);
} catch (MidiUnavailableException e) {
out("Exception thrown; Test NOT failed.");
e.printStackTrace(System.out);
out("");
}
out("\nTesting device: " + device);
if (device instanceof Sequencer) {
allOk &= testDevice(device, SEQUENCER_CLASS, providerClassName, true, true);
// incorrect cases
allOk &= testDevice(device, SYNTHESIZER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, RECEIVER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, TRANSMITTER_CLASS, providerClassName, false, false);
}
if (device instanceof Synthesizer) {
allOk &= testDevice(device, SYNTHESIZER_CLASS, providerClassName, true, true);
allOk &= testDevice(device, RECEIVER_CLASS, providerClassName, false, true);
// incorrect cases
allOk &= testDevice(device, TRANSMITTER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, SEQUENCER_CLASS, providerClassName, false, false);
}
if (device instanceof Receiver) {
allOk &= testDevice(device, RECEIVER_CLASS, providerClassName, true, true);
// incorrect cases
allOk &= testDevice(device, TRANSMITTER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, SYNTHESIZER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, SEQUENCER_CLASS, providerClassName, false, false);
}
if (device instanceof Transmitter) {
allOk &= testDevice(device, TRANSMITTER_CLASS, providerClassName, true, true);
// incorrect cases
allOk &= testDevice(device, RECEIVER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, SYNTHESIZER_CLASS, providerClassName, false, false);
allOk &= testDevice(device, SEQUENCER_CLASS, providerClassName, false, false);
}
}
return allOk;
}
private static boolean testDevice(MidiDevice device, Class type,
String providerClassName, boolean testWrong, boolean expectedResult) {
boolean allOk = true;
String instanceName = device.getDeviceInfo().getName();
// no error
allOk &= testDevice(device, type, providerClassName,
instanceName, expectedResult);
if (testWrong) {
// erroneous provider class name, correct instance name
allOk &= testDevice(device, type, ERROR_PROVIDER_CLASS_NAME,
instanceName, expectedResult);
// correct provider class name, erroneous instance name
// we presume that provider provides only one class of requested type
allOk &= testDevice(device, type, providerClassName,
ERROR_INSTANCE_NAME, expectedResult);
}
return allOk;
}
private static boolean testDevice(MidiDevice device, Class type,
String providerClassName, String instanceName,
boolean expectedResult) {
boolean allOk = true;
try {
String propertyName = type.getName();
String propertyValue = (providerClassName != null) ? providerClassName: "" ;
propertyValue += "#" + instanceName;
out("property: " + propertyName + "="+ propertyValue);
System.setProperty(propertyName, propertyValue);
Object reference = null;
Object result = null;
if (type == SEQUENCER_CLASS) {
reference = device;
result = MidiSystem.getSequencer();
} else if (type == SYNTHESIZER_CLASS) {
reference = device;
result = MidiSystem.getSynthesizer();
} else if (type == RECEIVER_CLASS) {
reference = device.getReceiver();
result = MidiSystem.getReceiver();
} else if (type == TRANSMITTER_CLASS) {
reference = device.getTransmitter();
result = MidiSystem.getTransmitter();
}
out("result: " + result);
boolean rightDevice = (reference.getClass() == result.getClass());
if (rightDevice != expectedResult) {
out("\nERROR: type " + type + " failed:"
+ " class should" + (expectedResult ? "" : " NOT") + " be '"
+ reference.getClass()
+ "' but is '" + result.getClass() + "'!\n");
allOk = false;
}
if (expectedResult
&& reference instanceof MidiDevice
&& result instanceof MidiDevice) {
MidiDevice referenceDevice = (MidiDevice)reference;
MidiDevice resultDevice = (MidiDevice)result;
if (!referenceDevice.getDeviceInfo().getName().equals(
resultDevice.getDeviceInfo().getName())) {
out("\nERROR: type " + type + " failed: name should be '"
+ referenceDevice.getDeviceInfo().getName()
+ "' but is '"
+ resultDevice.getDeviceInfo().getName() + "'!\n");
allOk = false;
}
}
if (result instanceof Receiver) {
((Receiver)result).close();
} else if (result instanceof Transmitter) {
((Transmitter)result).close();
} else if (result instanceof Synthesizer) {
((Synthesizer)result).close();
} else if (result instanceof Sequencer) {
((Sequencer)result).close();
}
} catch (Exception e) {
out("Exception thrown; Test NOT failed.");
e.printStackTrace(System.out);
out("");
}
return allOk;
}
private static void out(String message) {
System.out.println(message);
}
}