/**

 * @test

 * @bug 7088367

 * @summary SourceDataLine.write and TargetDataLine.read don't throw ArrayIndexOutOfBoundsException

 * @author Alex Menkov

 */

import javax.sound.sampled.AudioSystem;

import javax.sound.sampled.DataLine;

import javax.sound.sampled.Line;

import javax.sound.sampled.LineUnavailableException;

import javax.sound.sampled.Mixer;

import javax.sound.sampled.SourceDataLine;

import javax.sound.sampled.TargetDataLine;

public class DataLine_ArrayIndexOutOfBounds {

    static int total = 0;

    static int failed = 0;

    // shared buffer for all tests

    static final byte[] buffer = new byte[5000000];

    // the class describes different test scenarios (buffer properties)

    static abstract class Scenario {

        abstract int getBufferOffset(DataLine line);

        abstract int getBufferLength(DataLine line);

    }

    // scenarios to tests

    static Scenario[] scenarios = new Scenario[]{

        new Scenario() {

            public String toString() {

                return "offset is near Integer.MAX_VALUE";

            }

            public int getBufferOffset(DataLine line) {

                return Integer.MAX_VALUE - 4096;

            }

            public int getBufferLength(DataLine line) {

                return 65536;

            }

        },

        new Scenario() {

            public String toString() {

                return "offset is less than buffer.length, length is large";

            }

            int getBufferOffset(DataLine line) {

                return buffer.length / 10;

            }

            int getBufferLength(DataLine line) {

                return Integer.MAX_VALUE - getBufferOffset(line) + 4096;

            }

        }

    };

    public static void main(String[] args) throws Exception {

        Mixer.Info[] infos = AudioSystem.getMixerInfo();

        log("" + infos.length + " mixers detected");

        for (int i=0; i<infos.length; i++) {

            Mixer mixer = AudioSystem.getMixer(infos[i]);

            log("Mixer " + (i+1) + ": " + infos[i]);

            try {

                mixer.open();

                for (Scenario scenario: scenarios) {

                    testSDL(mixer, scenario);

                    testTDL(mixer, scenario);

                }

                mixer.close();

            } catch (LineUnavailableException ex) {

                log("LineUnavailableException: " + ex);

            }

        }

        if (failed == 0) {

            log("PASSED (" + total + " tests)");

        } else {

            log("FAILED (" + failed + " of " + total + " tests)");

            throw new Exception("Test FAILED");

        }

    }

    final static int STOPPER_DELAY = 5000;  // 1 sec

    static class AsyncLineStopper implements Runnable {

        private final DataLine line;

        private final long delayMS;  // delay before stop the line

        private final Thread thread;

        private final Object readyEvent = new Object();

        private final Object startEvent = new Object();

        public AsyncLineStopper(DataLine line, long delayMS) {

            this.line = line;

            this.delayMS = delayMS;

            thread = new Thread(this);

            thread.setDaemon(true);

            // starts the thread and waits until it becomes ready

            synchronized (readyEvent) {

                thread.start();

                try {

                    readyEvent.wait();

                } catch (InterruptedException ex) { }

            }

        }

        // makes the delay and then stops the line

        public void schedule() {

            synchronized(startEvent) {

                startEvent.notifyAll();

            }

        }

        // force stop/close the line

        public void force() {

            thread.interrupt();

            try {

                thread.join();

            } catch (InterruptedException ex) {

                log("join exception: " + ex);

            }

        }

        // Runnable implementation

        public void run() {

            try {

                synchronized(readyEvent) {

                    readyEvent.notifyAll();

                }

                synchronized(startEvent) {

                    startEvent.wait();

                }

                // delay

                Thread.sleep(delayMS);

            } catch (InterruptedException ex) {

                log("    AsyncLineStopper has been interrupted: " + ex);

            }

            // and flush

            log("    stop...");

            line.stop();

            log("    close...");

            line.close();

        }

    }

    static void testSDL(Mixer mixer, Scenario scenario) {

        log("  Testing SDL (scenario: " + scenario + ")...");

        Line.Info linfo = new Line.Info(SourceDataLine.class);

        SourceDataLine line = null;

        try {

            line = (SourceDataLine)mixer.getLine(linfo);

            log("    got line: " + line);

            log("    open...");

            line.open();

        } catch (IllegalArgumentException ex) {

            log("    unsupported (IllegalArgumentException)");

            return;

        } catch (LineUnavailableException ex) {

            log("    unavailable: " + ex);

            return;

        }

        total++;

        log("    start...");

        line.start();

        AsyncLineStopper lineStopper = new AsyncLineStopper(line, STOPPER_DELAY);

        int offset = scenario.getBufferOffset(line);

        int len = scenario.getBufferLength(line);

        // ensure len represents integral number of frames

        len -= len % line.getFormat().getFrameSize();

        log("    write...");

        lineStopper.schedule();

        try {

            line.write(buffer, offset, len);

            log("    ERROR: didn't get ArrayIndexOutOfBoundsException");

            failed++;

        } catch (ArrayIndexOutOfBoundsException  ex) {

            log("    OK: got ArrayIndexOutOfBoundsException: " + ex);

        }

        lineStopper.force();

    }

    static void testTDL(Mixer mixer, Scenario scenario) {

        log("  Testing TDL (scenario: " + scenario + ")...");

        Line.Info linfo = new Line.Info(TargetDataLine.class);

        TargetDataLine line = null;

        try {

            line = (TargetDataLine)mixer.getLine(linfo);

            log("    got line: " + line);

            log("    open...");

            line.open();

        } catch (IllegalArgumentException ex) {

            log("    unsupported (IllegalArgumentException)");

            return;

        } catch (LineUnavailableException ex) {

            log("    unavailable: " + ex);

            return;

        }

        total++;

        log("    start...");

        line.start();

        AsyncLineStopper lineStopper = new AsyncLineStopper(line, STOPPER_DELAY);

        int offset = scenario.getBufferOffset(line);

        int len = scenario.getBufferLength(line);

        // ensure len represents integral number of frames

        len -= len % line.getFormat().getFrameSize();

        log("    read...");

        try {

            line.read(buffer, offset, len);

            log("    ERROR: didn't get ArrayIndexOutOfBoundsException");

            failed++;

        } catch (ArrayIndexOutOfBoundsException  ex) {

            log("    OK: got ArrayIndexOutOfBoundsException: " + ex);

        }

        lineStopper.force();

    }

    static void log(String s) {

        System.out.println(s);

        System.out.flush();

    }

}