def test_main_noCmdArgs(self, mock_midas, mock_sys, mock_logscanstop,
                            mock_logscanvarstep, mock_logscanstart,
                            mock_ChangeTune, mock_TuneSwitch, mock_Scan2D,
                            mock_Scan1D, mock_time, mock_logswitchedtune,
                            mock_logscanerror):
        mocks = [mock_midas, mock_sys, mock_logscanstop,
                 mock_logscanvarstep, mock_logscanstart,
                 mock_ChangeTune, mock_TuneSwitch, mock_Scan2D,
                 mock_Scan1D, mock_time, mock_logswitchedtune,
                 mock_logscanerror]

        # Test if PerlRC is not active
        mock_midas.varget.side_effect = ['n']
        # Set sys.argv = None, since it's not populated
        mock_sys.argv.side_effect = None

        prc.main()

        mock_ChangeTune.assert_not_called()
        mock_logswitchedtune.assert_not_called()
        mock_midas.varset.assert_not_called()
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_not_called()
        mock_logscanvarstep.assert_not_called()
        mock_logscanstop.assert_not_called()
        mock_time.sleep.assert_not_called()
        mock_midas.starting.assert_not_called()
        mock_logscanerror.assert_not_called()

        map(lambda x: x.reset_mock(), mocks)

        # Test if PrelRC is active
        mock_midas.varget.side_effect = ['y', 'Scan1D']
        mock_sys.argv.side_effect = ['']
        mock_Scan1D.return_value = "called"

        prc.main()

        mock_Scan1D.assert_called_once_with()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_called_once_with()
        mock_logscanvarstep.assert_called_with("called")
        mock_logscanstop.assert_called_with()
        mock_time.sleep.assert_called_with(1)
        mock_midas.startrun.assert_called_with()
        mock_logscanerror.assert_not_called()
        mock_midas.sendmessage.assert_not_called()
    def test_main_cmdlineArg(self, mock_midas, mock_sys, mock_logscanstop,
                             mock_logscanvarstep, mock_logscanstart,
                             mock_ChangeTune, mock_TuneSwitch, mock_Scan2D,
                             mock_Scan1D, mock_time, mock_logswitchedtune,
                             mock_logscanerror):
        mocks = [mock_midas, mock_sys, mock_logscanstop,
                 mock_logscanvarstep, mock_logscanstart,
                 mock_ChangeTune, mock_TuneSwitch, mock_Scan2D,
                 mock_Scan1D, mock_time, mock_logswitchedtune,
                 mock_logscanerror]
        # First test starting a PerlRC scan
        mock_sys.argv = ["ProgramName", "start"]

        # Test with Scan1D
        mock_midas.varget.side_effect = ["n", "Scan1D"]

        mock_Scan1D.return_value = "called"

        # call main()
        prc.main()

        mock_midas.varset.assert_called_with(prc.RCActive, 'y')
        mock_Scan1D.assert_called_once_with()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_called_once_with()
        mock_logscanvarstep.assert_called_once_with("called")
        mock_logscanstop.assert_called_once_with()
        mock_time.sleep.assert_called_once_with(1)
        mock_midas.startrun.assert_called_once_with()

        map(lambda x: x.reset_mock(), mocks)

        # First test starting a PerlRC scan
        mock_sys.argv = ["ProgramName", "start"]

        # Test with Scan2D
        mock_midas.varget.side_effect = ["n", "Scan2D"]

        mock_Scan2D.return_value = "called"

        # call main()
        prc.main()

        mock_midas.varset.assert_called_with(prc.RCActive, 'y')
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_called_once_with()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_called_once_with()
        mock_logscanvarstep.assert_called_once_with("called")
        mock_logscanstop.assert_called_once_with()
        mock_time.sleep.assert_called_once_with(1)
        mock_midas.startrun.assert_called_once_with()

        map(lambda x: x.reset_mock(), mocks)

        # First test starting a PerlRC scan
        mock_sys.argv = ["ProgramName", "start"]

        # Test with Scan2D
        mock_midas.varget.side_effect = ["n", "TuneSwitch"]

        mock_TuneSwitch.return_value = "called"

        # call main()
        prc.main()

        mock_midas.varset.assert_called_with(prc.RCActive, 'y')
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_called_once_with()
        mock_logscanstart.assert_called_once_with()
        mock_logscanvarstep.assert_called_once_with("called")
        mock_logscanstop.assert_called_once_with()
        mock_time.sleep.assert_called_once_with(1)
        mock_midas.startrun.assert_called_once_with()

        map(lambda x: x.reset_mock(), mocks)

        # Scan1D/Scan2D/TuneSwitch raises an Exception
        mock_sys.argv = ["ProgramName", "start"]
        mock_midas.varget.side_effect = ["n", "TuneSwitch"]

        mock_TuneSwitch.side_effect = Exception

        # call main()
        prc.main()

        expected = [mock.call(prc.RCActive, 'y'),
                    mock.call(prc.RCActive, 'n')]

        self.assertEqual(mock_midas.varset.call_args_list, expected)

        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_called_once_with()
        mock_logscanstart.assert_not_called()
        mock_logscanvarstep.assert_not_called()
        mock_logscanstop.assert_not_called()
        mock_time.sleep.assert_not_called()
        mock_midas.startrun.assert_not_called()
        mock_logscanerror.assert_called_once_with()
        self.assertEqual(mock_midas.sendmessage.call_count, 1)

        map(lambda x: x.reset_mock(), mocks)

        # Stopping a PerlRC scan
        mock_sys.argv = ["ProgramName", "stop"]

        mock_midas.varget.side_effect = ["y"]

        prc.main()

        mock_midas.varset.assert_called_once_with(prc.RCActive, 'n')
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_not_called()
        mock_logscanvarstep.assert_not_called()
        mock_logscanstop.assert_not_called()
        mock_time.sleep.assert_not_called()
        mock_midas.starting.assert_not_called()

        map(lambda x: x.reset_mock(), mocks)

        # Changing a tune
        mock_sys.argv = ["ProgramName", "tune", "tuneName"]

        mock_midas.varget.side_effect = ["n"]

        prc.main()

        mock_ChangeTune.assert_called_once_with("tuneName")
        mock_logswitchedtune.assert_called_once_with("tuneName")
        mock_midas.varset.assert_not_called()
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_not_called()
        mock_logscanvarstep.assert_not_called()
        mock_logscanstop.assert_not_called()
        mock_time.sleep.assert_not_called()
        mock_midas.starting.assert_not_called()

        map(lambda x: x.reset_mock(), mocks)

        # Changing a tune
        mock_sys.argv = ["ProgramName", "tune", "tuneName"]

        mock_midas.varget.side_effect = ["n"]
        mock_ChangeTune.side_effect = Exception

        prc.main()

        mock_ChangeTune.assert_called_once_with("tuneName")
        mock_logswitchedtune.assert_called_once_with("tuneName", True)
        mock_midas.varset.assert_not_called()
        mock_Scan1D.assert_not_called()
        mock_Scan2D.assert_not_called()
        mock_TuneSwitch.assert_not_called()
        mock_logscanstart.assert_not_called()
        mock_logscanvarstep.assert_not_called()
        mock_logscanstop.assert_not_called()
        mock_time.sleep.assert_not_called()
        mock_midas.starting.assert_not_called()