from test import test_support

test_support.requires('audio')



from test.test_support import findfile, TestSkipped, run_unittest



import errno

linuxaudiodev = test_support.import_module('linuxaudiodev', deprecated=True)

import sys

import sunaudio

import audioop

import unittest



SND_FORMAT_MULAW_8 = 1



class LinuxAudioDevTests(unittest.TestCase):



    def setUp(self):

        self.dev = linuxaudiodev.open('w')



    def tearDown(self):

        self.dev.close()



    def test_methods(self):

        # at least check that these methods can be invoked

        self.dev.bufsize()

        self.dev.obufcount()

        self.dev.obuffree()

        self.dev.getptr()

        self.dev.fileno()



    def test_play_sound_file(self):

        path = findfile("audiotest.au")

        fp = open(path, 'r')

        size, enc, rate, nchannels, extra = sunaudio.gethdr(fp)

        data = fp.read()

        fp.close()



        if enc != SND_FORMAT_MULAW_8:

            self.fail("Expect .au file with 8-bit mu-law samples")



        # convert the data to 16-bit signed

        data = audioop.ulaw2lin(data, 2)



        # set the data format

        if sys.byteorder == 'little':

            fmt = linuxaudiodev.AFMT_S16_LE

        else:

            fmt = linuxaudiodev.AFMT_S16_BE



        # set parameters based on .au file headers

        self.dev.setparameters(rate, 16, nchannels, fmt)

        self.dev.write(data)

        self.dev.flush()



    def test_errors(self):

        size = 8

        fmt = linuxaudiodev.AFMT_U8

        rate = 8000

        nchannels = 1

        try:

            self.dev.setparameters(-1, size, nchannels, fmt)

        except ValueError, err:

            self.assertEquals(err.args[0], "expected rate >= 0, not -1")

        try:

            self.dev.setparameters(rate, -2, nchannels, fmt)

        except ValueError, err:

            self.assertEquals(err.args[0], "expected sample size >= 0, not -2")

        try:

            self.dev.setparameters(rate, size, 3, fmt)

        except ValueError, err:

            self.assertEquals(err.args[0], "nchannels must be 1 or 2, not 3")

        try:

            self.dev.setparameters(rate, size, nchannels, 177)

        except ValueError, err:

            self.assertEquals(err.args[0], "unknown audio encoding: 177")

        try:

            self.dev.setparameters(rate, size, nchannels, linuxaudiodev.AFMT_U16_LE)

        except ValueError, err:

            self.assertEquals(err.args[0], "for linear unsigned 16-bit little-endian "

                              "audio, expected sample size 16, not 8")

        try:

            self.dev.setparameters(rate, 16, nchannels, fmt)

        except ValueError, err:

            self.assertEquals(err.args[0], "for linear unsigned 8-bit audio, expected "

                              "sample size 8, not 16")



def test_main():

    try:

        dsp = linuxaudiodev.open('w')

    except linuxaudiodev.error, msg:

        if msg.args[0] in (errno.EACCES, errno.ENOENT, errno.ENODEV, errno.EBUSY):

            raise TestSkipped(msg)

        raise

    dsp.close()

    run_unittest(LinuxAudioDevTests)



if __name__ == '__main__':

    test_main()

