import unittest
import os
import sys
import time
import pygame
import pygame.midi
import pygame.compat
from pygame.locals import *
class MidiInputTest(unittest.TestCase):
def setUp(self):
pygame.midi.init()
in_id = pygame.midi.get_default_input_id()
if in_id != -1:
self.midi_input = pygame.midi.Input(in_id)
else:
self.midi_input = None
def tearDown(self):
if self.midi_input:
self.midi_input.close()
pygame.midi.quit()
def test_Input(self):
"""|tags: interactive|
"""
i = pygame.midi.get_default_input_id()
if self.midi_input:
self.assertEqual(self.midi_input.device_id, i)
# try feeding it an input id.
i = pygame.midi.get_default_output_id()
# can handle some invalid input too.
self.assertRaises(pygame.midi.MidiException, pygame.midi.Input, i)
self.assertRaises(pygame.midi.MidiException, pygame.midi.Input, 9009)
self.assertRaises(pygame.midi.MidiException, pygame.midi.Input, -1)
self.assertRaises(TypeError, pygame.midi.Input, "1234")
self.assertRaises(OverflowError, pygame.midi.Input, pow(2, 99))
def test_poll(self):
if not self.midi_input:
self.skipTest('No midi Input device')
self.assertFalse(self.midi_input.poll())
# TODO fake some incoming data
pygame.midi.quit()
self.assertRaises(RuntimeError, self.midi_input.poll)
# set midi_input to None to avoid error in tearDown
self.midi_input = None
def test_read(self):
if not self.midi_input:
self.skipTest('No midi Input device')
read = self.midi_input.read(5)
self.assertEqual(read, [])
# TODO fake some incoming data
pygame.midi.quit()
self.assertRaises(RuntimeError, self.midi_input.read, 52)
# set midi_input to None to avoid error in tearDown
self.midi_input = None
def test_close(self):
if not self.midi_input:
self.skipTest('No midi Input device')
self.assertIsNotNone(self.midi_input._input)
self.midi_input.close()
self.assertIsNone(self.midi_input._input)
class MidiOutputTest(unittest.TestCase):
def setUp(self):
pygame.midi.init()
m_out_id = pygame.midi.get_default_output_id()
if m_out_id != -1:
self.midi_output = pygame.midi.Output(m_out_id)
else:
self.midi_output = None
def tearDown(self):
if self.midi_output:
self.midi_output.close()
pygame.midi.quit()
def test_Output(self):
"""|tags: interactive|
"""
i = pygame.midi.get_default_output_id()
if self.midi_output:
self.assertEqual(self.midi_output.device_id, i)
# try feeding it an input id.
i = pygame.midi.get_default_input_id()
# can handle some invalid input too.
self.assertRaises(pygame.midi.MidiException, pygame.midi.Output, i)
self.assertRaises(pygame.midi.MidiException, pygame.midi.Output, 9009)
self.assertRaises(pygame.midi.MidiException, pygame.midi.Output, -1)
self.assertRaises(TypeError, pygame.midi.Output,"1234")
self.assertRaises(OverflowError, pygame.midi.Output, pow(2,99))
def test_note_off(self):
"""|tags: interactive|
"""
if self.midi_output:
out = self.midi_output
out.note_on(5, 30, 0)
out.note_off(5, 30, 0)
with self.assertRaises(ValueError) as cm:
out.note_off(5, 30, 25)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
with self.assertRaises(ValueError) as cm:
out.note_off(5, 30, -1)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
def test_note_on(self):
"""|tags: interactive|
"""
if self.midi_output:
out = self.midi_output
out.note_on(5, 30, 0)
out.note_on(5, 42, 10)
with self.assertRaises(ValueError) as cm:
out.note_on(5, 30, 25)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
with self.assertRaises(ValueError) as cm:
out.note_on(5, 30, -1)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
def test_set_instrument(self):
if not self.midi_output:
self.skipTest('No midi device')
out = self.midi_output
out.set_instrument(5)
out.set_instrument(42, channel=2)
with self.assertRaises(ValueError) as cm:
out.set_instrument(-6)
self.assertEqual(str(cm.exception), "Undefined instrument id: -6")
with self.assertRaises(ValueError) as cm:
out.set_instrument(156)
self.assertEqual(str(cm.exception), "Undefined instrument id: 156")
with self.assertRaises(ValueError) as cm:
out.set_instrument(5, -1)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
with self.assertRaises(ValueError) as cm:
out.set_instrument(5, 16)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
def test_write(self):
if not self.midi_output:
self.skipTest('No midi device')
out = self.midi_output
out.write([[[0xc0, 0, 0], 20000]])
# is equivalent to
out.write([[[0xc0], 20000]])
# example from the docstring :
# 1. choose program change 1 at time 20000 and
# 2. send note 65 with velocity 100 500 ms later
out.write([
[[0xc0, 0, 0], 20000],
[[0x90, 60, 100], 20500]
])
out.write([])
verrry_long = [[[0x90, 60, i % 100], 20000 + 100 * i] for i in range(1024)]
out.write(verrry_long)
too_long = [[[0x90, 60, i % 100], 20000 + 100 * i] for i in range(1025)]
self.assertRaises(IndexError, out.write, too_long)
# test wrong data
with self.assertRaises(TypeError) as cm:
out.write('Non sens ?')
error_msg = "unsupported operand type(s) for &: 'str' and 'int'"
self.assertEqual(str(cm.exception), error_msg)
with self.assertRaises(TypeError) as cm:
out.write(["Hey what's that?"])
self.assertEqual(str(cm.exception), error_msg)
def test_write_short(self):
"""|tags: interactive|
"""
if not self.midi_output:
self.skipTest('No midi device')
out = self.midi_output
# program change
out.write_short(0xc0)
# put a note on, then off.
out.write_short(0x90, 65, 100)
out.write_short(0x80, 65, 100)
out.write_short(0x90)
def test_write_sys_ex(self):
if not self.midi_output:
self.skipTest('No midi device')
out = self.midi_output
out.write_sys_ex(pygame.midi.time(),
[0xF0, 0x7D, 0x10, 0x11, 0x12, 0x13, 0xF7])
def test_pitch_bend(self):
# FIXME : pitch_bend in the code, but not in documentation
if not self.midi_output:
self.skipTest('No midi device')
out = self.midi_output
with self.assertRaises(ValueError) as cm:
out.pitch_bend(5, channel=-1)
self.assertEqual(str(cm.exception), "Channel not between 0 and 15.")
with self.assertRaises(ValueError) as cm:
out.pitch_bend(5, channel=16)
with self.assertRaises(ValueError) as cm:
out.pitch_bend(-10001, 1)
self.assertEqual(str(cm.exception), "Pitch bend value must be between "
"-8192 and +8191, not -10001.")
with self.assertRaises(ValueError) as cm:
out.pitch_bend(10665, 2)
def test_close(self):
if not self.midi_output:
self.skipTest('No midi device')
self.assertIsNotNone(self.midi_output._output)
self.midi_output.close()
self.assertIsNone(self.midi_output._output)
def test_abort(self):
if not self.midi_output:
self.skipTest('No midi device')
self.assertEqual(self.midi_output._aborted, 0)
self.midi_output.abort()
self.assertEqual(self.midi_output._aborted, 1)
class MidiModuleTest(unittest.TestCase):
def setUp(self):
pygame.midi.init()
def tearDown(self):
pygame.midi.quit()
def test_MidiException(self):
def raiseit():
raise pygame.midi.MidiException('Hello Midi param')
with self.assertRaises(pygame.midi.MidiException) as cm:
raiseit()
self.assertEqual(cm.exception.parameter, 'Hello Midi param')
def test_get_count(self):
c = pygame.midi.get_count()
self.assertIsInstance(c, int)
self.assertTrue(c >= 0)
def test_get_default_input_id(self):
midin_id = pygame.midi.get_default_input_id()
# if there is a not None return make sure it is an int.
self.assertIsInstance(midin_id, int)
self.assertTrue(midin_id >= -1)
pygame.midi.quit()
self.assertRaises(RuntimeError, pygame.midi.get_default_output_id)
def test_get_default_output_id(self):
c = pygame.midi.get_default_output_id()
self.assertIsInstance(c, int)
self.assertTrue(c >= -1)
pygame.midi.quit()
self.assertRaises(RuntimeError, pygame.midi.get_default_output_id)
def test_get_device_info(self):
an_id = pygame.midi.get_default_output_id()
if an_id != -1:
interf, name, input, output, opened = pygame.midi.get_device_info(an_id)
self.assertEqual(output, 1)
self.assertEqual(input, 0)
self.assertEqual(opened, 0)
an_in_id = pygame.midi.get_default_input_id()
if an_in_id != -1:
r = pygame.midi.get_device_info(an_in_id)
# if r is None, it means that the id is out of range.
interf, name, input, output, opened = r
self.assertEqual(output, 0)
self.assertEqual(input, 1)
self.assertEqual(opened, 0)
out_of_range = pygame.midi.get_count()
for num in range(out_of_range):
self.assertIsNotNone(pygame.midi.get_device_info(num))
info = pygame.midi.get_device_info(out_of_range)
self.assertIsNone(info)
def test_init(self):
pygame.midi.quit()
self.assertRaises(RuntimeError, pygame.midi.get_count)
# initialising many times should be fine.
pygame.midi.init()
pygame.midi.init()
pygame.midi.init()
pygame.midi.init()
self.assertTrue(pygame.midi.get_init())
def test_midis2events(self):
midi_data = ([[0xc0, 0, 1, 2], 20000],
[[0x90, 60, 100, 'blablabla'], 20000]
)
events = pygame.midi.midis2events(midi_data, 2)
self.assertEqual(len(events), 2)
for eve in events:
# pygame.event.Event is a function, but ...
self.assertEqual(eve.__class__.__name__, 'Event')
self.assertEqual(eve.vice_id, 2)
# FIXME I don't know what we want for the Event.timestamp
# For now it accepts it accepts int as is:
self.assertIsInstance(eve.timestamp, int)
self.assertEqual(eve.timestamp, 20000)
self.assertEqual(events[1].data3, 'blablabla')
def test_quit(self):
# It is safe to call this more than once.
pygame.midi.quit()
pygame.midi.init()
pygame.midi.quit()
pygame.midi.quit()
pygame.midi.init()
pygame.midi.init()
pygame.midi.quit()
self.assertFalse(pygame.midi.get_init())
def test_get_init(self):
# Already initialized as pygame.midi.init() was called in setUp().
self.assertTrue(pygame.midi.get_init())
def test_time(self):
mtime = pygame.midi.time()
self.assertIsInstance(mtime, int)
# should be close to 2-3... since the timer is just init'd.
self.assertTrue(0 <= mtime < 100)
def test_conversions(self):
""" of frequencies to midi note numbers and ansi note names.
"""
from pygame.midi import (
frequency_to_midi, midi_to_frequency, midi_to_ansi_note
)
self.assertEqual(frequency_to_midi(27.5), 21)
self.assertEqual(frequency_to_midi(36.7), 26)
self.assertEqual(frequency_to_midi(4186.0), 108)
self.assertEqual(midi_to_frequency(21), 27.5)
self.assertEqual(midi_to_frequency(26), 36.7)
self.assertEqual(midi_to_frequency(108), 4186.0)
self.assertEqual(midi_to_ansi_note(21), 'A0')
self.assertEqual(midi_to_ansi_note(102), 'F#7')
self.assertEqual(midi_to_ansi_note(108), 'C8')
if __name__ == '__main__':
unittest.main()