Index: src/sas/qtgui/GUITests.py
===================================================================
--- src/sas/qtgui/GUITests.py	(revision d3ca36332a95a5caf23ee8f8223a9c9912826726)
+++ src/sas/qtgui/GUITests.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -20,4 +20,5 @@
 from UnitTesting import WindowTitleTest
 from UnitTesting import SetGraphRangeTest
+from UnitTesting import LinearFitTest
 
 def suite():
@@ -42,4 +43,5 @@
         unittest.makeSuite(WindowTitleTest.WindowTitleTest, 'test'),
         unittest.makeSuite(SetGraphRangeTest.SetGraphRangeTest, 'test'),
+        unittest.makeSuite(LinearFitTest.LinearFitTest, 'test'),
     )
     return unittest.TestSuite(suites)
Index: src/sas/qtgui/LinearFit.py
===================================================================
--- src/sas/qtgui/LinearFit.py	(revision fed94a2715dc183e26bc1dfd2691e7802cc69313)
+++ src/sas/qtgui/LinearFit.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -38,4 +38,7 @@
         self.yLabel = ylabel
 
+        self.x_is_log = self.xLabel == "log10(x)"
+        self.y_is_log = self.yLabel == "log10(y)"
+
         self.txtFitRangeMin.setValidator(QtGui.QDoubleValidator())
         self.txtFitRangeMax.setValidator(QtGui.QDoubleValidator())
@@ -108,12 +111,14 @@
         self.xminFit, self.xmaxFit = self.range()
 
-        xminView = self.xminFit
-        xmaxView = self.xmaxFit
-        xmin = xminView
-        xmax = xmaxView
+        xmin = self.xminFit
+        xmax = self.xmaxFit
+        xminView = xmin
+        xmaxView = xmax
+
         # Set the qmin and qmax in the panel that matches the
         # transformed min and max
         #value_xmin = X_VAL_DICT[self.xLabel].floatTransform(xmin)
         #value_xmax = X_VAL_DICT[self.xLabel].floatTransform(xmax)
+
         value_xmin = self.floatInvTransform(xmin)
         value_xmax = self.floatInvTransform(xmax)
@@ -121,12 +126,75 @@
         self.txtRangeMax.setText(formatNumber(value_xmax))
 
+        tempx, tempy, tempdy = self.origData()
+
+        # Find the fitting parameters
+        self.cstA = fittings.Parameter(self.model, 'A', self.default_A)
+        self.cstB = fittings.Parameter(self.model, 'B', self.default_B)
+        tempdy = numpy.asarray(tempdy)
+        tempdy[tempdy == 0] = 1
+
+        if self.x_is_log:
+            xmin = numpy.log10(xmin)
+            xmax = numpy.log10(xmax)
+
+        chisqr, out, cov = fittings.sasfit(self.model,
+                                           [self.cstA, self.cstB],
+                                           tempx, tempy, tempdy,
+                                           xmin, xmax)
+        # Use chi2/dof
+        if len(tempx) > 0:
+            chisqr = chisqr / len(tempx)
+
+        # Check that cov and out are iterable before displaying them
+        errA = numpy.sqrt(cov[0][0]) if cov is not None else 0
+        errB = numpy.sqrt(cov[1][1]) if cov is not None else 0
+        cstA = out[0] if out is not None else 0.0
+        cstB = out[1] if out is not None else 0.0
+
+        # Reset model with the right values of A and B
+        self.model.setParam('A', float(cstA))
+        self.model.setParam('B', float(cstB))
+
+        tempx = []
+        tempy = []
+        y_model = 0.0
+
+        # load tempy with the minimum transformation
+        y_model = self.model.run(xmin)
+        tempx.append(xminView)
+        tempy.append(numpy.power(10, y_model) if self.y_is_log else y_model)
+
+        # load tempy with the maximum transformation
+        y_model = self.model.run(xmax)
+        tempx.append(xmaxView)
+        tempy.append(numpy.power(10, y_model) if self.y_is_log else y_model)
+
+        # Set the fit parameter display when  FitDialog is opened again
+        self.Avalue = cstA
+        self.Bvalue = cstB
+        self.ErrAvalue = errA
+        self.ErrBvalue = errB
+        self.Chivalue = chisqr
+
+        # Update the widget
+        self.txtA.setText(formatNumber(self.Avalue))
+        self.txtAerr.setText(formatNumber(self.ErrAvalue))
+        self.txtB.setText(formatNumber(self.Bvalue))
+        self.txtBerr.setText(formatNumber(self.ErrBvalue))
+        self.txtChi2.setText(formatNumber(self.Chivalue))
+
+        #self.parent.updatePlot.emit((tempx, tempy))
+        self.parent.emit(QtCore.SIGNAL('updatePlot'), (tempx, tempy))
+
+    def origData(self):
         # Store the transformed values of view x, y and dy before the fit
-        xmin_check = numpy.log10(xmin)
+        xmin_check = numpy.log10(self.xminFit)
+        # Local shortcuts
         x = self.data.view.x
         y = self.data.view.y
         dy = self.data.view.dy
 
-        if self.yLabel == "log10(y)":
-            if self.xLabel == "log10(x)":
+        if self.y_is_log:
+            if self.x_is_log:
                 tempy  = [numpy.log10(y[i])
                          for i in range(len(x)) if x[i] >= xmin_check]
@@ -140,87 +208,10 @@
             tempdy = dy
 
-        if self.xLabel == "log10(x)":
+        if self.x_is_log:
             tempx = [numpy.log10(x) for x in self.data.view.x if x > xmin_check]
         else:
-            tempx = self.data.view.x
-
-        # Find the fitting parameters
-        # Always use the same defaults, so that fit history
-        # doesn't play a role!
-        self.cstA = fittings.Parameter(self.model, 'A', self.default_A)
-        self.cstB = fittings.Parameter(self.model, 'B', self.default_B)
-        tempdy = numpy.asarray(tempdy)
-        tempdy[tempdy == 0] = 1
-
-        if self.xLabel == "log10(x)":
-            chisqr, out, cov = fittings.sasfit(self.model,
-                                               [self.cstA, self.cstB],
-                                               tempx, tempy,
-                                               tempdy,
-                                               numpy.log10(xmin),
-                                               numpy.log10(xmax))
-        else:
-            chisqr, out, cov = fittings.sasfit(self.model,
-                                               [self.cstA, self.cstB],
-                                               tempx, tempy, tempdy,
-                                               xminView, xmaxView)
-        # Use chi2/dof
-        if len(tempx) > 0:
-            chisqr = chisqr / len(tempx)
-
-        # Check that cov and out are iterable before displaying them
-        errA = numpy.sqrt(cov[0][0]) if cov is not None else 0
-        errB = numpy.sqrt(cov[1][1]) if cov is not None else 0
-        cstA = out[0] if out is not None else 0.0
-        cstB = out[1] if out is not None else 0.0
-
-        # Reset model with the right values of A and B
-        self.model.setParam('A', float(cstA))
-        self.model.setParam('B', float(cstB))
-
-        tempx = []
-        tempy = []
-        y_model = 0.0
-        # load tempy with the minimum transformation
-        if self.xLabel == "log10(x)":
-            y_model = self.model.run(numpy.log10(xmin))
-            tempx.append(xmin)
-        else:
-            y_model = self.model.run(xminView)
-            tempx.append(xminView)
-
-        if self.yLabel == "log10(y)":
-            tempy.append(numpy.power(10, y_model))
-        else:
-            tempy.append(y_model)
-
-        # load tempy with the maximum transformation
-        if self.xLabel == "log10(x)":
-            y_model = self.model.run(numpy.log10(xmax))
-            tempx.append(xmax)
-        else:
-            y_model = self.model.run(xmaxView)
-            tempx.append(xmaxView)
-
-        if self.yLabel == "log10(y)":
-            tempy.append(numpy.power(10, y_model))
-        else:
-            tempy.append(y_model)
-        # Set the fit parameter display when  FitDialog is opened again
-        self.Avalue = cstA
-        self.Bvalue = cstB
-        self.ErrAvalue = errA
-        self.ErrBvalue = errB
-        self.Chivalue = chisqr
-
-        # Update the widget
-        self.txtA.setText(formatNumber(self.Avalue))
-        self.txtAerr.setText(formatNumber(self.ErrAvalue))
-        self.txtB.setText(formatNumber(self.Bvalue))
-        self.txtBerr.setText(formatNumber(self.ErrBvalue))
-        self.txtChi2.setText(formatNumber(self.Chivalue))
-
-        #self.parent.updatePlot.emit((tempx, tempy))
-        self.parent.emit(QtCore.SIGNAL('updatePlot'), (tempx, tempy))
+            tempx = x
+
+        return tempx, tempy, tempdy
 
     def checkFitValues(self, item):
@@ -234,6 +225,7 @@
         p_pink = item.palette()
         p_pink.setColor(item.backgroundRole(), QtGui.QColor(255, 128, 128))
+        item.setAutoFillBackground(True)
         # Check for possible values entered
-        if self.xLabel == "log10(x)":
+        if self.x_is_log:
             if float(value) > 0:
                 item.setPalette(p_white)
@@ -259,5 +251,5 @@
             return numpy.sqrt(x)
         elif self.xLabel == "x^(4)":
-            return numpy.sqrt(math.sqrt(x))
+            return numpy.sqrt(numpy.sqrt(x))
         elif self.xLabel == "log10(x)":
             return numpy.power(10, x)
Index: src/sas/qtgui/Plotter.py
===================================================================
--- src/sas/qtgui/Plotter.py	(revision a66ff28037574eadcde466c7b04da5c45b314939)
+++ src/sas/qtgui/Plotter.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -382,4 +382,8 @@
         plot_dict = copy.deepcopy(self.plot_dict)
 
+        # Labels might have been changed
+        xl = self.ax.xaxis.label.get_text()
+        yl = self.ax.yaxis.label.get_text()
+
         self.plot_dict = {}
 
@@ -389,5 +393,10 @@
         for ids in plot_dict:
             if ids != id:
-                self.plot(data=plot_dict[ids], hide_error=plot_dict[ids].hide_error)                
+                self.plot(data=plot_dict[ids], hide_error=plot_dict[ids].hide_error)
+
+        # Reset the labels
+        self.ax.set_xlabel(xl)
+        self.ax.set_ylabel(yl)
+        self.canvas.draw()
 
     def onFreeze(self, id):
@@ -443,8 +452,11 @@
             self.xscale = xscale
             self.yscale = yscale
+
+            # Plot the updated chart
+            self.removePlot(id)
+
+            # This assignment will wrap the label in Latex "$"
             self.xLabel = new_xlabel
             self.yLabel = new_ylabel
-            # Plot the updated chart
-            self.removePlot(id)
             # Directly overwrite the data to avoid label reassignment
             self._data = current_plot
Index: src/sas/qtgui/Plotter2D.py
===================================================================
--- src/sas/qtgui/Plotter2D.py	(revision 9290b1a2e57458d51b13f1acd1798b999372c7d7)
+++ src/sas/qtgui/Plotter2D.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -85,5 +85,5 @@
                       zmax=zmax_2D_temp)
 
-    def contextMenu(self):
+    def createContextMenu(self):
         """
         Define common context menu and associated actions for the MPL widget
@@ -91,5 +91,5 @@
         self.defaultContextMenu()
 
-    def contextMenuQuickPlot(self):
+    def createContextMenuQuick(self):
         """
         Define context menu and associated actions for the quickplot MPL widget
Index: src/sas/qtgui/PlotterBase.py
===================================================================
--- src/sas/qtgui/PlotterBase.py	(revision 570a58f9169c78f01c6e69cc89a1960671e5a13d)
+++ src/sas/qtgui/PlotterBase.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
Index: src/sas/qtgui/UnitTesting/GuiUtilsTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/GuiUtilsTest.py	(revision 27313b77c4e5bef362a7502a76baa9340a740ae8)
+++ src/sas/qtgui/UnitTesting/GuiUtilsTest.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -346,4 +346,68 @@
         self.assertFalse(os.path.isfile(file_name))
 
+    def testXYTransform(self):
+        """ Assure the unit/legend transformation is correct"""
+        data = Data1D(x=[1.0, 2.0, 3.0], y=[10.0, 11.0, 12.0],
+                      dx=[0.1, 0.2, 0.3], dy=[0.1, 0.2, 0.3])
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="y")
+        self.assertEqual(xLabel, "()")
+        self.assertEqual(xscale, "linear")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x^(2)", yLabel="1/y")
+        self.assertEqual(xLabel, "^{2}(()^{2})")
+        self.assertEqual(yLabel, "1/(()^{-1})")
+        self.assertEqual(xscale, "linear")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x^(4)", yLabel="ln(y)")
+        self.assertEqual(xLabel, "^{4}(()^{4})")
+        self.assertEqual(yLabel, "\\ln{()}()")
+        self.assertEqual(xscale, "linear")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="ln(x)", yLabel="y^(2)")
+        self.assertEqual(xLabel, "\\ln{()}()")
+        self.assertEqual(yLabel, "^{2}(()^{2})")
+        self.assertEqual(xscale, "linear")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="log10(x)", yLabel="y*x^(2)")
+        self.assertEqual(xLabel, "()")
+        self.assertEqual(yLabel, " \\ \\ ^{2}(()^{2})")
+        self.assertEqual(xscale, "log")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="log10(x^(4))", yLabel="y*x^(4)")
+        self.assertEqual(xLabel, "^{4}(()^{4})")
+        self.assertEqual(yLabel, " \\ \\ ^{4}(()^{16})")
+        self.assertEqual(xscale, "log")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="1/sqrt(y)")
+        self.assertEqual(yLabel, "1/\\sqrt{}(()^{-0.5})")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="log10(y)")
+        self.assertEqual(yLabel, "()")
+        self.assertEqual(yscale, "log")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="ln(y*x)")
+        self.assertEqual(yLabel, "\\ln{( \\ \\ )}()")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="ln(y*x^(2))")
+        self.assertEqual(yLabel, "\\ln ( \\ \\ ^{2})(()^{2})")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="ln(y*x^(4))")
+        self.assertEqual(yLabel, "\\ln ( \\ \\ ^{4})(()^{4})")
+        self.assertEqual(yscale, "linear")
+
+        xLabel, yLabel, xscale, yscale = xyTransform(data, xLabel="x", yLabel="log10(y*x^(4))")
+        self.assertEqual(yLabel, " \\ \\ ^{4}(()^{4})")
+        self.assertEqual(yscale, "log")
+
 class FormulaValidatorTest(unittest.TestCase):
     """ Test the formula validator """
Index: src/sas/qtgui/UnitTesting/LinearFitTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/LinearFitTest.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
+++ src/sas/qtgui/UnitTesting/LinearFitTest.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -0,0 +1,139 @@
+import sys
+import unittest
+import numpy
+
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+from mock import MagicMock
+
+# set up import paths
+import path_prepare
+
+from UnitTesting.TestUtils import QtSignalSpy
+from sas.sasgui.guiframe.dataFitting import Data1D
+import sas.qtgui.Plotter as Plotter
+
+# Local
+from LinearFit import LinearFit
+
+app = QtGui.QApplication(sys.argv)
+
+class LinearFitTest(unittest.TestCase):
+    '''Test the LinearFit'''
+    def setUp(self):
+        '''Create the LinearFit'''
+        self.data = Data1D(x=[1.0, 2.0, 3.0],
+                           y=[10.0, 11.0, 12.0],
+                           dx=[0.1, 0.2, 0.3],
+                           dy=[0.1, 0.2, 0.3])
+        plotter = Plotter.Plotter(None, quickplot=True)
+        self.widget = LinearFit(parent=plotter, data=self.data, xlabel="log10(x^2)", ylabel="log10(y)")
+
+    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.QDialog)
+        self.assertEqual(self.widget.windowTitle(), "Linear Fit")
+        self.assertEqual(self.widget.txtA.text(), "1")
+        self.assertEqual(self.widget.txtB.text(), "1")
+        self.assertEqual(self.widget.txtAerr.text(), "0")
+        self.assertEqual(self.widget.txtBerr.text(), "0")
+
+        self.assertEqual(self.widget.lblRange.text(), "Fit range of log10(x^2)")
+
+    def testFit(self):
+        '''Test the fitting wrapper '''
+        # Catch the update signal
+        self.widget.parent.emit = MagicMock()
+
+        # Set some initial values
+        self.widget.txtRangeMin.setText("1.0")
+        self.widget.txtRangeMax.setText("3.0")
+        self.widget.txtFitRangeMin.setText("1.0")
+        self.widget.txtFitRangeMax.setText("3.0")
+        # Run the fitting
+        self.widget.fit(None)
+        return_values = self.widget.parent.emit.call_args[0][1]
+        # Compare
+        self.assertItemsEqual(return_values[0], [1.0, 3.0])
+        self.assertItemsEqual(return_values[1], [10.004054329087303, 12.030439848443539])
+
+        # Set the log scale
+        self.widget.x_is_log = True
+        self.widget.fit(None)
+        return_values = self.widget.parent.emit.call_args[0][1]
+        # Compare
+        self.assertItemsEqual(return_values[0], [1.0, 3.0])
+        self.assertItemsEqual(return_values[1], [9.9877329376711437, 11.843650824649025])
+
+    def testOrigData(self):
+        ''' Assure the un-logged data is returned'''
+        # log(x), log(y)
+        self.widget.xminFit, self.widget.xmaxFit = self.widget.range()
+        orig_x = [ 1.,  2.,  3.]
+        orig_y = [1.0, 1.0413926851582251, 1.0791812460476249]
+        orig_dy = [0.01, 0.018181818181818184, 0.024999999999999998]
+        x, y, dy = self.widget.origData()
+
+        self.assertItemsEqual(x, orig_x)
+        self.assertItemsEqual(y, orig_y)
+        self.assertItemsEqual(dy, orig_dy)
+
+        # x, y
+        self.widget.x_is_log = False
+        self.widget.y_is_log = False
+        self.widget.xminFit, self.widget.xmaxFit = self.widget.range()
+        orig_x = [ 1.,  2.,  3.]
+        orig_y = [10., 11., 12.]
+        orig_dy = [0.1, 0.2, 0.3]
+        x, y, dy = self.widget.origData()
+
+        self.assertItemsEqual(x, orig_x)
+        self.assertItemsEqual(y, orig_y)
+        self.assertItemsEqual(dy, orig_dy)
+
+        # x, log(y)
+        self.widget.x_is_log = False
+        self.widget.y_is_log = True
+        self.widget.xminFit, self.widget.xmaxFit = self.widget.range()
+        orig_x = [ 1.,  2.,  3.]
+        orig_y = [1.0, 1.0413926851582251, 1.0791812460476249]
+        orig_dy = [0.01, 0.018181818181818184, 0.024999999999999998]
+        x, y, dy = self.widget.origData()
+
+        self.assertItemsEqual(x, orig_x)
+        self.assertItemsEqual(y, orig_y)
+        self.assertItemsEqual(dy, orig_dy)
+
+    def testCheckFitValues(self):
+        '''Assure fit values are correct'''
+        # Good values
+        self.assertTrue(self.widget.checkFitValues(self.widget.txtFitRangeMin))
+        self.assertEqual(self.widget.txtFitRangeMin.palette().color(10).name(), "#f0f0f0")
+        # Bad values
+        self.widget.x_is_log = True
+        self.widget.txtFitRangeMin.setText("-1.0")
+        self.assertFalse(self.widget.checkFitValues(self.widget.txtFitRangeMin))
+       
+
+    def testFloatInvTransform(self):
+        '''Test the helper method for providing conversion function'''
+        self.widget.xLabel="x"
+        self.assertEqual(self.widget.floatInvTransform(5.0), 5.0)
+        self.widget.xLabel="x^(2)"
+        self.assertEqual(self.widget.floatInvTransform(25.0), 5.0)
+        self.widget.xLabel="x^(4)"
+        self.assertEqual(self.widget.floatInvTransform(81.0), 3.0)
+        self.widget.xLabel="log10(x)"
+        self.assertEqual(self.widget.floatInvTransform(2.0), 100.0)
+        self.widget.xLabel="ln(x)"
+        self.assertEqual(self.widget.floatInvTransform(1.0), numpy.exp(1))
+        self.widget.xLabel="log10(x^(4))"
+        self.assertEqual(self.widget.floatInvTransform(4.0), 10.0)
+      
+if __name__ == "__main__":
+    unittest.main()
Index: src/sas/qtgui/UnitTesting/Plotter2DTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/Plotter2DTest.py	(revision 27313b77c4e5bef362a7502a76baa9340a740ae8)
+++ src/sas/qtgui/UnitTesting/Plotter2DTest.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -74,4 +74,5 @@
         """ Test the right click menu """
         self.plotter.data = self.data
+        self.plotter.createContextMenuQuick()
         actions = self.plotter.contextMenu.actions()
         self.assertEqual(len(actions), 7)
Index: src/sas/qtgui/UnitTesting/PlotterTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/PlotterTest.py	(revision aadf0af183702570addb989ed535f1c04f06b3df)
+++ src/sas/qtgui/UnitTesting/PlotterTest.py	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -69,5 +69,5 @@
         self.assertTrue(FigureCanvas.draw.called)
 
-    def testContextMenuQuickPlot(self):
+    def testCreateContextMenuQuick(self):
         """ Test the right click menu """
         self.plotter.createContextMenuQuick()
@@ -112,49 +112,20 @@
         self.assertTrue(self.plotter.properties.exec_.called)
 
-    def testXYTransform(self):
-        """ Assure the unit/legend transformation is correct"""
-        self.plotter.plot(self.data)
-
-        self.plotter.xyTransform(xLabel="x", yLabel="y")
+    def testXyTransform(self):
+        """ Tests the XY transformation and new chart update """
+        self.plotter.plot(self.data)
+
+        # Transform the points
+        self.plotter.xyTransform(xLabel="x", yLabel="log10(y)")
+
+        # Assure new plot has correct labels
         self.assertEqual(self.plotter.ax.get_xlabel(), "$()$")
         self.assertEqual(self.plotter.ax.get_ylabel(), "$()$")
-
-        self.plotter.xyTransform(xLabel="x^(2)", yLabel="1/y")
-        self.assertEqual(self.plotter.ax.get_xlabel(), "$^{2}(()^{2})$")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$1/(()^{-1})$")
-
-        self.plotter.xyTransform(xLabel="x^(4)", yLabel="ln(y)")
-        self.assertEqual(self.plotter.ax.get_xlabel(), "$^{4}(()^{4})$")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$\\ln{()}()$")
-
-        self.plotter.xyTransform(xLabel="ln(x)", yLabel="y^(2)")
-        self.assertEqual(self.plotter.ax.get_xlabel(), "$\\ln{()}()$")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$^{2}(()^{2})$")
-
-        self.plotter.xyTransform(xLabel="log10(x)", yLabel="y*x^(2)")
-        self.assertEqual(self.plotter.ax.get_xlabel(), "$()$")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$ \\ \\ ^{2}(()^{2})$")
-
-        self.plotter.xyTransform(xLabel="log10(x^(4))", yLabel="y*x^(4)")
-        self.assertEqual(self.plotter.ax.get_xlabel(), "$^{4}(()^{4})$")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$ \\ \\ ^{4}(()^{16})$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="1/sqrt(y)")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$1/\\sqrt{}(()^{-0.5})$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="log10(y)")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$()$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="ln(y*x)")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$\\ln{( \\ \\ )}()$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="ln(y*x^(2))")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$\\ln ( \\ \\ ^{2})(()^{2})$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="ln(y*x^(4))")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$\\ln ( \\ \\ ^{4})(()^{4})$")
-
-        self.plotter.xyTransform(xLabel="x", yLabel="log10(y*x^(4))")
-        self.assertEqual(self.plotter.ax.get_ylabel(), "$ \\ \\ ^{4}(()^{4})$")
+        # ... and scale
+        self.assertEqual(self.plotter.xscale, "linear")
+        self.assertEqual(self.plotter.yscale, "log")
+        # See that just one plot is present
+        self.assertEqual(len(self.plotter.plot_dict), 1)
+        self.assertEqual(len(self.plotter.ax.collections), 1)
 
     def testAddText(self):
@@ -250,4 +221,24 @@
         self.assertNotEqual(self.plotter.ax.get_ylim(), new_y)
 
+    def testOnLinearFit(self):
+        """ Checks the response to LinearFit call """
+        pass
+
+    def testOnRemovePlot(self):
+        """ Assure plots get removed when requested """
+        pass
+
+    def testRemovePlot(self):
+        """ Test plot removal """
+        pass
+
+    def testOnToggleHideError(self):
+        """ Test the error bar toggle on plots """
+        pass
+
+    def testOnFitDisplay(self):
+        """ Test the fit line display on the chart """
+        pass
+
 if __name__ == "__main__":
     unittest.main()
Index: src/sas/qtgui/run_tests.bat
===================================================================
--- src/sas/qtgui/run_tests.bat	(revision d3ca36332a95a5caf23ee8f8223a9c9912826726)
+++ src/sas/qtgui/run_tests.bat	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -19,2 +19,3 @@
 python -m UnitTesting.AddTextTest
 python -m UnitTesting.SetGraphRangeTest
+python -m UnitTesting.LinearFitTest
Index: src/sas/qtgui/run_tests.sh
===================================================================
--- src/sas/qtgui/run_tests.sh	(revision d3ca36332a95a5caf23ee8f8223a9c9912826726)
+++ src/sas/qtgui/run_tests.sh	(revision b46f285a3e36e0f686120f9c8095a9c6da2d81b0)
@@ -18,2 +18,3 @@
 python -m UnitTesting.AddTextTest
 python -m UnitTesting.SetGraphRangeTest
+python -m UnitTesting.LinearFitTest
