haiku/docs/develop/midi/testing.rst

Testing the Midi Kit
====================

Most of the OpenBeOS source code has unit tests in the current/src/tests
directory. I looked into building CppUnit tests for the midi2 kit, but
decided that it doesn't really make much sense. Unit tests work best if
you can test something in isolation, but in the case of the midi2 kit
this is very hard to achieve. Because the classes from libmidi2.so
always need to talk to the midi_server, the tests depend on too many
external factors. The available endpoints, for example, will differ from
system to system. The spray and hook functions are difficult to test
this way, too.

So instead of a CppUnit test suite, here is a list of manual tests that
I performed when developing the midi2 kit:

--------------

Registering the application
---------------------------

*Required:* Client app that calls BMidiRoster::MidiRoster()

-  When a client app starts, it should first receive mNEW notifications
   for all endpoints in the system (even unregistered remotes), followed
   by mCON notifications for all connections in the system (even those
   between two unregistered local endpoints from another app).

-  Send invalid Mapp message (without messenger). The midi_server
   ignores the request, and the client app blocks forever.

-  Fake a delivery error for the mNEW notifications and the mAPP reply.
   (Add a snooze() in the midi_server's OnRegisterApplication(). While
   it is snoozing, Ctrl-C the client app. Now the server can't deliver
   the message and will unregister the application again.)

-  Kill the server. Start the client app. It should realize that the
   server is not running, and return from MidiRoster(); it does not
   block forever.

-  Note: The server does not protect against sending two or more Mapp
   messages; it will add a new app_t object to the roster and it will
   also send out the mNEW and mCON notifications again.

-  Verify that when the client app quits, the BMidiRoster instance is
   destroyed by the BMidiRosterKiller. The BMidiRosterLooper is also
   destroyed, along with any endpoint objects from its list. We don't
   destroy endpoints with a refcount > 0, but print a warning message on
   stderr instead.

-  When the app quits before it has created a BMidiRoster instance, the
   BMidiRosterKiller should do nothing.

--------------

Creating endpoints
------------------

*Required:* Client app that creates a new BMidiLocalProducer and/or
BMidiLocalConsumer

-  Send invalid Mnew message (missing fields). The server will return an
   error code.

-  Don't send reply from midi_server. The client receives a B_NO_REPLY
   error.

-  If something goes wrong creating a new local endpoint, you still get
   a new BMidiEndpoint object (but it is not added to
   BMidiRosterLooper's internal list of endpoints). Verify that its ID()
   function returns 0, and IsValid() returns false. Verify that you can
   Release() it without crashing into the debugger (i.e. the reference
   count of the new object should be 1).

-  Snooze in midi_server's OnCreateEndpoint() before sending reply to
   client to simulate heavy processor load. Client should timeout. When
   done snoozing, server fails to deliver the reply because the client
   is no longer listening, and it unregisters the app.

-  Note: if you kill the client app with Ctrl-C before the server has
   sent its reply, SendReply() still returns okay, and the midi_server
   adds the endpoint, even though the corresponding app is dead. There
   is not much we can do to prevent that (but it is not really a big
   deal).

-  Start the test app from two different Terminals. Verify that the new
   local endpoint of app1 is added to the BMidiRosterLooper's list of
   endpoints, and that its "isLocal" flag is true. Verify that when you
   start the second app, it immediately receives mNEW notifications for
   the first app's endpoints. It should also create BMidiEndpoint proxy
   objects for these endpoints with "isLocal" set to false, and add them
   its own list. Vice versa for the endpoints that app2 creates. Verify
   that the "registered" field in the mNEW notification is false,
   because newly created endpoints are not registered yet. The
   "properties" field should contain an empty message.

-  Start server. Start client app. The app makes new endpoints and the
   server adds them to the roster. Ctrl-C the app. Start client app
   again. The new client first receives mNEW notifications for the old
   app's endpoints. When the new app tries to create its own endpoints,
   the server realizes that the old app is dead, and sends mDEL
   notifications for the now-defunct endpoints.

-  The test app should now create 2 endpoints. Let the midi_server
   snooze during the second create message, so the app times out. The
   server now unregisters the app and purges its first endpoint (which
   was successfully created).

-  The test app should now create 3 endpoints. Let the midi_server
   snooze during the second create message, so the app times out. (It
   also times out when sending the create request for the 3rd endpoint,
   because the server is still snoozing.) Because it cannot send a reply
   for the 2nd create message, the server now unregisters the app and
   purges its first endpoint (which was successfully created). Then it
   processes the create request for the 3rd endpoint, but ignores it
   because the app is now no longer registered with the server.

-  Purging endpoints. The test app should now create 2 endpoints. Let
   the midi_server snooze during the \_fourth\_ create message. Run the
   server. Run the test app. Run the test app again in a second
   Terminal. The server times out, and unregisters the second app. The
   first app should receive an mDEL notification. Repeat, but now the
   test app should make 3 endpoints and the server fails on the
   \_sixth\_ endpoint. The first app now receives 2 mDEL notifications.

-  You should be allowed to pass NULL into the BMidiLocalProducer and
   BMidiLocalConsumer constructor.

-  Let the midi_server assign random IDs to new endpoints; the
   BMidiRosterLooper should sort the endpoints by their IDs when it adds
   them to its internal list.

--------------

Deleting endpoints
------------------

*Required:* client app that creates one or more endpoints and
Release()'s them

-  Verify that Acquire() increments the endpoint's refcount and
   Release() decrements it. When you Release() a local endpoint so its
   refcount becomes zero, the client sends an Mdel request to the
   server. When you Release() a local endpoint too many times, your app
   jumps into the debugger.

-  Send an Mdel request with an invalid ID to the server. Examples of
   invalid IDs: -1, 0, 1000 (or any other large number).

-  Start the test app from two different Terminals. Note that when one
   of the apps Release()'s its endpoints, the other receives
   corresponding mDEL notifications.

-  Snooze in midi_server's OnCreateEndpoint() before sending reply to
   "create endpoint" request. The client will timeout and the server
   will unregister the app. Now have the client Release() the endpoint.
   This sends a "delete endpoint" request to the server, which ignores
   the request because the app is no longer registered.

-  Override BMidiLocalProducer and BMidiLocalConsumer, and provide a
   public destructor. Call "delete prod; delete cons;" from your code,
   instead of using Release(). Your app should drop into the debugger.

-  Start the client app and let it make its endpoints. Kill the server.
   Release() the endpoints. The server doesn't run, so the Mdel request
   never arrives, but the BMidiEndpoint objects should be deleted
   regardless.

-  Start the test app from two different Terminals, and let them make
   their endpoints. Quit the apps (using the Deskbar's "Quit
   Application" menu item). Verify that both clean up and exit
   correctly. App1 removes its own endpoint from the BMidiRosterLooper's
   list of endpoints and sends an 'mDEL' message to the server, which
   passes it on to app2. In response, app2 removes the proxy object from
   its own list and deletes it. Again, vice versa for the endpoint from
   app2.

-  Start both apps again and wait until they have notified each other
   about the endpoints. Ctrl-C app1, and restart it. Verify that app1
   receives the 'mNEW' messages and creates proxies for these remote
   endpoints. Both apps should receive an 'mDEL' message for app1's old
   endpoint (because the midi_server realizes it no longer exists and
   purges it), and remove it from their lists accordingly.

--------------

Changing attributes
-------------------

*Required:* Client app that creates an endpoint and calls Register(),
Unregister(), SetName(), and SetLatency()

-  Send an Mchg request with an invalid ID to the server.

-  Register() a local endpoint that is already registered. This does not
   send a message to the server and always returns B_OK. Likewise for
   Unregister()ing a local endpoint that is not registered.

-  Register() or Unregister() a remote endpoint, or an invalid local
   endpoint. That should immediately return an error code.

-  Verify that BMidiRoster::Register() does the same thing as
   BMidiEndpoint::Register(). Also for BMidiRoster::Unregister() and
   BMidiEndpoint::Unregister().

-  If you pass NULL into BMidiRoster::Register() or Unregister(), the
   functions immediately return with an error code.

-  SetName() should ignore NULL names. When you call it on a remote
   endpoint, SetName() should do nothing. SetName() does not send a
   message if the new name is the same as the current name.

-  SetLatency() should ignore negative values. SetLatency() does not
   send a message if the new latency is the same as the current latency.
   (Since SetLatency() lives in BMidiLocalConsumer, you can never use it
   on remote endpoints.)

-  Kill the server after making the new endpoint, and call Register().
   The client app should return an error code. Also for Unregister(),
   SetName(), SetLatency(), and SetProperties().

-  Snooze in the midi_server's OnChangeEndpoint() before sending the
   reply to the client. Both sides will flag an error. No mCHG
   notifications will be sent. The server unregisters the app and purges
   its endpoints.

-  Verify that other apps will receive mCHG notifications when the test
   app successfully calls Register(), Unregister(), SetName(), and
   SetLatency(), and that they modify the corresponding BMidiEndpoint
   objects accordingly. Since clients are never notified when they
   change their own endpoints, they should ignore the notifications that
   concern local endpoints. Latency changes should be ignored if the
   endpoint is not a consumer.

-  Send an Mchg request with only the "midi:id" field, so no
   "midi:name", "midi:registered", "midi:latency", or "midi:properties".
   The server will still notify the other apps, although they will
   obviously ignore the notification, because it doesn't contain any
   useful data.

-  The Mchg request is overloaded to change several attributes. Verify
   that changing one of these attributes, such as the latency, does not
   overwrite/wipe out the others.

-  Start app1. Wait until it has created and registered its endpoint.
   Start app2. During the initial handshake, app2 should receive an
   'mNEW' message for app1's endpoint. Verify that the "refistered"
   field in this message is already true, and that this is passed on
   correctly to the new BMidiEndpoint proxy object.

-  GetProperties() should return NULL if the message parameter is NULL.

-  The properties of new endpoints are empty. Create a new endpoint and
   call GetProperties(). The BMessage that you receive should contain no
   fields.

-  SetProperties() should return NULL if the message parameter is NULL.
   It should return an error code if the endpoint is remote or invalid.
   It should work fine on local endpoints, registered or not.
   SetProperties() does not compare the contents of the new BMessage to
   the old, so it will always send out the change request.

-  If you Unregister() an endpoint that is connected, the connection
   should not be broken.

--------------

Consulting the roster
---------------------

*Required:* Client app that creates several endpoints, and registers
some of them (not all), and uses the BMidiRoster::FindEndpoint() etc
functions to examine the roster.

-  Verify that FindEndpoint() returns NULL if you pass it:

   -  invalid ID (localOnly = false)
   -  invalid ID (localOnly = true)
   -  remote non-registered endpoint (localOnly = false)
   -  remote non-registered endpoint (localOnly = true)
   -  remote registered endpoint (localOnly = true)

   | 

   Verify that FindEndpoint() returns a valid BMidiEndpoint object if
   you pass it:

   -  local non-registered endpoint (localOnly = false)
   -  local non-registered endpoint (localOnly = true)
   -  local registered endpoint (localOnly = false)
   -  local registered endpoint (localOnly = true)
   -  remote registered endpoint (localOnly = false)

   | 

-  Verify that FindConsumer() works just like FindEndpoint(), but that
   it also returns NULL if the endpoint with the specified ID is not a
   consumer. Likewise for FindProducer().

-  Verify that NextEndpoint() returns NULL if you pass it NULL. It also
   returns NULL if no more endpoints exist. Otherwise, it returns a
   BMidiEndpoint object, bumps the endpoint's reference count, and sets
   the "id" parameter to the ID of the endpoint. NextEndpoint() should
   never return local endpoints (registered or not), nor unregistered
   remote endpoints. Verify that negative "id" values also work.

-  Verify that you can safely call the Find and Next functions without
   having somehow initialized the BMidiRoster first (by making a new
   endpoint, for example). The functions themselves should call
   MidiRoster() and do the handshake with the server.

-  The Find and Next functions should bump the reference count of the
   BMidiEndpoint object that they return. However, they should not
   (inadvertently) modify the refcounts of any other endpoint objects.

-  Get a BMidiEndpoint proxy for a remote published endpoint. Release().
   Now it should not be removed from the endpoint list or even be
   deleted, even though its reference count dropped to zero.

-  Start app1. Start app2. App2 gets a BMidiEndpoint proxy for a remote
   endpoint from app1. Ctrl-C app1. Start app1 again. Now app2 receives
   an mDEL message for app1's old endpoint. Verify that the endpoint is
   removed from the endpoint list, but not deleted because its reference
   count isn't zero. If app2 now Release()s the endpoint, the
   BMidiEndpoint object should be deleted. Try again, but now Release()
   the endpoint before you Ctrl-C; now it should be deleted and removed
   from the list when you start app1 again.

--------------

Making/breaking connections
---------------------------

*Required:* Client app that creates a producer and consumer endpoint,
optionally registers them, consults the roster for remote endpoints, and
makes various kinds of connections.

-  Test the following for BMidiProducer::Connect():

   -  Connect(NULL)
   -  Connect(invalid consumer)
   -  Connect() using an invalid producer
   -  Send Mcon request with invalid IDs
   -  Kill the midi_server just before you Connect()
   -  Let the midi_server snooze, so the connect request times out
   -  Have the midi_server return an error result code
   -  On successful connect, verify that the consumer is added to the
      producer's list of endpoints
   -  Verify that you can make connections between 2 local endpoints, a
      local producer and a remote consumer, a remote producer and a
      local consumer, and two 2 remote endpoints. Test the local
      endpoints both registered and unregistered.
   -  2x Connect() on same consumer should give an error
   -  The other applications should receive an mCON notification, and
      adjust their own local rosters accordingly
   -  If you are calling Connect() on a local producer, its Connected()
      hook should be called. If you are calling Connect() on a remote
      producer, then its own application should call the Connected()
      hook.

   | 

-  Test the following for BMidiProducer::Disconnect():

   -  Disconnect(NULL)
   -  Disconnect(invalid consumer)
   -  Disconnect() using an invalid producer
   -  Send Mdis request with invalid IDs
   -  Kill the midi_server just before you Disconnect()
   -  Let the midi_server snooze, so the disconnect request times out
   -  Have the midi_server return an error result code
   -  On successful disconnect, verify that the consumer is removed from
      the producer's list of endpoints
   -  Verify that you can break connections between 2 local endpoints, a
      local producer and a remote consumer, a remote producer and a
      local consumer, and two 2 remote endpoints. Test the local
      endpoints both registered and unregistered.
   -  Disconnecting 2 endpoints that were not connected should give an
      error
   -  The other applications should receive an mDIS notification, and
      adjust their own local rosters accordingly
   -  If you are calling Disconnect() on a local producer, its
      Disconnected() hook should be called. If you are calling
      Disconnect() on a remote producer, then its own application should
      call the Disconnected() hook.

   | 

-  Make a connection on a local producer. Release() the producer. The
   other app should only receive an mDEL notification. Likewise if you
   have a connection with a local consumer and you Release() that.
   However, now all apps should throw away this consumer from the
   connection lists, invoking the Disconnected() hook of local
   producers. The same thing happens if you Ctrl-C the app and restart
   it. (Now the old endpoints are purged.)

-  BMidiProducer::IsConnected() should return false if you pass NULL or
   an invalid consumer.

-  BMidiProducer::Connections() should return a new BList every time you
   call it. The objects in this list are the BMidiConsumers that are
   connected to this producer; verify that their reference counts are
   bumped for every call to Connections().

--------------

Watching
--------

*Required:* Client app that creates local consumer and producer
endpoints, and calls Register(), Unregister(), SetName(), SetLatency(),
and SetProperties(). It should also make and break connections.

-  When you call StartWatching(), you should receive B_MIDI_EVENT
   notifications for all remote registered endpoints and the connections
   between them. You will get no notifications for local endpoints, or
   for any connections that involve unregistered endpoints. The
   BMidiRosterLooper should make a copy of the BMessenger, so when the
   client destroys the original messenger, you will still receive
   notifications. Verify that calling StartWatching() with the same
   BMessenger twice in a row will also send the initial set of
   notifications twice. StartWatching(NULL) should be ignored and does
   not remove the current messenger.

-  Run the client app from two different Terminals. Verify that you
   receive properly formatted B_MIDI_EVENT notifications when the other
   app changes the attributes of its *registered* endpoints with the
   various Set() functions. You should also receive notifications if the
   app Register()s or Unregister()s its endpoints. That app that makes
   these changes does not receive the notifications.

-  Run the client app from two different Terminals. Verify that you
   receive properly formatted B_MIDI_EVENT notifications when the apps
   make and break connections. Every app receives these connection
   notifications, whether the endpoints are published or not. The app
   that makes and breaks the connections does not receive any
   notifications.

-  StopWatching() should delete BMidiRosterLooper's BMessenger copy, if
   any. Verify that you no longer receive B_MIDI_EVENT notifications for
   remote endpoints after you have called StopWatching().

-  If the client is watching, and the BMidiRosterLooper receives an mDEL
   notification for a registered remote endpoint, it should also send an
   "unregistered" B_MIDI_EVENT to let the client know that this endpoint
   is no longer available. If the endpoint was connected to anything,
   you'll also receive "disconnected" B_MIDI_EVENTs.

-  If you get a "registered" event, and you do FindEndpoint() for that
   id, you'll get its BMidiEndpoint object. If you get an "unregistered"
   event, then FindEndpoint() returns NULL. So the events are send
   *after* the roster is modified.

--------------

Event tests
-----------

*Required:* Several client apps that create and register consumer
endpoints that override the various MIDI event hook functions, as well
as producer endpoints that spray MIDI events. Also useful is a tool that
lets you make connections between all these endpoints (PatchBay), and a
tool that lets you monitor the MIDI events (MidiMonitor).

-  BMidiLocalProducer's spray functions should only try to send
   something if there is one or more connected consumer. If the spray
   functions cannot deliver their events, they simply ignore that
   consumer until the next spray. (No connections are broken or
   anything.)

-  All spray functions except SprayData() should set the atomic flag to
   true, even SpraySystemExclusive().

-  When you send a sysex message using SpraySystemExclusive(), it should
   add 0xF0 in front of your data and 0xF7 at the back. When you call
   SprayData() instead, no bytes are added to the MIDI event data.

-  Verify that all events arrive correctly and that the latency is
   minimal, even when the load is heavy (i.e. many events are being
   sprayed to many different consumers).

-  Verify that the BMidiLocalConsumer destructor properly destroys the
   corresponding port and event thread before it returns.

-  BMidiLocalConsumer should ignore messages that are too small,
   addressed to another consumer, or otherwise invalid.

-  BMidiLocalConsumer's Data() hook should ignore all non-atomic events.
   The rest of the events, provided they contain the correct number of
   bytes for that kind of event, are passed on to the other hooks.

-  Hook a producer up to a consumer and call all SprayXXX() functions
   with a variety of arguments to make sure the correct hooks are being
   called with the correct values. Call SprayData() and
   SpraySystemExclusive() with NULL data and/or length 0.

-  Call GetProducerID() from one of BMidiLocalConsumer's hooks to verify
   that this indeed returns the ID of the producer that sprayed the
   event.

-  To test timeouts, first call SetTimeout(system_time() + 2000000),
   spray an event to the consumer, and wait 2 seconds. The consumer's
   Timeout() hook should now be called. Try again, but now spray
   multiple events to the consumer. The Timeout() hook should still be
   called after 2 seconds, measured from the moment the timeout was set.
   Replace the call to SetTimeout() with SetTimeout(0). After spraying
   the first event, you should immediately get the Timeout() signal,
   because the target time was set in the past. Verify that calling
   SetTimeout() only takes effect after at least one new event has been
   received.

--------------

Other tests
-----------

-  Kill the server. Now run a client app. It should recognize that the
   server isn't running, and return error codes on all operations. Also
   kill the server while the test app is running. From then on, the
   client app will return error codes on all operations. Also bring it
   back up again while the test app is still running. Now the client
   app's request messages will be delivered to the server again, but the
   server will ignore them, because our app did not register with this
   new instance of the server.

-  Start the midi_server and several client apps. Use PatchBay to make
   and break a whole bunch of connections. Quit PatchBay. Start it
   again. Now the same connections should show up. Run similar tests
   with MidiKeyboard. Also install VirtualMidi (and run the old
   midi_server for the time being) to get a whole bunch of fake MIDI
   devices.

-  *Regression bug:* After you quit one client app, another app fails to
   send request to the midi_server.

   *Required:* Client app that creates a new endpoint and registers it.
   In the app's destructor, it unregisters and releases the endpoint.

   *How to reproduce:* Run the app from two different Terminals. Ctrl-C
   app1. Start app1 again. From the Deskbar quit both apps at the same
   time (that is possible because app1 and app2 both have the same
   signature). When it tries to send the Unregister() request to the
   midi_server, app2 gives the error "Cannot send msg to server". The
   error code is "Bad Port ID", which means that the reply port is dead.
   The Mdel message from Release() is sent without any problems,
   however, because that expects no reply back. This is not the only way
   to reproduce the problem, but it seems to be the most reliable one.

   The reason this happens is because you kill app1. When app2 sends a
   synchronous request to the midi_server, the server re-used that same
   message to notify the other apps. (Because it already contained all
   the necessary fields.) But app1 is dead, the notification fails, and
   this (probably) wipes out the reply address in the message. I changed
   the midi_server to create new BMessages for the notifications, and
   was no longer able to reproduce the problem.