anchor.diff:      ?assertMatch(#ofp_message{type = features_reply, xid = RXID2}, Reply2),
       ?assertNot(meck:called(of_driver_handler_mock, handle_message, '_')).
   
  -unsupported_version({Socket, ConnTable}) ->
  -    % XXX
  -    ok.
  -
  -send_bad_message({Socket, ConnTable}) ->
  +send_unsupported_version({_Socket, ConnTable}) ->
  +    Connection = get_connection(ConnTable),
  +    BadMsg = (of_msg_lib:get_features(4))#ofp_message{version = -1},
  +    R = of_driver:send(Connection, BadMsg),
  +    ?assertMatch({error, unsupported_version}, R).
  +
  +sync_send_unsupported_version({Socket, ConnTable}) ->
  +    Connection = get_connection(ConnTable),
  +    BadMsg = (of_msg_lib:get_features(4))#ofp_message{version = -1},
  +    Future = future(of_driver, sync_send, [Connection, BadMsg]),
  +    {#ofp_message{type = barrier_request, xid = BXID}, <<>>} = receive_msg(Socket, <<>>),
  +    send_msg(Socket, barrier_reply(BXID)),
  +    ?assertMatch({error, unsupported_version}, wait_future(Future)).
  +
  +send_bad_message({_Socket, ConnTable}) ->
       Connection = get_connection(ConnTable),
       R = of_driver:send(Connection, #ofp_message{type = not_a_valid_message, version = 4}),
       ?assertMatch({error, {bad_message, _}}, R).
  
positive.code:     BadMsg = #ofp_message{type = not_a_valid_message, version = 4},
      R = of_driver:send_list(Connection, [GoodMsg, BadMsg]),
      ?assertMatch({error, [ok, {error, {bad_message, _}}]}, R),
      {#ofp_message{type = features_request, xid = RXID}, <<>>} = receive_msg(Socket, <<>>).
  
  sync_send_list_bad_message({Socket, ConnTable}) ->
      Connection = get_connection(ConnTable),
      GoodMsg = of_msg_lib:get_features(4),
      BadMsg = #ofp_message{type = not_a_valid_message, version = 4},
      Future = future(of_driver, sync_send_list, [Connection, [GoodMsg, BadMsg]]),
      {#ofp_message{type = features_request, xid = RXID}, Rest} = receive_msg(Socket, <<>>),
      {#ofp_message{type = barrier_request, xid = BXID}, <<>>} = receive_msg(Socket, Rest),
      send_msg(Socket, barrier_reply(BXID)),
      Reply = wait_future(Future),
  
negative.code:                                   ,{"sync_send_list", fun sync_send_list/1}
                                    ,{"sync_send_list_no_reply", fun sync_send_list_no_reply/1}
                                    ,{"multiple_sync_send", fun multiple_sync_send/1}
                                    ,{"send_unsupported_version", fun send_unsupported_version/1}
                                    ,{"sync_send_unsupported_version", fun sync_send_unsupported_version/1}
                                    ,{"send_bad_message", fun send_bad_message/1}
                                    ,{"sync_send_bad_message", fun sync_send_bad_message/1}
                                    ,{"send_list_bad_message", fun send_list_bad_message/1}
  