Index: src/sas/qtgui/GUITests.py
===================================================================
--- src/sas/qtgui/GUITests.py	(revision 57b7ee2a03730ca7183c233fa0fcae728926ee09)
+++ src/sas/qtgui/GUITests.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -28,4 +28,10 @@
 from UnitTesting import SlicerParametersTest
 
+# Perspectives
+import path_prepare
+from Perspectives.Fitting.UnitTesting import FittingWidgetTest
+from Perspectives.Fitting.UnitTesting import FittingPerspectiveTest
+
+
 def suite():
     suites = (
@@ -56,4 +62,6 @@
         unittest.makeSuite(SlicerModelTest.SlicerModelTest, 'test'),
         unittest.makeSuite(SlicerParametersTest.SlicerParametersTest, 'test'),
+        unittest.makeSuite(FittingPerspectiveTest.FittingPerspectiveTest, 'test'),
+        unittest.makeSuite(FittingWidgetTest.FittingWidgetTest, 'test'),
     )
     return unittest.TestSuite(suites)
Index: src/sas/qtgui/GuiManager.py
===================================================================
--- src/sas/qtgui/GuiManager.py	(revision cbcdd2c5b8d12554dc14f421d4dd36716db47864)
+++ src/sas/qtgui/GuiManager.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -182,5 +182,5 @@
             self._current_perspective.close()
         # Default perspective
-        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](manager=self, parent=self)
+        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](parent=self)
         self._workspace.workspace.addWindow(self._current_perspective)
         self._current_perspective.show()
Index: src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py
===================================================================
--- src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py	(revision cbcdd2c5b8d12554dc14f421d4dd36716db47864)
+++ src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -13,8 +13,7 @@
     """
     name = "Fitting" # For displaying in the combo box in DataExplorer
-    def __init__(self, manager=None, parent=None, data=None):
+    def __init__(self, parent=None, data=None):
         super(FittingWindow, self).__init__()
 
-        self.manager = manager
         self.parent = parent
         self._data = data
@@ -35,4 +34,6 @@
         self.setTabsClosable(True)
 
+        self.communicate = self.parent.communicator()
+
         # Initialize the first tab
         self.addFit(None)
@@ -43,12 +44,9 @@
         self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer)
 
-        #self.communicate = GuiUtils.Communicate()
-        self.communicate = self.parent.communicator()
-
     def addFit(self, data):
         """
         Add a new tab for passed data
         """
-        tab	= FittingWidget(manager=self.manager, parent=self.parent, data=data, id=self.maxIndex+1)
+        tab	= FittingWidget(parent=self.parent, data=data, id=self.maxIndex+1)
         self.tabs.append(tab)
         self.maxIndex += 1
Index: src/sas/qtgui/Perspectives/Fitting/FittingWidget.py
===================================================================
--- src/sas/qtgui/Perspectives/Fitting/FittingWidget.py	(revision cd312514d1a65fbaf4b9adfc4d61cd49c87be114)
+++ src/sas/qtgui/Perspectives/Fitting/FittingWidget.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -38,11 +38,6 @@
     Main widget for selecting form and structure factor models
     """
-    def __init__(self, manager=None, parent=None, data=None, id=1):
-        """
-
-        :param manager:
-        :param parent:
-        :return:
-        """
+    def __init__(self, parent=None, data=None, id=1):
+
         super(FittingWidget, self).__init__()
 
@@ -69,8 +64,9 @@
         self.tab_id = id
 
-        # Parameters
+        # Range parameters
         self.q_range_min = QMIN_DEFAULT
         self.q_range_max = QMAX_DEFAULT
         self.npts = NPTS_DEFAULT
+
         # Main Data[12]D holder
         self._data = None
@@ -88,23 +84,6 @@
         self._magnet_model = QtGui.QStandardItemModel()
 
-        # Set the proxy models for display
-        #   Main display
-        self._model_proxy = QtGui.QSortFilterProxyModel()
-        self._model_proxy.setSourceModel(self._model_model)
-        #self._model_proxy.setFilterRegExp(r"[^()]")
-
-        #   Proxy display
-        self._poly_proxy = QtGui.QSortFilterProxyModel()
-        self._poly_proxy.setSourceModel(self._poly_model)
-        self._poly_proxy.setFilterRegExp(r"[^()]")
-
-        #   Magnetism display
-        self._magnet_proxy = QtGui.QSortFilterProxyModel()
-        self._magnet_proxy.setSourceModel(self._magnet_model)
-        #self._magnet_proxy.setFilterRegExp(r"[^()]")
-
         # Param model displayed in param list
         self.lstParams.setModel(self._model_model)
-        #self.lstParams.setModel(self._model_proxy)
         self.readCategoryInfo()
         self.model_parameters = None
@@ -112,5 +91,5 @@
 
         # Poly model displayed in poly list
-        self.lstPoly.setModel(self._poly_proxy)
+        self.lstPoly.setModel(self._poly_model)
         self.setPolyModel()
         self.setTableProperties(self.lstPoly)
@@ -251,6 +230,5 @@
         structure_factors = ["None"]
         self.cbStructureFactor.clear()
-        for (structure_factor, _) in structure_factor_list:
-            structure_factors.append(structure_factor)
+        structure_factors = [factor[0] for factor in structure_factor_list]
         self.cbStructureFactor.addItems(sorted(structure_factors))
 
@@ -365,13 +343,8 @@
         If so, returns the name of the counter parameter and the number of shells
         """
-        iter_param = ""
-        iter_length = 0
-
         iter_params = self.getIterParams(model)
-        # pull out the iterator parameter name and length
-        if iter_params:
-            iter_length = iter_params[0].length
-            iter_param = iter_params[0].length_control
-        return (iter_param, iter_length)
+        # return the iterator parameter name and length
+        return (iter_params[0].length_control if iter_params else "",
+                iter_params[0].length if iter_params else 0)
 
     def addBackgroundToModel(self, model):
@@ -392,4 +365,7 @@
 
     def addCheckedListToModel(self, model, param_list):
+        """
+        Add a QItem to model. Makes the QItem checkable
+        """
         assert isinstance(model, QtGui.QStandardItemModel)
         item_list = [QtGui.QStandardItem(item) for item in param_list]
Index: src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py
===================================================================
--- src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py	(revision 6ee82dd39fa4473f41e7c35782a7b6b5ff339529)
+++ src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -1,4 +1,5 @@
 import sys
 import unittest
+import webbrowser
 
 from PyQt4 import QtGui
@@ -7,124 +8,99 @@
 from mock import MagicMock
 
+# set up import paths
+import sas.qtgui.path_prepare
+
 # Local
-from FittingPerspective import FittingWindow
+import sas.qtgui.GuiUtils as GuiUtils
+from sas.sasgui.guiframe.dataFitting import Data1D
+
+from sas.qtgui.Perspectives.Fitting.FittingPerspective import FittingWindow
 
 app = QtGui.QApplication(sys.argv)
 
 class FittingPerspectiveTest(unittest.TestCase):
-    """Test the Main Window GUI"""
+    '''Test the Fitting Perspective'''
     def setUp(self):
-        """Create the GUI"""
+        class dummy_manager(object):
+            def communicator(self):
+                return GuiUtils.Communicate()
+            def communicate(self):
+                return GuiUtils.Communicate()
 
-        self.widget = FittingWindow(None)
+        '''Create the perspective'''
+        self.widget = FittingWindow(dummy_manager())
 
     def tearDown(self):
-        """Destroy the GUI"""
+        '''Destroy the perspective'''
         self.widget.close()
         self.widget = None
 
     def testDefaults(self):
-        """Test the GUI in its default state"""
+        '''Test the GUI in its default state'''
         self.assertIsInstance(self.widget, QtGui.QWidget)
-        self.assertEqual(self.widget.windowTitle(), "Fitting")
-        self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed)
+        self.assertIn("Fit panel", self.widget.windowTitle())
+        self.assertEqual(self.widget.optimizer, "DREAM")
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 1)
+        self.assertEqual(self.widget.tabName(), "FitPage1")
 
-    def testSelectCategory(self):
-        """
-        Test if categories have been load properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+    def testAddTab(self):
+        '''Add a tab and test it'''
 
-        #Test loading from json categories
-        category_list = fittingWindow.master_category_dict.keys()
-        self.assertTrue("Cylinder" in category_list)
-        self.assertTrue("Ellipsoid" in category_list)
-        self.assertTrue("Lamellae" in category_list)
-        self.assertTrue("Paracrystal" in category_list)
-        self.assertTrue("Parallelepiped" in category_list)
-        self.assertTrue("Shape Independent" in category_list)
-        self.assertTrue("Sphere" in category_list)
+        # Add an empty tab
+        self.widget.addFit(None)
+        self.assertEqual(len(self.widget.tabs), 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
+        self.assertEqual(self.widget.maxIndex, 2)
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Ellipsoid"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Lamellae"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Paracrystal"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Parallelepiped"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Shape Independent"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Sphere"),-1)
+    def testCloseTab(self):
+        '''Delete a tab and test'''
+        # Add an empty tab
+        self.widget.addFit(None)
 
-        #Test what is current text in the combobox
-        self.assertTrue(fittingWindow.cbCategory.currentText(), "Cylinder")
+        # Remove the original tab
+        self.widget.tabCloses(1)
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
 
-    def testSelectModel(self):
-        """
-        Test if models have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Attemtp to remove the last tab
+        self.widget.tabCloses(1)
+        # The tab should still be there
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
 
-        #Test loading from json categories
-        model_list = fittingWindow.master_category_dict["Cylinder"]
-        self.assertTrue(['cylinder', True] in model_list)
-        self.assertTrue(['core_shell_cylinder', True] in model_list)
-        self.assertTrue(['barbell', True] in model_list)
-        self.assertTrue(['core_shell_bicelle', True] in model_list)
-        self.assertTrue(['flexible_cylinder', True] in model_list)
-        self.assertTrue(['flexible_cylinder_elliptical', True] in model_list)
-        self.assertTrue(['pearl_necklace', True] in model_list)
-        self.assertTrue(['capped_cylinder', True] in model_list)
-        self.assertTrue(['elliptical_cylinder', True] in model_list)
-        self.assertTrue(['pringle', True] in model_list)
-        self.assertTrue(['hollow_cylinder', True] in model_list)
-        self.assertTrue(['core_shell_bicelle_elliptical', True] in model_list)
-        self.assertTrue(['stacked_disks', True] in model_list)
+    def testAllowBatch(self):
+        '''Assure the perspective allows multiple datasets'''
+        self.assertTrue(self.widget.allowBatch())
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbModel.findText("cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("barbell"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder_elliptical"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("pearl_necklace"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("capped_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("elliptical_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("pringle"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("hollow_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle_elliptical"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("stacked_disks"),-1)
+    def testSetData(self):
+        ''' Assure that setting data is correct'''
+        with self.assertRaises(AssertionError):
+            self.widget.setData(None)
 
+        with self.assertRaises(AttributeError):
+            self.widget.setData("BOOP")
 
-    def testSelectPolydispersity(self):
-        """
-        Test if models have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Mock the datafromitem() call from FittingWidget
+        data = Data1D(x=[1,2], y=[1,2])
+        GuiUtils.dataFromItem = MagicMock(return_value=data)
 
-        #Test loading from json categories
-        fittingWindow.setModelModel("cylinder")
-        pd_index = fittingWindow.tableView_2.model().index(0,0)
-        self.assertEqual(str(pd_index.data().toString()), "Distribution of radius")
-        pd_index = fittingWindow.tableView_2.model().index(1,0)
-        self.assertEqual(str(pd_index.data().toString()), "Distribution of length")
+        item = QtGui.QStandardItem("test")
+        self.widget.setData([item])
 
-    def testSelectStructureFactor(self):
-        """
-        Test if structure factors have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Look at the data in tab
+        self.assertEqual(self.widget._model_item, item)
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("stickyhardsphere"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hayter_msa"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("squarewell"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hardsphere"),-1)
+        # First tab should accept data
+        self.assertEqual(len(self.widget.tabs), 1)
 
-        #Test what is current text in the combobox
-        self.assertTrue(fittingWindow.cbCategory.currentText(), "None")
+        # Add another set of data
+        self.widget.setData([item])
+
+        # Now we should have two tabs
+        self.assertEqual(len(self.widget.tabs), 2)
+
 
 if __name__ == "__main__":
Index: src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py
===================================================================
--- src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
+++ src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -0,0 +1,295 @@
+import sys
+import unittest
+
+from PyQt4 import QtGui
+from PyQt4 import QtTest
+from PyQt4 import QtCore
+from mock import MagicMock
+
+# set up import paths
+import sas.qtgui.path_prepare
+
+# Local
+from sas.qtgui.GuiUtils import *
+from sas.qtgui.Perspectives.Fitting.FittingWidget import *
+#from sas.qtgui.Perspectives.Fitting.FittingWidget import FittingWidget
+from sas.sasgui.guiframe.dataFitting import Data1D
+
+app = QtGui.QApplication(sys.argv)
+
+class dummy_manager(object):
+    def communicate(self):
+        return Communicate()
+
+class FittingWidgetTest(unittest.TestCase):
+    """Test the fitting widget GUI"""
+
+    def setUp(self):
+        """Create the GUI"""
+        self.widget = FittingWidget(dummy_manager())
+
+    def tearDown(self):
+        """Destroy the GUI"""
+        self.widget.close()
+        self.widget = None
+
+    def testDefaults(self):
+        """Test the GUI in its default state"""
+        self.assertIsInstance(self.widget, QtGui.QWidget)
+        self.assertEqual(self.widget.windowTitle(), "Fitting")
+        self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed)
+        self.assertIsInstance(self.widget.lstParams.model(), QtGui.QStandardItemModel)
+        self.assertIsInstance(self.widget.lstPoly.model(), QtGui.QStandardItemModel)
+        self.assertIsInstance(self.widget.lstMagnetic.model(), QtGui.QStandardItemModel)
+        self.assertFalse(self.widget.cbModel.isEnabled())
+        self.assertFalse(self.widget.cbStructureFactor.isEnabled())
+        self.assertFalse(self.widget.cmdFit.isEnabled())
+        self.assertTrue(self.widget.acceptsData())
+        self.assertFalse(self.widget.data_is_loaded)
+
+    def testSelectCategory(self):
+        """
+        Test if model categories have been loaded properly
+        """
+        fittingWindow =  self.widget
+
+        #Test loading from json categories
+        category_list = fittingWindow.master_category_dict.keys()
+
+        for category in category_list:
+            self.assertNotEqual(fittingWindow.cbCategory.findText(category),-1)
+
+        #Test what is current text in the combobox
+        self.assertEqual(fittingWindow.cbCategory.currentText(), CATEGORY_DEFAULT)
+
+    def testWidgetWithData(self):
+        """
+        Test the instantiation of the widget with initial data
+        """
+        data = Data1D(x=[1,2], y=[1,2])
+        GuiUtils.dataFromItem = MagicMock(return_value=data)
+        item = QtGui.QStandardItem("test")
+
+        widget_with_data = FittingWidget(dummy_manager(), data=[data], id=3)
+
+        self.assertEqual(widget_with_data.data, data)
+        self.assertTrue(widget_with_data.data_is_loaded)
+        self.assertTrue(widget_with_data.cmdFit.isEnabled())
+        self.assertFalse(widget_with_data.acceptsData())
+
+    def notestSelectModel(self):
+        """
+        Test if models have been loaded properly
+        :return:
+        """
+        fittingWindow =  self.widget
+
+        #Test loading from json categories
+        model_list = fittingWindow.master_category_dict["Cylinder"]
+        self.assertTrue(['cylinder', True] in model_list)
+        self.assertTrue(['core_shell_cylinder', True] in model_list)
+        self.assertTrue(['barbell', True] in model_list)
+        self.assertTrue(['core_shell_bicelle', True] in model_list)
+        self.assertTrue(['flexible_cylinder', True] in model_list)
+        self.assertTrue(['flexible_cylinder_elliptical', True] in model_list)
+        self.assertTrue(['pearl_necklace', True] in model_list)
+        self.assertTrue(['capped_cylinder', True] in model_list)
+        self.assertTrue(['elliptical_cylinder', True] in model_list)
+        self.assertTrue(['pringle', True] in model_list)
+        self.assertTrue(['hollow_cylinder', True] in model_list)
+        self.assertTrue(['core_shell_bicelle_elliptical', True] in model_list)
+        self.assertTrue(['stacked_disks', True] in model_list)
+
+        #Test for existence in combobox
+        self.assertNotEqual(fittingWindow.cbModel.findText("cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("barbell"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder_elliptical"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("pearl_necklace"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("capped_cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("elliptical_cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("pringle"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("hollow_cylinder"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle_elliptical"),-1)
+        self.assertNotEqual(fittingWindow.cbModel.findText("stacked_disks"),-1)
+
+
+    def testSelectPolydispersity(self):
+        """
+        Test if models have been loaded properly
+        :return:
+        """
+        fittingWindow =  self.widget
+
+        #Test loading from json categories
+        fittingWindow.setModelModel("cylinder")
+        pd_index = fittingWindow.lstPoly.model().index(0,0)
+        self.assertEqual(str(pd_index.data().toString()), "Distribution of radius")
+        pd_index = fittingWindow.lstPoly.model().index(1,0)
+        self.assertEqual(str(pd_index.data().toString()), "Distribution of length")
+
+    def testSelectStructureFactor(self):
+        """
+        Test if structure factors have been loaded properly
+        :return:
+        """
+        fittingWindow =  self.widget
+
+        #Test for existence in combobox
+        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("stickyhardsphere"),-1)
+        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hayter_msa"),-1)
+        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("squarewell"),-1)
+        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hardsphere"),-1)
+
+        #Test what is current text in the combobox
+        self.assertTrue(fittingWindow.cbCategory.currentText(), "None")
+
+    def testSignals(self):
+        """
+        Test the widget exmitted signals
+        """
+        pass
+
+    def  testSelectCategory(self):
+        """
+        Assure proper behaviour on changing category
+        """
+        pass
+
+    def testSelectModel(self):
+        """
+        Assure proper behaviour on changing model
+        """
+        pass
+
+    def testSelectFactor(self):
+        """
+        Assure proper behaviour on changing structure factor
+        """
+        pass
+
+    def testReadCategoryInfo(self):
+        """
+        Check the category file reader
+        """
+        pass
+
+    def testGetIterParams(self):
+        """
+        Assure the right multishell parameters are returned
+        """
+        pass
+
+    def testGetMultiplicity(self):
+        """
+        Assure more multishell parameters are evaluated correctly
+        """
+        pass
+
+    def testAddCheckedListToModel(self):
+        """
+        Test for utility function
+        """
+        pass
+
+    def testUpdateParamsFromModel(self):
+        """
+        Checks the sasmodel parameter update from QModel items
+        """
+        pass
+
+    def testComputeDataRange(self):
+        """
+        Tests the data range calculator on Data1D/Data2D
+        """
+        pass
+
+    def testAddParametersToModel(self):
+        """
+        Checks the QModel update from Sasmodel parameters
+        """
+        pass
+
+    def testAddSimpleParametersToModel(self):
+        """
+        Checks the QModel update from Sasmodel parameters - no polydisp
+        """
+        pass
+
+    def testCreateDefault1dData(self):
+        """
+        Tests the default 1D set
+        """
+        pass
+
+    def testCreateDefault2dData(self):
+        """
+        Tests the default 2D set
+        """
+        pass
+
+    def testCreateTheoryIndex(self):
+        """
+        Test the data->QIndex conversion
+        """
+        pass
+
+    def testCalculate1DForModel(self):
+        """
+        Check that the fitting 1D data object is ready
+        """
+        pass
+
+    def testCalculate2DForModel(self):
+        """
+        Check that the fitting 2D data object is ready
+        """
+        pass
+
+    def testComplete1D(self):
+        """
+        Check that a new 1D plot is generated
+        """
+        pass
+
+    def testComplete2D(self):
+        """
+        Check that a new 2D plot is generated
+        """
+        pass
+
+    def testReplaceShellName(self):
+        """
+        Test the utility function for string manipulation
+        """
+        pass
+
+    def testSetPolyModel(self):
+        """
+        Test the polydispersity model setup
+        """
+        pass
+
+    def testSetMagneticModel(self):
+        """
+        Test the magnetic model setup
+        """
+        pass
+
+    def testAddExtraShells(self):
+        """
+        Test how the extra shells are presented
+        """
+        pass
+
+    def testModifyShellsInList(self):
+        """
+        Test the additional rows added by modifying the shells combobox
+        """
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()
Index: src/sas/sasgui/perspectives/fitting/fitting.py
===================================================================
--- src/sas/sasgui/perspectives/fitting/fitting.py	(revision 7673ecd9d5adcefdfa1fc6a6d1ff0649f8e63bc8)
+++ src/sas/sasgui/perspectives/fitting/fitting.py	(revision 811bec19d50f449dd2af46130143530ec1d535db)
@@ -41,6 +41,6 @@
 from sas.sasgui.perspectives.fitting.pagestate import Reader
 from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent
-from sas.sasgui.perspectives.calculator.model_editor import TextDialog
-from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
+#from sas.sasgui.perspectives.calculator.model_editor import TextDialog
+#from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
 from sas.sasgui.guiframe.gui_manager import MDIFrame
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow
