hybridgroup-crubyflie 0.1.4

data/spec/crazyflie_spec.rb

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'crazyflie'
+
+
+describe Crazyflie do
+    before :all do
+    end
+    before :each do
+        @facility = double("Facility")
+        allow(Commander).to receive(:new).and_return(@facility)
+        allow(Param).to receive(:new).and_return(@facility)
+        allow(Log).to receive(:new).and_return(@facility)
+        allow(Commander).to receive(:new).and_return(@facility)
+        allow(@facility).to receive(:send_setpoint)
+        allow(@facility).to receive(:refresh_toc)
+        allow(@facility).to receive(:start_packet_reader_thread)
+        allow(@facility).to receive(:stop_packet_reader_thread)
+        @link = double("RadioDriver")
+        @uri = 'radio://0/0/1M'
+        allow(RadioDriver).to receive(:new).and_return(@link)
+        allow(@link).to receive(:connect)
+        allow(@link).to receive(:disconnect)
+        allow(@link).to receive(:receive_packet)
+        allow(@link).to receive(:uri).and_return(CrubyflieURI.new(@uri))
+
+        #allow_any_instance_of(CrubyflieLogger).to receive(:info)
+
+        @cf = Crazyflie.new()
+        @logger = @cf.logger
+
+        @default_pk = CRTPPacket.new(0b00001100, [1,2,3])
+    end
+
+
+    describe "#initialize" do
+        it "should initalize correctly" do
+            Crazyflie::CALLBACKS.each do |cb|
+                @cf.callbacks[cb].size.should >= 0
+            end
+
+            Crazyflie::CRTP_PORTS.keys().each do |port|
+                @cf.crtp_queues[port].should be_an_instance_of Queue
+            end
+        end
+    end
+
+
+    describe "#open_link" do
+        it "should connect to a crazyradio url" do
+            expect(@link).to receive(:receive_packet).and_return(@default_pk)
+            m = "Connection initiated to radio://0/0/1M"
+            m2 = "Disconnected from radio://0/0/1M"
+            m3 = "TOCs extracted from #{@uri}"
+            expect(@logger).to receive(:info).with(m)
+            expect(@logger).to receive(:info).with("Connected!")
+            expect(@logger).to receive(:info).with("Connection ready!")
+            expect(@logger).to receive(:info).with(m2)
+            expect(@logger).to receive(:debug).with(m3)
+
+
+            expect(@facility).to receive(:refresh_toc).twice
+            # only log facility gets this
+            expect(@facility).to receive(:start_packet_reader_thread).once
+            expect(@facility).to receive(:stop_packet_reader_thread).twice
+            @cf.open_link(@uri)
+            @cf.close_link()
+        end
+
+        it "should close the link if something happens" do
+            expect(@link).to receive(:connect).and_raise(Exception)
+            mesg = "Connection failed: Exception"
+            expect(@logger).to receive(:info).at_least(:once)
+            expect(@logger).to receive(:error).with(mesg)
+            expect(@facility).not_to receive(:refresh_toc)
+            @cf.open_link(@uri)
+            @cf.close_link()
+        end
+    end
+
+    describe "#close_link" do
+        it "should close the link" do
+            expect(@facility).to receive(:send_setpoint)
+            expect(@link).to receive(:disconnect)
+            m1 = "Connection initiated to radio://0/0/1M"
+            m2 = "Connection ready!"
+            m3 = "Disconnected from radio://0/0/1M"
+            expect(@logger).to receive(:debug)
+            expect(@logger).to receive(:info).with(m1)
+            expect(@logger).to receive(:info).with(m2)
+            expect(@logger).to receive(:info).with(m3)
+
+            @cf.open_link(@uri)
+            @cf.close_link()
+            @cf.crtp_queues.each do |k,q|
+                q.should be_empty
+            end
+        end
+
+        it "should not break closing a non existing link" do
+            expect(@facility).not_to receive(:send_setpoint)
+            expect_any_instance_of(NilClass).not_to receive(:disconnect)
+            expect(@cf).not_to receive(:puts)
+            expect_any_instance_of(Thread).not_to receive(:kill)
+            expect(@logger).to receive(:info).with("Disconnected from nowhere")
+            @cf.close_link()
+        end
+    end
+
+    describe "#send_packet" do
+        it "should send a packet without expecting answer" do
+            expect(@cf).not_to receive(:setup_retry)
+            expect(@link).to receive(:send_packet).with(@default_pk)
+            expect(@logger).to receive(:info).at_least(:once)
+            expect(@logger).to receive(:debug)
+            @cf.open_link(@uri)
+            @cf.send_packet(@default_pk)
+            @cf.close_link()
+        end
+
+        it "should send a packet and set up a timer when expecting answer" do
+            pk = @default_pk
+            expect(@link).to receive(:send_packet).with(pk).at_least(:twice)
+            expect(@logger).to receive(:info).at_least(:once)
+            expect(@logger).to receive(:debug).at_least(:once)
+            @cf.open_link(@uri)
+            @cf.send_packet(@default_pk, true)
+            sleep 0.5
+            @cf.close_link()
+        end
+    end
+
+    describe "#receive_packet" do
+        it " should receive a packet, trigger callbacks" do
+            proc = Proc.new do
+                puts "port 0 ch 0 callback"
+            end
+
+            proc2 = Proc.new do |pk|
+                puts "Received packet"
+            end
+
+            @cf.callbacks[:received_packet][:log] = proc
+            @cf.callbacks[:received_packet][:log2] = proc2
+
+            allow_any_instance_of(Thread).to receive(:new).and_return(nil)
+            expect(@link).to receive(:receive_packet).and_return(@default_pk)
+            expect(proc).to receive(:call).with(@default_pk).at_least(:once)
+            expect(proc2).to receive(:call).with(@default_pk).at_least(:once)
+            expect(@cf.crtp_queues[:console]).to receive(:<<).once
+            expect(@logger).to receive(:info).at_least(:once)
+            expect(@logger).to receive(:debug)
+            @cf.open_link(@uri)
+            @cf.send(:receive_packet)
+            # Received packet comes on port 0 - console
+
+            @cf.close_link()
+        end
+    end
+end

data/spec/crazyradio_spec.rb

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'crazyradio/crazyradio'
+
+describe Crazyradio do
+    before :each do
+        @device = double("LIBUSB::Device")
+        @handle = double("LIBUSB::DevHandler")
+
+        allow(@device).to receive(:is_a?).and_return(LIBUSB::Device)
+        allow(@device).to receive(:open).and_return(@handle)
+        allow(@device).to receive(:serial_number).and_return("serial123")
+        allow(@device).to receive(:manufacturer).and_return("Bitcraze")
+        allow(@handle).to receive(:configuration=)
+        allow(@handle).to receive(:claim_interface)
+        tr_result = [1,2,3].pack('C*')
+        allow(@handle).to receive(:control_transfer).and_return(tr_result)
+        allow(@handle).to receive(:release_interface)
+        allow(@handle).to receive(:reset_device)
+        allow(@handle).to receive(:close)
+
+        @crazyradio = Crazyradio.new(@device)
+    end
+
+    describe "#initialize" do
+        it "should initialize the dongle correctly" do
+            settings = [:data_rate, :channel, :cont_carrier,
+             :address, :power, :arc, :ard_bytes]
+            ssize = settings.size
+            expect(@device).to receive(:open)
+            expect(@handle).to receive(:configuration=).with(1)
+            expect(@handle).to receive(:claim_interface).with(0)
+            expect(@handle).to receive(:control_transfer).exactly(ssize).times
+            crazyradio = Crazyradio.new(@device)
+            defaults = Crazyradio::DEFAULT_SETTINGS
+            settings.each do |setting|
+                crazyradio[setting].should == defaults[setting]
+            end
+        end
+
+        it "should not initialize with a nil device" do
+            expect { Crazyradio.new() }.to raise_error(USBDongleException,
+                                                       "Wrong USB device")
+        end
+    end
+
+    describe "#status" do
+        it "should return a status" do
+            allow(Crazyradio).to receive(:factory).and_return(@crazyradio)
+            status = "Found serial123 USB dongle from Bitcraze"
+            Crazyradio.status().should == status
+        end
+    end
+
+    describe "#close" do
+        it "should close the USB" do
+            expect(@handle).to receive(:release_interface).with(0)
+            expect(@handle).to receive(:reset_device)
+            #expect(@handle).to receive(:close)
+            @crazyradio.close()
+        end
+    end
+
+    describe "#has_fw_scan" do
+        it "should say false" do
+            @crazyradio.has_fw_scan.should be_false
+        end
+    end
+
+    describe "#scan_channels" do
+        it "should scan channels and return them" do
+            ack = RadioAck.new(true)
+            do_this = receive(:send_packet).with([0xFF]).and_return(ack)
+            allow(@crazyradio).to do_this
+            @crazyradio.scan_channels(0, 125).should == (0..125).to_a
+        end
+
+        it "should scan channels with fw_scan and return them" do
+            allow(@crazyradio).to receive(:has_fw_scan).and_return(true)
+            @crazyradio.scan_channels(0, 125).should == [1,2,3]
+        end
+
+        it "should not include bad channels in a scan" do
+            ack = RadioAck.new(false)
+            do_this = receive(:send_packet).with([0xFF]).and_return(ack)
+            allow(@crazyradio).to do_this
+            @crazyradio.scan_channels(0, 125).should == []
+        end
+    end
+
+    describe "#factory" do
+        it "should raise an exception if no dongles are found" do
+            context = double("Context")
+            expect(LIBUSB::Context).to receive(:new).and_return(context)
+            expect(context).to receive(:devices).and_return([])
+
+            expect { Crazyradio.factory() }.to raise_error(USBDongleException,
+                                                           "No dongles found")
+        end
+
+        it "should provide a new crazyradio item" do
+            context = double("Context")
+            expect(LIBUSB::Context).to receive(:new).and_return(context)
+            expect(context).to receive(:devices).and_return([@device])
+            Crazyradio.factory()
+        end
+    end
+
+    describe "#send_packet" do
+        it "should send a packet and get a response" do
+            dataout = { :endpoint => 1, :dataOut => [1,2,3,4,5].pack('C*')}
+            datain = { :endpoint => 0x81, :dataIn => 64}
+            response = ([0xFF] * 64).pack('C*')
+            do_this =  receive(:bulk_transfer)
+            expect(@handle).to do_this.with(dataout).and_return(response)
+            expect(@handle).to do_this.with(datain).and_return(response)
+
+            ack = @crazyradio.send_packet([1,2,3,4,5])
+            ack.should be_an_instance_of RadioAck
+            ack.ack.should == true
+            ack.data.should == [0xFF] * 63
+        end
+    end
+
+    describe "#[]=" do
+        it "should set a setting" do
+            expect(@crazyradio).to receive(:set_data_rate).with(58)
+            @crazyradio[:data_rate] = 58
+        end
+        it "should no set a bad setting" do
+            expect(@crazyradio).not_to receive(:set_data_rate)
+            expect(@crazyradio).not_to receive(:set_channel)
+            expect(@crazyradio).not_to receive(:set_arc)
+            expect(@crazyradio).not_to receive(:set_cont_carrier)
+            expect(@crazyradio).not_to receive(:set_address)
+            expect(@crazyradio).not_to receive(:set_power)
+            expect(@crazyradio).not_to receive(:set_ard_bytes)
+            @crazyradio[:abc] = 3
+            @crazyradio[:abc].should be_nil
+        end
+    end
+
+    describe "[]" do
+        it "should get a setting value" do
+            expected = Crazyradio::DEFAULT_SETTINGS[:channel]
+            @crazyradio[:channel].should == expected
+        end
+    end
+
+    describe "#apply_settings" do
+        it "should apply one setting" do
+            d = Crazyradio::DEFAULT_SETTINGS
+            expect(@crazyradio).to receive(:set_channel).with(d[:channel])
+            expect(@crazyradio).to receive(:set_data_rate).with(d[:data_rate])
+            expect(@crazyradio).to receive(:set_arc).with(d[:arc])
+            scr = :set_cont_carrier
+            expect(@crazyradio).to receive(scr).with(d[:cont_carrier])
+            expect(@crazyradio).to receive(:set_address).with(d[:address])
+            expect(@crazyradio).to receive(:set_power).with(d[:power])
+            expect(@crazyradio).to receive(:set_ard_bytes).with(d[:ard_bytes])
+            @crazyradio.apply_settings(:channel)
+            @crazyradio.apply_settings(:data_rate)
+            @crazyradio.apply_settings(:arc)
+            @crazyradio.apply_settings(:cont_carrier)
+            @crazyradio.apply_settings(:power)
+            @crazyradio.apply_settings(:ard_bytes)
+            @crazyradio.apply_settings(:address)
+        end
+
+        it "should apply all settings" do
+            d = Crazyradio::DEFAULT_SETTINGS
+            expect(@crazyradio).to receive(:set_channel).with(d[:channel])
+            expect(@crazyradio).to receive(:set_data_rate).with(d[:data_rate])
+            expect(@crazyradio).to receive(:set_arc).with(d[:arc])
+            scr = :set_cont_carrier
+            expect(@crazyradio).to receive(scr).with(d[:cont_carrier])
+            expect(@crazyradio).to receive(:set_address).with(d[:address])
+            expect(@crazyradio).to receive(:set_power).with(d[:power])
+            expect(@crazyradio).to receive(:set_ard_bytes).with(d[:ard_bytes])
+            @crazyradio.apply_settings()
+        end
+    end
+
+    describe "#send_vendor_setup" do
+        it "should make a control_transfer with the proper args set" do
+            args = {
+                :bmRequestType => LIBUSB::REQUEST_TYPE_VENDOR,
+                :bRequest      => 38,
+                :wValue        => 3,
+                :wIndex        => 2,
+                :dataOut       => ""
+            }
+            expect(@handle).to receive(:control_transfer).with(args)
+            @crazyradio.send(:send_vendor_setup, 38, 3, 2)
+        end
+    end
+
+    describe "#get_vendor_setup" do
+        it "should make a control_transfer with the proper args set" do
+            args = {
+                :bmRequestType => LIBUSB::REQUEST_TYPE_VENDOR | 0x80,
+                :bRequest      => 38,
+                :wValue        => 3,
+                :wIndex        => 2,
+                :dataIn       => 0
+            }
+            expect(@handle).to receive(:control_transfer).with(args)
+            resp = @crazyradio.send(:get_vendor_setup, 38, 3, 2)
+            resp.should == [1,2,3]
+        end
+    end
+end

data/spec/crtp_packet_spec.rb

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'driver/crtp_packet'
+
+describe CRTPPacket do
+    describe "#initalize" do
+        it "should initialize correctly a packet" do
+            header = 0b11101010 # channel 10; port 1110
+            payload = [1,2,3]
+            packet = CRTPPacket.new(header, payload)
+            packet.size.should == 3
+            packet.header.should == header
+            packet.data.should == payload
+            packet.channel.should == 0b10
+            packet.port.should == 0b1110
+        end
+    end
+
+    describe "#modify_header" do
+        it "should modify only with header if provided" do
+            header = 0b11101010 # channel 10; port 1110
+            payload = [1,2,3]
+            packet = CRTPPacket.new(header, payload)
+            packet.modify_header(0, 3, 4)
+            packet.header.should == 0
+            packet.channel.should == 0
+            packet.port.should == 0
+        end
+
+        it "should modify channel and port and set the header" do
+            channel = 0b10
+            port = 0b1101
+            payload = [1,2,3]
+            packet = CRTPPacket.new(0, payload)
+            packet.modify_header(nil, port, channel)
+            packet.header.should == 0b11010010
+            packet.channel.should == 0b10
+            packet.port.should == 0b1101
+        end
+    end
+
+    describe "#unpack" do
+        it "should return an empty package if data is empty or not array" do
+            CRTPPacket.unpack("abc").pack.should == [0]
+            CRTPPacket.unpack([]).pack.should == [0]
+        end
+
+        it "should unpack a data array correctly into header and data" do
+            packet = CRTPPacket.unpack([1,2,3])
+            packet.data.should == [2,3]
+            packet.header.should == 1
+        end
+    end
+
+    describe "#pack" do
+        it "should concat header and data" do
+            header = 0b11101010 # channel 10; port 1110
+            payload = [1,2,3]
+            packet = CRTPPacket.new(header, payload)
+            packet.pack.should == [0b11101010, 1, 2, 3]
+        end
+    end
+end

data/spec/crubyflie_logger_spec.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+describe Logging do
+    it "should provide a logger" do
+        include Logging
+        logger.should be_an_instance_of CrubyflieLogger
+    end
+end
+
+describe CrubyflieLogger do
+
+    it "should log to debug, info, warn" do
+        l = CrubyflieLogger.new(true)
+        expect($stderr).to receive(:puts).with("DEBUG: a")
+        expect($stdout).to receive(:puts).with("INFO: a")
+        expect($stderr).to receive(:puts).with("ERROR: a")
+        expect($stderr).to receive(:puts).with("WARNING: a")
+        l.debug "a"
+        l.info "a"
+        l.warn "a"
+        l.error "a"
+    end
+end

data/spec/crubyflie_spec.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+$: << File.dirname(__FILE__)
+require 'rspec'
+require 'spec_helper'

data/spec/input_reader_spec.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+describe InputReader do
+
+    before :each do
+        @sdl_joystick = double("Joystick")
+        allow(SDL::Joystick).to receive(:update_all)
+        allow(SDL).to receive(:init).with(SDL::INIT_JOYSTICK)
+        allow(SDL::Joystick).to receive(:num).and_return(3)
+        allow(SDL::Joystick).to receive(:open).and_return(@sdl_joystick)
+        allow(SDL::Joystick).to receive(:index_name).and_return("My Joystick")
+        allow(SDL::Joystick).to receive(:poll).with(false)
+        expect(SDL::Joystick).not_to receive(:poll).with(true)
+        path = File.join(File.dirname(__FILE__), 'joystick_cfg.yaml')
+        @joystick = Joystick.new(path)
+
+        @logger = @joystick.logger
+        allow(@logger).to receive(:info)
+        @joystick.init()
+
+        @cf = double("Crazyflie")
+    end
+
+    describe "#read_input" do
+        it "should read axis and buttons" do
+            do_this = receive(:axis).and_return(0,32768,0,-32767)
+            do_this = do_this.exactly(4).times
+            expect(@sdl_joystick).to do_this
+
+            expect(@sdl_joystick).to receive(:button) { |arg|
+                false
+            }.twice
+
+            @joystick.read_input()
+            @joystick.axis_readings.should == {
+                :roll => 0,
+                :pitch => -30,
+                :yaw => 0,
+                :thrust => 49900
+            }
+
+            @joystick.button_readings.should == {
+                :switch_xmode => 0,
+                :close_link => 0
+            }
+        end
+    end
+
+
+    describe "#apply_input" do
+        it "should apply the read input to an active crazyflie" do
+            do_this = receive(:axis).and_return(0,32768,0,-32767)
+            do_this = do_this.exactly(4).times
+            expect(@sdl_joystick).to do_this
+
+            expect(@sdl_joystick).to receive(:button) { |arg|
+                false
+            }.twice
+
+            expect(@cf).to receive(:active?).and_return(true).twice
+            cmder = double("Commander")
+            expect(@cf).to receive(:commander).and_return(cmder)
+            expect(cmder).to receive(:send_setpoint).with(0, -30, 0,
+                                                          49900, false)
+            @joystick.read_input()
+            @joystick.apply_input(@cf)
+        end
+
+        it "should not send commands to a non active crazyflie" do
+            do_this = receive(:axis).and_return(0,32768,0,-32767)
+            do_this = do_this.exactly(4).times
+            expect(@sdl_joystick).to do_this
+
+            expect(@sdl_joystick).to receive(:button) { |arg|
+                false
+            }.twice
+
+            expect(@cf).to receive(:active?).and_return(false)
+            expect(@cf).not_to receive(:commander)
+            @joystick.read_input()
+            @joystick.apply_input(@cf)
+        end
+
+        it "should close the link to the crazyflie" do
+            do_this = receive(:axis).and_return(0,32768,0,-32767)
+            do_this = do_this.exactly(4).times
+            expect(@sdl_joystick).to do_this
+
+            expect(@sdl_joystick).to receive(:button) { |arg|
+                arg == 0 ? false : true
+            }.twice
+
+            expect(@cf).to receive(:active?).and_return(true, false).twice
+            expect(@cf).not_to receive(:commander)
+            expect(@cf).to receive(:close_link)
+            @joystick.read_input()
+            @joystick.apply_input(@cf)
+        end
+
+        it "should enable xmode" do
+            do_this = receive(:axis).and_return(0,32768,0,-32767)
+            do_this = do_this.exactly(4).times
+            expect(@sdl_joystick).to do_this
+
+            expect(@sdl_joystick).to receive(:button) { |arg|
+                arg == 1 ? false : true
+            }.twice
+
+            expect(@cf).to receive(:active?).and_return(true).twice
+            cmder = double("Commander")
+            expect(@cf).to receive(:commander).and_return(cmder)
+            expect(cmder).to receive(:send_setpoint).with(0, -30, 0,
+                                                          49900, true)
+            @joystick.read_input()
+            @joystick.apply_input(@cf)
+            @joystick.xmode.should == true
+        end
+    end
+
+end