/*

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

    }

}