Repository: CcgAlberta/pygeostat

Issue:
Implement pytest in `test_plots.py`
Testing suite is using unittest. Moving testing suite to pytest can help to create more tests.

Discussion:

Solution patch:
diff --git a/src/pygeostat/plotting/location_plot.py b/src/pygeostat/plotting/location_plot.py
index ad15664..52296d1 100644
--- a/src/pygeostat/plotting/location_plot.py
+++ b/src/pygeostat/plotting/location_plot.py
@@ -311,8 +311,11 @@ def location_plot(data, x=None, y=None, z=None, var=None, dhid = None, catdata=N
 	figx, figy, _ = _spatial_orient2fig(orient, x, y, z)
 
 	if orient.lower() == 'xy' or not dhid:
-		plot = ax.scatter(pointx, pointy, c=pointvar, cmap=cmap, vmin=vlim[0],
-						vmax=vlim[1], s=s, marker=marker, **kwargs)
+		if pointvar is not None and len(pointvar) > 0:
+			plot = ax.scatter(pointx, pointy, c=pointvar, cmap=cmap, vmin=vlim[0],
+					 vmax=vlim[1], s=s, marker=marker, **kwargs)
+		else:
+			plot = ax.scatter(pointx, pointy)
 	else: # Plot lines if the dhid was inferred/provided and the orientation is xz or yz
 		drill_plot_format = True
 		data_temp = pd.DataFrame({figx:pointx, figy: pointy, var:pointvar, dhid: point_dh})
@@ -327,7 +330,7 @@ def location_plot(data, x=None, y=None, z=None, var=None, dhid = None, catdata=N
 				if var in data.columns:
 					collar_var = group[var][group[var].index.min()]
 					norm = plt.cm.colors.Normalize(*vlim)
-					_cmap = plt.cm.get_cmap(cmap)
+					_cmap = plt.colormaps.get_cmap(cmap)
 					collar_var = [_cmap(norm(collar_var))]
 					plot = ax.scatter(x_points, y_points, c=collar_var, cmap=cmap, vmin=vlim[0], vmax=vlim[1], s=s,
 							marker=collar_marker, **kwargs)
@@ -395,9 +398,9 @@ def location_plot(data, x=None, y=None, z=None, var=None, dhid = None, catdata=N
 		# cax = grid.cbar_axes[0]
 		# Plot the colorbar
 		if drill_plot_format:
-			cbar = plt.colorbar(lc, cax=cax, ticks=ticklocs)
+			cbar = lc.axes.figure.colorbar(lc, cax=cax, ticks=ticklocs)
 		else:
-			cbar = fig.colorbar(plot, cax=cax, ticks=ticklocs)
+			cbar = plot.figure.colorbar(plot, cax=cax, ticks=ticklocs)
 		# Configure the color bar
 		cbar.ax.set_yticklabels(ticklabels, ha='left')
 		cbar.ax.tick_params(axis='y', pad=2)
@@ -414,4 +417,4 @@ def location_plot(data, x=None, y=None, z=None, var=None, dhid = None, catdata=N
 		return ax, cbar
 	if return_plot:
 		return plot
-	return ax
\ No newline at end of file
+	return ax
diff --git a/src/pygeostat/plotting/utils.py b/src/pygeostat/plotting/utils.py
index 15c4dfe..4a2b6af 100644
--- a/src/pygeostat/plotting/utils.py
+++ b/src/pygeostat/plotting/utils.py
@@ -310,32 +310,54 @@ def get_cmap(colormap):
 
 def catcmapfromcontinuous(contcmap, ncats, offset=0.5):
     """
-    Use the continuous colormap to get a set of categorical values returned in the
-    proper format for the other plotting routines in pygeostat from ListedColormap()
-
-    Parameters:
-        contcmap (str): valid matplotlib continuous colormap string, like 'jet' or 'spectral'
-        ncats (int): number of categories passed to the function
-        offset (float): offsets the colors so as they are not the end member colors
-
-    Returns:
-        cmap (cmap): Matplotlib colormap
-
-    .. codeauthor:: pygeostat development team 2016-05-18
+    Create a categorical colormap from a continuous colormap.
+    
+    Takes a continuous colormap and samples it at regular intervals to create 
+    a categorical colormap with the specified number of categories.
+    
+    Parameters
+    ----------
+    contcmap : str or matplotlib.colors.Colormap
+        Valid matplotlib continuous colormap string or colormap object
+    ncats : int
+        Number of categories to create in the resulting colormap
+    offset : float, default=0.5
+        Offset value to avoid using extreme end colors of the colormap
+        
+    Returns
+    -------
+    matplotlib.colors.ListedColormap
+        A categorical colormap with ncats colors
+        
+    Notes
+    -----
+    The offset parameter (default 0.5) helps avoid the extreme colors at the 
+    ends of the colormap, which are often too light or too dark.
     """
-
     from . cmaps import avail_cmaps
+    from matplotlib.colors import ListedColormap
+    import matplotlib as mpl
 
     if contcmap in avail_cmaps:
+        # Use custom pygeostat colormap
         cm = get_cmap(contcmap)
     else:
-        cm = plt.cm.get_cmap(contcmap)
+        try:
+            cm = mpl.colormaps[contcmap]
+        except (KeyError, TypeError):
+            raise ValueError(f"Colormap '{contcmap}' not found in matplotlib or pygeostat colormaps")
+    
     colors = []
     for num in range(ncats):
-        colors.append(cm((num + offset) / (ncats)))
+        position = (num + offset) / ncats
+        colors.append(cm(position))
+
+    return ListedColormap(colors, name=f"{contcmap}_categorical_{ncats}")
+
+
+
+
 
-    cmap = ListedColormap(colors, name=contcmap)
-    return cmap
 
 
 def get_label(data):
@@ -492,45 +514,83 @@ def get_supaxislocs(fig, nrow, ncol, figsize, pad):
     ymax = ymax + pad
     #  Get the limit of the xticklabels
     iax = ncol * (nrow - 1)
-    bbox = axes[iax].xaxis.get_ticklabel_extents(renderer)[0]
+    #bbox = axes[iax].xaxis.get_ticklabel_extents(renderer)[0]
+    #ymin = (bbox.ymin / figsize[1] / dpi) - pad
+    ##  Get the x limit of the yticklabels
+    #bbox = axes[0].yaxis.get_ticklabel_extents(renderer)[0]
+    #xmin = (bbox.xmin / figsize[0] / dpi) - pad
+    
+    # New implementation due to deprecation in matplotlib
+    bbox = axes[iax].get_tightbbox(renderer)
     ymin = (bbox.ymin / figsize[1] / dpi) - pad
-    #  Get the x limit of the yticklabels
-    bbox = axes[0].yaxis.get_ticklabel_extents(renderer)[0]
+    
+    # For left margin
+    bbox = axes[0].get_tightbbox(renderer)
     xmin = (bbox.xmin / figsize[0] / dpi) - pad
 
     return xmin, xmid, ymin, ymid, ymax
 
-
 def _get_cmap(cmap, catdata, ncat):
-    '''Determine the colormap based on the catdata boolean, cmap value and Parameters.
-    Used by location_plot'''
-
+    '''
+    Determine the colormap based on categorical data flag, provided colormap 
+    name, and parameters.
+    Used by location_plot and other plotting functions.
+    
+    Parameters
+    ----------
+    cmap : str, matplotlib.colors.Colormap, or None
+        Name of colormap or colormap object
+    catdata : bool or None
+        Flag indicating if data is categorical
+    ncat : int
+        Number of categories (used for categorical data)
+        
+    Returns
+    -------
+    matplotlib.colors.Colormap
+        The selected colormap
+    '''
     from . cmaps import avail_palettes, avail_cmaps
     from matplotlib.colors import LinearSegmentedColormap
+    
     if catdata:
+        # Get default categorical colormap if none provided
         if cmap is None:
             cmap = Parameters['plotting.cmap_cat']
             if isinstance(cmap, dict):
                 cmap = list(cmap.values())
                 cmap = LinearSegmentedColormap.from_list('cmap_cat', cmap, N=len(cmap))
-        if not isinstance(cmap, mpl.colors.ListedColormap):
+        
+        if not isinstance(cmap, mpl.colors.Colormap):
             if cmap in avail_palettes:
+                # Use pygeostat's custom palette
                 cmap = get_palette(cmap, ncat)
             else:
                 cmap = catcmapfromcontinuous(cmap, ncat)
+    
+    # Handle continuous data case
     else:
         if cmap is None:
             cmap = Parameters['plotting.cmap']
-        if not isinstance(cmap, mpl.colors.ListedColormap):
+            
+        if not isinstance(cmap, mpl.colors.Colormap):
             if cmap in avail_cmaps:
+                # Use pygeostat's custom colormap
                 cmap = get_cmap(cmap)
-            elif cmap in plt.colormaps():
-                cmap = plt.cm.get_cmap(cmap)
             else:
-                pass  # this causes MPL to raise an exception and give a list of valid cmaps
+                try:
+                    cmap = mpl.colormaps[cmap]
+                except (KeyError, TypeError):
+                    pass
+    
     return cmap
 
 
+
+
+
+
+
 def setup_plot(ax, cbar=None, figsize=None, cax=None, aspect=None):
     '''A small utility function called from many of the plotting functions. This will set up a
     matplotlib plot instance based on whether an axis is passed or not.
@@ -1387,4 +1447,4 @@ def _tickoverlap(ax):
                       "to set the argument manually to rotate them if necessary")
     overlaps = [tickcheck(ax.get_xticklabels()), tickcheck(ax.get_yticklabels())]
 
-    return overlaps
\ No newline at end of file
+    return overlaps
diff --git a/src/pygeostat/statistics/utils.py b/src/pygeostat/statistics/utils.py
index 549a6ee..4b44ff9 100644
--- a/src/pygeostat/statistics/utils.py
+++ b/src/pygeostat/statistics/utils.py
@@ -194,12 +194,12 @@ def accsim(truth, reals, pinc=0.05):
     pre = 0
     goo = 0
     for i, values in propavg.iterrows():
-        if values[1] >= values[0]:
+        if values.iloc[1] >= values.iloc[0]:
             acc = acc + 1
-            pre = pre + (values[1] - values[0])
-            goo = goo + (values[1] - values[0])
+            pre = pre + (values.iloc[1] - values.iloc[0])
+            goo = goo + (values.iloc[1] - values.iloc[0])
         else:
-            goo = goo + (2 * (values[0] - values[1]))
+            goo = goo + (2 * (values.iloc[0] - values.iloc[1]))
     acc = acc / len(propavg)
     pre = 1 - ((2 * pre) / len(propavg))
     goo = 1 - (goo / len(propavg))


Test patch:
diff --git a/tests/test_plots.py b/tests/test_plots.py
index 780ae8b..6854858 100644
--- a/tests/test_plots.py
+++ b/tests/test_plots.py
@@ -1,865 +1,739 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function
-
-__author__ = 'pygeostat development team'
-__date__ = '2020-01-04'
-__version__ = '1.0.0'
-
-import os, sys
-try:
-	import pygeostat as gs
-except (ImportError, ModuleNotFoundError):
-	sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), r'..')))
-	import pygeostat as gs
-import unittest
-import warnings
-import subprocess
-import pandas as pd
-import numpy as np
-import tempfile
-
-
-
-class BaseTest(unittest.TestCase):
-	'''
-	base class for testing plotting tools
-	'''
-	def setUp(self):
-		warnings.simplefilter('ignore', category=ImportWarning)
-		self.out_dir = tempfile.NamedTemporaryFile().name
-		gs.mkdir(self.out_dir)
-
-	def tearDown(self):
-		gs.clrmplmem()
-		gs.rmdir(self.out_dir)
-		
-
-class LocationPlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat location_plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-		self.data = gs.ExampleData('point3d_ind_mv')
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting by passing only the data file
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'location_plot1.png')
-		try:
-			_ = gs.location_plot(self.data, output_file = output_file)
-		except Exception as ex:
-			self.fail('Unable to test the location plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-	def test_plot_cmap(self):
-		'''
-		Test the capability of plotting by passing variable name to get the color map
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'location_plot2.png')
-		_, ax = plt.subplots(1,1)
-		try:
-			_ = gs.location_plot(self.data, var='Phi', output_file = output_file)
-			_ = gs.location_plot(self.data, var='Phi', output_file = output_file, ax =ax)
-		except Exception as ex:
-			self.fail('Unable to test the location plot with passing the variable name \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_lines(self):
-		'''
-		Test the capability of plotting along xz/yz orientation and use line plots based on drill hole id
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'location_plot3.png')
-		try:
-			_ = gs.location_plot(self.data, var='Phi', orient='yz', aspect =5, plot_collar = True, output_file = output_file)
-		except Exception as ex:
-			self.fail('Unable to test the location plot along yz/xz orientation \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_categorical(self):
-		'''
-		Test the capability of plotting along xz/yz orientation and use line plots based on drill hole id for a categorical variable
-		'''
-		from matplotlib import pyplot as plt
-		
-		output_file = os.path.join(self.out_dir, 'location_plot3.png')
-		_, ax = plt.subplots(1,1)
-		try:
-			_ = gs.location_plot(self.data, var='Lithofacies', orient='yz', aspect =5, plot_collar = True, output_file = output_file)
-			_ = gs.location_plot(self.data, var='Lithofacies', orient='yz', aspect =5, plot_collar = True, output_file = output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the location plot along yz/xz orientation for a categorical variable \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class AccuracyPlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat accuracy_plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting by passing only the data file
-		'''
-		from matplotlib import pyplot as plt
-
-		data = gs.ExampleData('accuracy_plot')
-		reals = data[list(data.columns[1:])].values
-		truth = data[list(data.columns)[0]].values
-		output_file = os.path.join(self.out_dir, 'accuracy_plot1.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.accuracy_plot(truth=truth, reals=reals, output_file = output_file)
-			gs.accuracy_plot(truth=truth, reals=reals, output_file = output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the accuracy plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-	
-
-class SlicePlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat slice_plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-		self.griddef = gs.GridDef([40,0.5,1,40,0.5,1,40,0.5,1])
-		self.data = gs.ExampleData('3d_grid', griddef=self.griddef)
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting by passing only the data file
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'slice_plot1.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.slice_plot(self.data, griddef=self.data.griddef, orient='xy', cmap='viridis', output_file=output_file)
-			gs.slice_plot(self.data, griddef=self.data.griddef, orient='xy', cmap='viridis', output_file=output_file, ax =ax)
-		except Exception as ex:
-			self.fail('Unable to test the slice plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_with_thickness_plot(self):
-		'''
-		Test the capability of plotting by passing only the data file
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'slice_plot2.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.slice_plot(self.data, orient='xy', cmap='viridis', output_file=output_file, slice_thickness=20)
-			gs.slice_plot(self.data, orient='xy', cmap='viridis', output_file=output_file, slice_thickness=20, ax =ax)
-		except Exception as ex:
-			self.fail('Unable to test the slice plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class GridSlicePlotTest(SlicePlotTest):
-	'''
-	 Test suite for pygeostat gird_slice_plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting by passing only the data file
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'grid_slice_plot1.png')
-		try:
-			_ = gs.grid_slice_plot(self.data, output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the grid slice plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_orient_slice_number_plot(self):
-		'''
-		Test the capability of specifying number of slices and orientation
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'grid_slice_plot2.png')
-		try:
-			_ = gs.grid_slice_plot(self.data, orient='xz', n_slice=5, output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the grid slice plot with number of slices and orientation \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-	
-
-	def test_nrow_ncol_plot(self):
-		'''
-		Test the capability of specifying number of rows or columns required for the slices
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'grid_slice_plot3.png')
-		try:
-			_ = gs.grid_slice_plot(self.data, orient='xz', n_slice=6, ncol=2, nrow=3, output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the grid slice plot number of rows or columns required for the slices \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_custom_plot(self):
-		'''
-		Test the ability to specify slice_plot kwargs using this function, so we can apply consistent
-		custom formatting to all of the subplots:
-		'''
-		
-		output_file = os.path.join(self.out_dir, 'grid_slice_plot4.png')
-		try:
-			_ = gs.grid_slice_plot(self.data, nrow=2, ncol=5, start_slice=10, end_slice=25, n_slice=10, cmap='hot', vlim=(-3,3), output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the grid slice plot to specify slice_plot kwargs \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class HistogramPlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat Histogram Plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-		self.data = gs.ExampleData("point3d_ind_mv")
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting a simple histogram and saving the plot
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'histogram_plot1.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.histogram_plot(self.data, var="Phi", bins=30, output_file = output_file)
-			gs.histogram_plot(self.data, var="Phi", bins=30, output_file = output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-	def test_plot_density_with_color(self):
-
-		'''
-		Test the capability of plotting a histogram with density and custom colour and saving the plot
-		'''
-		from matplotlib import pyplot as plt
-		output_file = os.path.join(self.out_dir, 'histogram_plot2.png')
-
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.histogram_plot(self.data, var="Phi", bins=30, color='#c2e1e5', sigfigs=5, log=True, density=True, output_file = output_file)
-			gs.histogram_plot(self.data, var="Phi", bins=30, color='#c2e1e5', sigfigs=5, log=True, density=True, output_file = output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot with density and custom color \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_icdf(self):
-
-		'''
-		Test the capability of plotting a histogram fo idcf and custom stat location and saving the plot
-		'''
-		from matplotlib import pyplot as plt
-		output_file = os.path.join(self.out_dir, 'histogram_plot3.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.histogram_plot(self.data, var="Phi", icdf=True, color=3, lw=3.5, stat_xy=(1, 0.75), output_file = output_file)
-			gs.histogram_plot(self.data, var="Phi", icdf=True, color=3, lw=3.5, stat_xy=(1, 0.75), output_file = output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot for icdf and custom stat location \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_var_per_category(self):
-
-		'''
-		Test the capability of plotting a histogram within different categorical variables
-		'''
-
-		output_file = os.path.join(self.out_dir, 'histogram_plot4.png')
-
-
-		try:
-			cats = [1, 2, 3, 4, 5]
-			colors = gs.catcmapfromcontinuous("Spectral", 5).colors
-			self.data.catdict = {c: "RT {:02d}".format(c) for c in cats}
-			colordict =  {c: colors[i] for i, c in enumerate(cats)}
-
-			gs.histogram_plot(self.data, var='Phi', cat=True, color=colordict, bins=40, figsize=(8, 4), xlabel=False, output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot for a variable within different categories \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_cdf_per_category(self):
-
-		'''
-		Test the capability of plotting a cdf within different categorical variables
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'histogram_plot5.png')
-
-
-		try:
-			cats = [1, 2, 3, 4, 5]
-			colors = gs.catcmapfromcontinuous("Spectral", 5).colors
-			self.data.catdict = {c: "RT {:02d}".format(c) for c in cats}
-			colordict =  {c: colors[i] for i, c in enumerate(cats)}
-			
-			_, axs = plt.subplots(2, 2, figsize=(12, 9))
-			axs=axs.flatten()
-			
-			for var, ax in zip(self.data.variables, axs):
-				gs.histogram_plot(self.data, var=var, icdf=True, cat=True, color=colordict, ax=ax, output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot for a variable within different categories \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_plot_proportions(self):
-
-		'''
-		Test the capability of plotting a histogram for categorical proportions
-		'''
-		from matplotlib import pyplot as plt
-		output_file = os.path.join(self.out_dir, 'histogram_plot6.png')
-
-		_, ax = plt.subplots(1,1)
-		try:
-			cats = [1, 2, 3, 4, 5]
-			colors = gs.catcmapfromcontinuous("Spectral", 5).colors
-			self.data.catdict = {c: "RT {:02d}".format(c) for c in cats}
-			colordict =  {c: colors[i] for i, c in enumerate(cats)}
-
-			gs.histogram_plot(self.data, cat=True, color=colordict, bins=40, figsize=(8, 4), xlabel=False, output_file=output_file)
-			gs.histogram_plot(self.data, cat=True, color=colordict, bins=40, figsize=(8, 4), xlabel=False, output_file=output_file, ax = ax)
-
-		except Exception as ex:
-			self.fail('Unable to test the histogram plot for categorical proportions\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class HistogramPlotTestSimulation(BaseTest):
-	
-	def setUp(self):
-		super().setUp()
-
-		self.griddef = gs.GridDef([10,1,0.5, 10,1,0.5, 1,1,0.5])
-		size = self.griddef.count()
-		mean = 2.5
-		scale = 3
-		self.nreal = 100
-		self.ref_data = pd.DataFrame({'value':np.random.normal(mean, scale, size = size)})
-
-		for i, offset in enumerate(np.random.rand(self.nreal)*0.04 - 0.02):
-			data = pd.DataFrame({'value':np.random.normal(mean+offset, scale, size = size)})
-			gs.write_gslib(data, os.path.join(self.out_dir, 'real{}.out'.format(i+1)))
-
-	def test_histogram_reproduction_plot(self):
-
-		'''
-		Test the capability of plotting histogram reproduction
-		'''
-
-		output_file = os.path.join(self.out_dir, 'histplt_sim_plot1.png')
-
-
-		try:
-			gs.histogram_plot_simulation(os.path.join(self.out_dir,'real*.out'), self.ref_data, reference_variable='value', 
-								 		reference_color='C3', simulated_column=1, griddef = self.griddef, simulation_color='cyan',
-										title='var', grid=True, nreal=self.nreal, output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the histogram reproduction plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-			
-
-class CorrelationMatrixPlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat Correlation Matrix Plot
-	'''
-
-	def setUp(self):
-		super().setUp()
-		dfl = gs.ExampleData("point3d_ind_mv")
-		data = dfl[dfl.variables]
-		self.data_cor = data.corr() 
-
-
-	def test_simple_plot(self):
-
-		'''
-		Test the capability of plotting a simple correlation matrix
-		'''
-		from matplotlib import pyplot as plt
-		output_file = os.path.join(self.out_dir, 'correlation_matrix_plot1.png')
-
-		_, ax = plt.subplots(1,1)
-		try:
-			gs.correlation_matrix_plot(self.data_cor, output_file=output_file)
-			gs.correlation_matrix_plot(self.data_cor, output_file=output_file, ax =ax)
-		except Exception as ex:
-			self.fail('Unable to test the correlation matrix plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_simple_lower_matrix(self):
-
-		'''
-		Test the capability of plotting lower part of a simple correlation matrix 
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'correlation_matrix_plot2.png')
-
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.correlation_matrix_plot(self.data_cor, lower_matrix=True, annotation=True, output_file=output_file)
-			gs.correlation_matrix_plot(self.data_cor, lower_matrix=True, annotation=True, output_file=output_file, ax = ax)
-		except Exception as ex:
-			self.fail('Unable to test the correlation matrix plot with only lower matrix option\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class ScatterPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-		self.data = gs.ExampleData("point3d_ind_mv")
-
-	def test_simple_plot(self):
-
-		'''
-		Test the capability of plotting a scatter plot with probability density estimate
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'scatter_plot1.png')
-
-		_, ax = plt.subplots(1,1)
-
-		try:
-			gs.scatter_plot(self.data[self.data.variables[0]], self.data[self.data.variables[1]], cmap='hot', cbar=True, output_file = output_file)
-			gs.scatter_plot(self.data[self.data.variables[0]], self.data[self.data.variables[1]], cmap='hot', cbar=True, output_file = output_file, ax =ax)
-
-		except Exception as ex:
-			self.fail('Unable to test the scatter plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class ScatterPlotsTest(ScatterPlotTest):
 
-	def setUp(self):
-		super().setUp()
+"""Tests for plotting functionality in pygeostat"""
+
+import os
+import warnings
+import tempfile
+import pytest
+import numpy as np
+import pandas as pd
+import pygeostat as gs
+from matplotlib import pyplot as plt
+
+@pytest.fixture
+def plot_output_dir():
+    """Create temporal output directory for plots"""
+    warnings.simplefilter('ignore', category=ImportWarning)
+    out_dir = tempfile.NamedTemporaryFile().name
+    gs.mkdir(out_dir)
+    yield out_dir
+    gs.clrmplmem()
+    gs.rmdir(out_dir)
+
+@pytest.fixture
+def location_plot_data():
+    """Provide plot sample data"""
+    return gs.ExampleData('point3d_ind_mv')
+
+@pytest.fixture
+def accuracy_plot_data():
+    """Prepare data for the accuracy plots."""
+    data = gs.ExampleData('accuracy_plot')
+    reals = data[list(data.columns[1:])].values
+    truth = data[list(data.columns[0:])].values
+    return truth, reals
+
+@pytest.fixture
+def slice_plot_data():
+    """Prepare data for slice plots."""
+    griddef = gs.GridDef([40, 0.5, 1, 40, 0.5, 1, 40, 0.5, 1])
+    return gs.ExampleData('3d_grid', griddef = griddef)
+
+@pytest.fixture
+def histogram_plot_data():
+    """Provide data for histogram plots"""
+    return gs.ExampleData('point3d_ind_mv')
+
+@pytest.fixture
+def histogram_simulation_data(plot_output_dir):
+    """Create simulation data for histogram testing."""
+    griddef = gs.GridDef([10, 1, 0.5, 10, 1, 0.5, 1, 1, 0.5])
+    size = griddef.count()
+    mean = 2.5
+    scale = 3
+    nreal = 100
+    ref_data = pd.DataFrame({'value': np.random.normal(mean, scale, size=size)})
+
+    for i, offset in enumerate(np.random.rand(nreal) * 0.04 - 0.02):
+        data = pd.DataFrame({'value': np.random.normal(mean + offset, scale, size=size)})
+        gs.write_gslib(data, os.path.join(plot_output_dir, f'real{i+1}.out'))
+
+    return griddef, nreal, ref_data
+
+
+@pytest.fixture
+def correlation_matrix_data():
+    """Provide correlation matrix data."""
+    dfl = gs.ExampleData("point3d_ind_mv")
+    data = dfl[dfl.variables]
+    return data.corr()
+
+
+@pytest.fixture
+def loadings_plot_data():
+    """Provide loadings plot data."""
+    refdata = gs.ExampleData('3d_correlation')
+    return refdata.data.corr().iloc[3:6, 6:9]
+
+
+@pytest.fixture
+def drill_plot_data():
+    """Provide drill plot data."""
+    dat = gs.ExampleData('point3d_ind_mv')
+    return dat.data[dat.data['HoleID'] == 3]
+
+
+@pytest.fixture
+def contour_plot_data():
+    """Provide contour plot data."""
+    grid_str = '''120 5.00  10.00 -nx, xmn, xsiz
+                110 1205.00  10.00 -ny, ymn, ysiz
+                1 0.5 1.0  -nz, zmn, zsiz'''
+    griddef = gs.GridDef(grid_str=grid_str)
+    return gs.ExampleData("grid2d_surf", griddef=griddef)
+
+
+
+def test_location_plot_simple(plot_output_dir, location_plot_data):
+    """Test capability of plotting by passing just the data file"""
+    output_file = os.path.join(plot_output_dir, "location_plot_test.png")
+    try:
+        _ = gs.location_plot(location_plot_data, output_file = output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the location plot with simple settings \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_location_plot_cmap(plot_output_dir, location_plot_data):
+    """Test capability of plottin by passing argument variable name to get color map"""
+    output_file = os.path.join(plot_output_dir, "location_plot_cmap_test.png")
+    _, ax = plt.subplots(1,1)
+
+    try:
+        _ = gs.location_plot(location_plot_data, var='Phi', output_file=output_file)
+        _ = gs.location_plot(location_plot_data, var='Phi', output_file=output_file, ax=ax)
+
+    except Exception as ex:
+        pytest.fail(f'Unable to test the location plot with passing variable name\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+def test_location_plot_lines(plot_output_dir, location_plot_data):
+    """Test plotting along xz/yz orientation and use the line plots based on drill hole id."""
+    output_file = os.path.join(plot_output_dir, "location_plot_lines_test.png")
+
+    try:
+        _ = gs.location_plot(
+        location_plot_data,
+        var = 'Phi',
+        orient = 'yz',
+        aspect=5,
+        plot_collar=True,
+        output_file=output_file
+    )
+
+    except Exception as ex:
+        pytest.fail(f'Unable to test the location plot along yz/xz orientation \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+def test_location_plot_categorical(plot_output_dir, location_plot_data):
+    """Test plotting categorical variables along xz/yz orientation."""
+    output_file = os.path.join(plot_output_dir, 'location_plot_categorical_test.png')
+    _, ax = plt.subplots(1, 1)
+    
+    try:
+        _ = gs.location_plot(
+            location_plot_data, 
+            var='Lithofacies', 
+            orient='yz', 
+            aspect=5, 
+            plot_collar=True, 
+            output_file=output_file
+        )
+        _ = gs.location_plot(
+            location_plot_data, 
+            var='Lithofacies', 
+            orient='yz', 
+            aspect=5, 
+            plot_collar=True, 
+            output_file=output_file, 
+            ax=ax
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the location plot for a categorical variable \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_accuracy_plot(plot_output_dir, accuracy_plot_data):
+    """Test the capability of plotting the accuracy with no function parameters"""
+    truth, reals = accuracy_plot_data
+    output_file = os.path.join(plot_output_dir, 'accuracy_plot_test.png')
+    _, ax = plt.subplots(1,1)
+
+    try:
+        gs.accuracy_plot(truth=truth, reals=reals, output_file=output_file)
+        gs.accuracy_plot(truth=truth, reals=reals, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the accuracy plot with simple settings \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_slice_plot_simple(plot_output_dir, slice_plot_data):
+    """Test the capability of plotting by passing only the data file"""
+    output_file = os.path.join(plot_output_dir, 'slice_plot_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.slice_plot(slice_plot_data, griddef=slice_plot_data.griddef, 
+                     orient='xy', cmap='viridis', output_file=output_file)
+        gs.slice_plot(slice_plot_data, griddef=slice_plot_data.griddef, 
+                     orient='xy', cmap='viridis', output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the slice plot with simple settings \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_slice_plot_with_thickness(plot_output_dir, slice_plot_data):
+    """Test the capability of plotting with slice thickness parameter"""
+    output_file = os.path.join(plot_output_dir, 'slice_plot_thickness_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.slice_plot(slice_plot_data, orient='xy', cmap='viridis', 
+                     output_file=output_file, slice_thickness=20)
+        gs.slice_plot(slice_plot_data, orient='xy', cmap='viridis', 
+                     output_file=output_file, slice_thickness=20, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the slice plot with thickness \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_grid_slice_plot_simple(plot_output_dir, slice_plot_data):
+    """Test the capability of grid slice plot with simple parameters"""
+    output_file = os.path.join(plot_output_dir, 'grid_slice_plot_test.png')
+    
+    try:
+        _ = gs.grid_slice_plot(slice_plot_data, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the grid slice plot with simple settings \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_grid_slice_plot_orient(plot_output_dir, slice_plot_data):
+    """Test the capability of specifying number of slices and orientation"""
+    output_file = os.path.join(plot_output_dir, 'grid_slice_plot_orient_test.png')
+    
+    try:
+        _ = gs.grid_slice_plot(slice_plot_data, orient='xz', n_slice=5, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the grid slice plot with orientation \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_grid_slice_plot_rows_cols(plot_output_dir, slice_plot_data):
+    """Test the capability of specifying number of rows or columns for slices"""
+    output_file = os.path.join(plot_output_dir, 'grid_slice_plot_rows_cols_test.png')
+    
+    try:
+        _ = gs.grid_slice_plot(slice_plot_data, orient='xz', n_slice=6, 
+                              ncol=2, nrow=3, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the grid slice plot with rows/columns \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
 
-	def test_scatter_plots(self):
-
-		'''
-		Test the capability of plotting a scatter plot with probability density estimate for multivariate data set
-		'''
-
-		output_file = os.path.join(self.out_dir, 'scatter_plots1.png')
-
-
-		try:
-			_ = gs.scatter_plots(self.data, nmax=1000, stat_xy=(0.95, 0.95), pad=(-1, -1), s=10, figsize=(10, 10), output_file = output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the scatter plots \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_scatter_plots_lu(self):
-
-		'''
-		Test the capability of plotting a scatter plot with probability density estimate for multivariate data set, creating an upper/lower matrix triangle of
-		scatterplots for comparing the scatter of multiple variables in two data sets
-		'''
-
-		output_file = os.path.join(self.out_dir, 'scatter_plots2.png')
-
-
-		try:
-			_ = gs.scatter_plots_lu(self.data, self.data, titles=('Data', 'Realization'), s=10, nmax=1000,
-							 stat_xy=(0.95, 0.95), pad=(-1, -1), figsize=(10, 10),
-							 align_orient=True, output_file = output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the scatter plots creating an upper/lower matrix triangle \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class QqPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-
-	def test_simple_plot(self):
-
-		'''
-		Test the capability of plotting a simple quantile by quantile comparison between two distributions
-		'''
-		import numpy as np
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'qq_plot1.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			_ = gs.qq_plot(np.random.randn(1000),np.random.randn(1000), npoints=500, output_file=output_file)
-			_ = gs.qq_plot(np.random.randn(1000),np.random.randn(1000), npoints=500, output_file=output_file, ax =ax)
-
-		except Exception as ex:
-			self.fail('Unable to test the qq_plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-		
-
-class ProbabilityPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-
-	def test_simple_plot(self):
-
-		'''
-		Test the capability of plotting a CDF with probability scale
-		'''
-		from matplotlib import pyplot as plt
-
-		output_file = os.path.join(self.out_dir, 'probability_plot1.png')
-
-		_, ax = plt.subplots(1,1)
-		try:
-			data = gs.ExampleData('oilsands')
-			_ = gs.probability_plot(data.data['Fines'], logscale=False, output_file=output_file)
-			_ = gs.probability_plot(data.data['Fines'], logscale=False, output_file=output_file, ax =ax)
-		except Exception as ex:
-			self.fail('Unable to test the probability_plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class ValidationPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-
-
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting a simple scatter plot to compare estimate vs truth
-		'''
-		from matplotlib import pyplot as plt 
-
-		output_file = os.path.join(self.out_dir, 'validation_plot1.png')
-		_, ax = plt.subplots(1,1)
-
-		try:
-			data = gs.ExampleData('3d_estimate')
-			_ = gs.validation_plot(data.data['Estimate'], data.data['True'], stat_blk='minimal', output_file = output_file)
-			_ = gs.validation_plot(data.data['Estimate'], data.data['True'], stat_blk='minimal', output_file = output_file, ax =ax)
-
-		except Exception as ex:
-			self.fail('Unable to test the validation_plot with simple settings\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-	def test_detailed_plot(self):
-		'''
-		Test the capability of plotting a simple scatter plot to compare estimate vs truth
-		'''
-		from matplotlib import pyplot as plt 
-
-		output_file = os.path.join(self.out_dir, 'validation_plot2.png')
-		_, ax =plt.subplots(1,1)
-
-		try:
-			mean = [0, 0]
-			cov = [[1, 0.95], [0.95, 1]]  # diagonal covariance
-			x, y = np.random.multivariate_normal(mean, cov, 5000).T
-			gs.validation_plot(x,y,vlim=(-3.5, 3.5) ,grid=True, stat_xy=(1, 0.68), output_file=output_file)
-			gs.validation_plot(x,y,vlim=(-3.5, 3.5) ,grid=True, stat_xy=(1, 0.68), output_file=output_file, ax =ax)
-
-		except Exception as ex:
-			self.fail('Unable to test the validation_plot \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class LoadingsPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-		refdata = gs.ExampleData('3d_correlation')
-		self.loadmat = refdata.data.corr().iloc[3:6,6:9]
-
-	def test_simple_plot1(self):
-		'''
-		Test the capability of plotting a simple loadings plot for original variables and the principal components (using pandas dataframe)
-		'''
-
-		output_file = os.path.join(self.out_dir, 'loadings_plot1.png')
-
-		try:
-			_ = gs.loadings_plot(self.loadmat, output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the loadings_plot with simple settings (using pandas dataframe)\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_simple_plot2(self):
-		'''
-		Test the capability of plotting a simple loadings plot for original variables and the principal components (using a numpy array)
-		'''
-
-		output_file = os.path.join(self.out_dir, 'loadings_plot2.png')
-
-		try:
-			_ = gs.loadings_plot(self.loadmat.values, output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the loadings_plot with simple settings (using a numpy array)\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_with_labels(self):
-		'''
-		Test the capability of plotting a loadings plot with detailed settings for original variables and the principal components
-		'''
-
-		output_file = os.path.join(self.out_dir, 'loadings_plot3.png')
-
-		try:
-			_ = gs.loadings_plot(self.loadmat.values, figsize=(4,4), xticklabels=['PC1', 'PC2', 'PC3'], yticklabels=['InputVariable1', 'InputVariable2', 'InputVariable3'], output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the loadings_plot with  tick labels and figsize\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_with_tickrotation(self):
-		'''
-		Test the capability of plotting a loadings plot with detailed settings for original variables and the principal components
-		'''
-
-		output_file = os.path.join(self.out_dir, 'loadings_plot4.png')
-
-		try:
-			_ = gs.loadings_plot(self.loadmat.values, figsize=(5,5), xticklabels=['PC1', 'PC2', 'PC3'],
-				 yticklabels=['InputVariable1', 'InputVariable2', 'InputVariable3'],
-				 rotateticks=(False, True), output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the loadings_plot with tick rotation settings\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-class DrillPlotTest(BaseTest):
-
-	def setUp(self):
-		super().setUp()
-		dat = gs.ExampleData('point3d_ind_mv')
-		self.data = dat.data[dat.data['HoleID'] == 3]
-
-	def test_continuous_plot(self):
-		'''
-		Test the capability of plotting a continuous variable
-		'''
-
-		output_file = os.path.join(self.out_dir, 'drill_plot1.png')
-
-		try:
-			_ = gs.drill_plot(self.data['Elevation'], self.data['Sw'], grid = True, output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the drill_plot for a continuous variable\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-
-
-	def test_categorical_plot(self):
-		'''
-		Test the capability of plotting a categorical variable
-		'''
-
-		output_file = os.path.join(self.out_dir, 'drill_plot2.png')
-
-		try:
-			_ = gs.drill_plot(self.data['Elevation'], self.data['Lithofacies'], output_file=output_file)
-
-		except Exception as ex:
-			self.fail('Unable to test the drill_plot for a categorical variable\n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
 
+def test_grid_slice_plot_custom(plot_output_dir, slice_plot_data):
+    """Test the ability to specify slice_plot kwargs for consistent formatting"""
+    output_file = os.path.join(plot_output_dir, 'grid_slice_plot_custom_test.png')
+    
+    try:
+        _ = gs.grid_slice_plot(slice_plot_data, nrow=2, ncol=5, start_slice=10, 
+                              end_slice=25, n_slice=10, cmap='hot', vlim=(-3, 3), 
+                              output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the grid slice plot with custom settings \n{str(ex)}')
 
-	def test_categorical_custom_plot(self):
-		'''
-		Test the capability of plotting a categorical variable with custom categorical dictionary
-		'''
+    assert os.path.isfile(output_file)
 
-		output_file = os.path.join(self.out_dir, 'drill_plot3.png')
 
-		try:
-			cat_dict = {1: {'name': 'Sand', 'color': 'gold'},
-			3: {'name': 'SHIS','color': 'orange'},
-			4: {'name': 'MHIS','color': 'green'},
-			5: {'name': 'MUD','color': 'gray'}}
+def test_histogram_plot_simple(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting a simple histogram"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_test.png')
+    _, ax = plt.subplots(1, 1)
 
-			_ = gs.drill_plot(self.data['Elevation'], self.data['Lithofacies'], categorical_dictionary=cat_dict, output_file=output_file)
+    try:
+        gs.histogram_plot(histogram_plot_data, var="Phi", bins=30, output_file=output_file)
+        gs.histogram_plot(histogram_plot_data, var="Phi", bins=30, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot with simple settings \n{str(ex)}')
 
-		except Exception as ex:
-			self.fail('Unable to test the drill_plot for a categorical variable with custom categorical dictionary\n{}'.format(str(ex)))
+    assert os.path.isfile(output_file)
 
-		self.assertEqual(os.path.isfile(output_file), True)
 
+def test_histogram_plot_density_color(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting a histogram with density and custom colour"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_density_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.histogram_plot(histogram_plot_data, var="Phi", bins=30, color='#c2e1e5', 
+                         sigfigs=5, log=True, density=True, output_file=output_file)
+        gs.histogram_plot(histogram_plot_data, var="Phi", bins=30, color='#c2e1e5', 
+                         sigfigs=5, log=True, density=True, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot with density and color \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_histogram_plot_icdf(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting a histogram with icdf and custom stat location"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_icdf_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.histogram_plot(histogram_plot_data, var="Phi", icdf=True, color=3, 
+                         lw=3.5, stat_xy=(1, 0.75), output_file=output_file)
+        gs.histogram_plot(histogram_plot_data, var="Phi", icdf=True, color=3, 
+                         lw=3.5, stat_xy=(1, 0.75), output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot for icdf \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
 
-class VariogramPlotTest(BaseTest):
 
-	def setUp(self):
-		super().setUp()
+def test_histogram_plot_categories(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting a histogram with categorical variables"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_categories_test.png')
+
+    try:
+        cats = [1, 2, 3, 4, 5]
+        colors = gs.catcmapfromcontinuous("Spectral", 5).colors
+        histogram_plot_data.catdict = {c: f"RT {c:02d}" for c in cats}
+        colordict = {c: colors[i] for i, c in enumerate(cats)}
+
+        gs.histogram_plot(histogram_plot_data, var='Phi', cat=True, color=colordict, 
+                         bins=40, figsize=(8, 4), xlabel=False, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot with categories \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_histogram_plot_cdf_categories(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting cdfs with different categorical variables"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_cdf_categories_test.png')
 
-	def test_experimental_plot(self):
-		'''
-		Test the capability of plotting experimental variograms
-		'''
+    try:
+        cats = [1, 2, 3, 4, 5]
+        colors = gs.catcmapfromcontinuous("Spectral", 5).colors
+        histogram_plot_data.catdict = {c: f"RT {c:02d}" for c in cats}
+        colordict = {c: colors[i] for i, c in enumerate(cats)}
+
+        _, axs = plt.subplots(2, 2, figsize=(12, 9))
+        axs = axs.flatten()
+
+        for var, ax in zip(histogram_plot_data.variables, axs):
+            gs.histogram_plot(histogram_plot_data, var=var, icdf=True, cat=True, 
+                             color=colordict, ax=ax, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot for cdf categories \n{str(ex)}')
 
-		output_file = os.path.join(self.out_dir, 'variogram_plot1.png')
+    assert os.path.isfile(output_file)
 
-		try:
-			dfl = gs.ExampleData('experimental_variogram')
-			_ = gs.variogram_plot(dfl, experimental=True, figsize=(8,4), output_file=output_file)
 
-		except Exception as ex:
-			self.fail('Unable to test the variogram_plot for experimental variogram\n{}'.format(str(ex)))
+def test_histogram_plot_proportions(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting histogram for categorical proportions"""
+    output_file = os.path.join(plot_output_dir, 'histogram_plot_proportions_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        cats = [1, 2, 3, 4, 5]
+        colors = gs.catcmapfromcontinuous("Spectral", 5).colors
+        histogram_plot_data.catdict = {c: f"RT {c:02d}" for c in cats}
+        colordict = {c: colors[i] for i, c in enumerate(cats)}
+
+        gs.histogram_plot(histogram_plot_data, cat=True, color=colordict, bins=40, 
+                         figsize=(8, 4), xlabel=False, output_file=output_file)
+        gs.histogram_plot(histogram_plot_data, cat=True, color=colordict, bins=40, 
+                         figsize=(8, 4), xlabel=False, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram plot for proportions\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_histogram_reproduction_plot(plot_output_dir, histogram_simulation_data):
+    """Test the capability of plotting histogram reproduction"""
+    griddef, nreal, ref_data = histogram_simulation_data
+    output_file = os.path.join(plot_output_dir, 'histplt_sim_test.png')
+
+    try:
+        gs.histogram_plot_simulation(
+            os.path.join(plot_output_dir, 'real*.out'), 
+            ref_data, 
+            reference_variable='value',
+            reference_color='C3', 
+            simulated_column=1, 
+            griddef=griddef, 
+            simulation_color='cyan',
+            title='var', 
+            grid=True, 
+            nreal=nreal, 
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the histogram reproduction plot \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_correlation_matrix_plot_simple(plot_output_dir, correlation_matrix_data):
+    """Test the capability of plotting a simple correlation matrix"""
+    output_file = os.path.join(plot_output_dir, 'correlation_matrix_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.correlation_matrix_plot(correlation_matrix_data, output_file=output_file)
+        gs.correlation_matrix_plot(correlation_matrix_data, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the correlation matrix plot \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_correlation_matrix_plot_lower(plot_output_dir, correlation_matrix_data):
+    """Test the capability of plotting lower part of a correlation matrix"""
+    output_file = os.path.join(plot_output_dir, 'correlation_matrix_lower_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.correlation_matrix_plot(correlation_matrix_data, lower_matrix=True, 
+                                  annotation=True, output_file=output_file)
+        gs.correlation_matrix_plot(correlation_matrix_data, lower_matrix=True, 
+                                  annotation=True, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the correlation matrix plot with lower matrix\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_scatter_plot_simple(plot_output_dir, histogram_plot_data):
+    """Test the capability of plotting a scatter plot with probability density"""
+    output_file = os.path.join(plot_output_dir, 'scatter_plot_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        gs.scatter_plot(histogram_plot_data[histogram_plot_data.variables[0]], 
+                       histogram_plot_data[histogram_plot_data.variables[1]], 
+                       cmap='hot', cbar=True, output_file=output_file)
+        gs.scatter_plot(histogram_plot_data[histogram_plot_data.variables[0]], 
+                       histogram_plot_data[histogram_plot_data.variables[1]], 
+                       cmap='hot', cbar=True, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the scatter plot \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_scatter_plots_multivariate(plot_output_dir, histogram_plot_data):
+    """Test scatter plots with probability density for multivariate data"""
+    output_file = os.path.join(plot_output_dir, 'scatter_plots_multivariate_test.png')
+
+    try:
+        _ = gs.scatter_plots(histogram_plot_data, nmax=1000, stat_xy=(0.95, 0.95), 
+                            pad=(-1, -1), s=10, figsize=(10, 10), output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the scatter plots \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_scatter_plots_lu(plot_output_dir, histogram_plot_data):
+    """Test scatter plots with upper/lower matrix for comparing datasets"""
+    output_file = os.path.join(plot_output_dir, 'scatter_plots_lu_test.png')
+
+    try:
+        _ = gs.scatter_plots_lu(
+            histogram_plot_data, 
+            histogram_plot_data, 
+            titles=('Data', 'Realization'), 
+            s=10, 
+            nmax=1000,
+            stat_xy=(0.95, 0.95), 
+            pad=(-1, -1), 
+            figsize=(10, 10),
+            align_orient=True, 
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the scatter plots with upper/lower matrix \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_qq_plot(plot_output_dir):
+    """Test the capability of plotting a simple quantile-quantile comparison"""
+    output_file = os.path.join(plot_output_dir, 'qq_plot_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        _ = gs.qq_plot(np.random.randn(1000), np.random.randn(1000), 
+                      npoints=500, output_file=output_file)
+        _ = gs.qq_plot(np.random.randn(1000), np.random.randn(1000), 
+                      npoints=500, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the qq_plot \n{str(ex)}')
 
-		self.assertEqual(os.path.isfile(output_file), True)
+    assert os.path.isfile(output_file)
 
-	def test_model_plot(self):
-		'''
-		Test the capability of plotting variogram models
-		'''
 
-		output_file = os.path.join(self.out_dir, 'variogram_plot2.png')
+def test_probability_plot(plot_output_dir):
+    """Test the capability of plotting a CDF with probability scale"""
+    output_file = os.path.join(plot_output_dir, 'probability_plot_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        data = gs.ExampleData('oilsands')
+        _ = gs.probability_plot(data.data['Fines'], logscale=False, output_file=output_file)
+        _ = gs.probability_plot(data.data['Fines'], logscale=False, output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the probability_plot \n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_validation_plot_simple(plot_output_dir):
+    """Test plotting a simple scatter plot to compare estimate vs truth"""
+    output_file = os.path.join(plot_output_dir, 'validation_plot_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        data = gs.ExampleData('3d_estimate')
+        _ = gs.validation_plot(data.data['Estimate'], data.data['True'], 
+                              stat_blk='minimal', output_file=output_file)
+        _ = gs.validation_plot(data.data['Estimate'], data.data['True'], 
+                              stat_blk='minimal', output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the validation_plot with simple settings\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_validation_plot_detailed(plot_output_dir):
+    """Test plotting a detailed validation plot with statistics"""
+    output_file = os.path.join(plot_output_dir, 'validation_plot_detailed_test.png')
+    _, ax = plt.subplots(1, 1)
+
+    try:
+        mean = [0, 0]
+        cov = [[1, 0.95], [0.95, 1]]
+        x, y = np.random.multivariate_normal(mean, cov, 5000).T
+        
+        gs.validation_plot(x, y, vlim=(-3.5, 3.5), grid=True, 
+                          stat_xy=(1, 0.68), output_file=output_file)
+        gs.validation_plot(x, y, vlim=(-3.5, 3.5), grid=True, 
+                          stat_xy=(1, 0.68), output_file=output_file, ax=ax)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the validation_plot with detailed settings\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_loadings_plot_dataframe(plot_output_dir, loadings_plot_data):
+    """Test plotting a loadings plot using pandas dataframe"""
+    output_file = os.path.join(plot_output_dir, 'loadings_plot_dataframe_test.png')
+
+    try:
+        _ = gs.loadings_plot(loadings_plot_data, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the loadings_plot with pandas dataframe\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_loadings_plot_array(plot_output_dir, loadings_plot_data):
+    """Test plotting a loadings plot using numpy array"""
+    output_file = os.path.join(plot_output_dir, 'loadings_plot_array_test.png')
+
+    try:
+        _ = gs.loadings_plot(loadings_plot_data.values, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the loadings_plot with numpy array\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_loadings_plot_labels(plot_output_dir, loadings_plot_data):
+    """Test plotting a loadings plot with custom labels"""
+    output_file = os.path.join(plot_output_dir, 'loadings_plot_labels_test.png')
 
-		try:
-			dfl = gs.ExampleData('variogram_model')
-			_ = gs.variogram_plot(dfl, experimental=False, lw = 3, figsize=(8,4), output_file=output_file)
+    try:
+        _ = gs.loadings_plot(
+            loadings_plot_data.values, 
+            figsize=(4, 4), 
+            xticklabels=['PC1', 'PC2', 'PC3'], 
+            yticklabels=['InputVariable1', 'InputVariable2', 'InputVariable3'],
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the loadings_plot with custom labels\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
 
-		except Exception as ex:
-			self.fail('Unable to test the variogram_plot for experimental variogram\n{}'.format(str(ex)))
 
-		self.assertEqual(os.path.isfile(output_file), True)
+def test_loadings_plot_tick_rotation(plot_output_dir, loadings_plot_data):
+    """Test plotting a loadings plot with tick rotation"""
+    output_file = os.path.join(plot_output_dir, 'loadings_plot_rotation_test.png')
 
+    try:
+        _ = gs.loadings_plot(
+            loadings_plot_data.values, 
+            figsize=(5, 5), 
+            xticklabels=['PC1', 'PC2', 'PC3'],
+            yticklabels=['InputVariable1', 'InputVariable2', 'InputVariable3'],
+            rotateticks=(False, True), 
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the loadings_plot with tick rotation\n{str(ex)}')
 
-class ContourPlotTest(BaseTest):
-	'''
-	 Test suite for pygeostat countour_plot
-	'''
+    assert os.path.isfile(output_file)
 
-	def setUp(self):
-		super().setUp()
-		grid_str = '''120 5.00  10.00 -nx, xmn, xsiz
-					110 1205.00  10.00 -ny, ymn, ysiz
-					1 0.5 1.0  -nz, zmn, zsiz'''
-		
-		griddef = gs.GridDef(grid_str=grid_str)
-		self.data = gs.ExampleData("grid2d_surf", griddef=griddef)
 
-	def test_simple_plot(self):
-		'''
-		Test the capability of plotting by passing only the essential parameters
-		'''
-		
+def test_drill_plot_continuous(plot_output_dir, drill_plot_data):
+    """Test plotting a continuous variable in a drill plot"""
+    output_file = os.path.join(plot_output_dir, 'drill_plot_continuous_test.png')
+
+    try:
+        _ = gs.drill_plot(
+            drill_plot_data['Elevation'], 
+            drill_plot_data['Sw'], 
+            grid=True, 
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the drill_plot for continuous variable\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_drill_plot_categorical(plot_output_dir, drill_plot_data):
+    """Test plotting a categorical variable in a drill plot"""
+    output_file = os.path.join(plot_output_dir, 'drill_plot_categorical_test.png')
+
+    try:
+        _ = gs.drill_plot(
+            drill_plot_data['Elevation'], 
+            drill_plot_data['Lithofacies'], 
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the drill_plot for categorical variable\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_drill_plot_categorical_custom(plot_output_dir, drill_plot_data):
+    """Test plotting a categorical variable with custom dictionary"""
+    output_file = os.path.join(plot_output_dir, 'drill_plot_categorical_custom_test.png')
+
+    try:
+        cat_dict = {
+            1: {'name': 'Sand', 'color': 'gold'},
+            3: {'name': 'SHIS', 'color': 'orange'},
+            4: {'name': 'MHIS', 'color': 'green'},
+            5: {'name': 'MUD', 'color': 'gray'}
+        }
+
+        _ = gs.drill_plot(
+            drill_plot_data['Elevation'],
+            drill_plot_data['Lithofacies'],
+            categorical_dictionary=cat_dict,
+            output_file=output_file
+        )
+    except Exception as ex:
+        pytest.fail(f'Unable to test the drill_plot with custom categorical dictionary\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_variogram_plot_experimental(plot_output_dir):
+    """Test plotting experimental variograms"""
+    output_file = os.path.join(plot_output_dir, 'variogram_plot_experimental_test.png')
+
+    try:
+        dfl = gs.ExampleData('experimental_variogram')
+        _ = gs.variogram_plot(dfl, experimental=True, figsize=(8, 4), output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the variogram_plot for experimental variogram\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_variogram_plot_model(plot_output_dir):
+    """Test plotting variogram models"""
+    output_file = os.path.join(plot_output_dir, 'variogram_plot_model_test.png')
+
+    try:
+        dfl = gs.ExampleData('variogram_model')
+        _ = gs.variogram_plot(dfl, experimental=False, lw=3, figsize=(8, 4), output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the variogram_plot for model\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+def test_contour_plot_simple(plot_output_dir, contour_plot_data):
+    """Test plotting contours with essential parameters"""
+    output_file = os.path.join(plot_output_dir, 'contour_plot_test.png')
+
+    try:
+        _ = gs.contour_plot(contour_plot_data, var="Thickness", clabel=True, output_file=output_file)
+    except Exception as ex:
+        pytest.fail(f'Unable to test the contour plot with simple settings\n{str(ex)}')
+
+    assert os.path.isfile(output_file)
+
+
+@pytest.mark.skip(reason="Requires additional setup for gmm_file path")
+def test_gmm_plotting():
+    """Test GMM plotting utilities"""
+    # This test depends on locating the gmm_file correctly
+    # We'll skip it in this conversion but keep the structure
+    
+    try:
+        # Path needs to be adjusted for your environment
+        gmm_file = os.path.join(os.path.dirname(os.getcwd()), 
+                    'pygeostat', 'src', 'pygeostat', 'data', 'example_data', 'gmm_fit.out')
+        gmm_file = os.path.normpath(gmm_file)
+        
+        gmm_util = gs.GmmUtility(
+            gmm_file=gmm_file,
+            data=gs.ExampleData('point2d_mv').data, 
+            variable_names=['Var1', 'Var2', 'Var3']
+        )
+        
+        # Test bivariate plot
+        gmm_util.bivariate_plot(var_index=[1, 2], cmap='viridis', title='Bivariate Plot')
+        
+        # Test summary plot
+        gmm_util.summary_plot(pad=0.1)
+        
+        # Test conditional plot
+        gmm_util.univariate_conditional_plot(conditioning_data=[0, 0, None])
+        
+    except Exception as ex:
+        pytest.fail(f'Unable to test GMM plotting: {str(ex)}')
 
-		output_file = os.path.join(self.out_dir, 'countour_plot1.png')
-		try:
-			_ = gs.contour_plot(self.data, var="Thickness", clabel=True, output_file=output_file)
-		except Exception as ex:
-			self.fail('Unable to test the countour plot with simple settings \n{}'.format(str(ex)))
-
-		self.assertEqual(os.path.isfile(output_file), True)
-	
-	def test_gmm_plot(self):
-		'''
-		Test the GMM plotting
-		'''
-		try:
-			gmm_file = os.path.join(os.path.dirname(os.getcwd()), 
-                        'pygeostat', 'src', 'pygeostat', 'data', 'example_data', 'gmm_fit.out')
-			gmm_file = os.path.normpath(gmm_file)
-			gmm_util = gs.GmmUtility(gmm_file=gmm_file,
-                      data=gs.ExampleData('point2d_mv').data, variable_names=['Var1', 'Var2','Var3'])
-		except Exception as ex:
-			self.fail('Unable to test GmmUtility \n{}'.format(str(ex)))
-		try:
-			gmm_util.bivariate_plot(var_index=[1,2], cmap='viridis',title='Bivariate Plot')
-		except Exception as ex:
-			self.fail('Unable to test bivariate_plot \n{}'.format(str(ex)))
-		try:
-			gmm_util.summary_plot(pad=0.1)
-		except Exception as ex:
-			self.fail('Unable to test summary_plot \n{}'.format(str(ex)))
-		try:
-			gmm_util.univariate_conditional_plot(conditioning_data=[0, 0,None])
-		except Exception as ex:
-			self.fail('Unable to test univariate_conditional_plot \n{}'.format(str(ex)))
-
-if __name__ == '__main__':
-	subprocess.call([sys.executable, '-m', 'unittest', str(__file__), '-v'])
diff --git a/tests/test_utility.py b/tests/test_utility.py
index aed39b2..40def3f 100644
--- a/tests/test_utility.py
+++ b/tests/test_utility.py
@@ -1,42 +1,18 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function
 
-__author__ = 'pygeostat development team'
-__date__ = '2020-01-04'
-__version__ = '1.0.0'
+"""Tests for utility functions in pygeostat"""
 
 import os
 import sys
-try:
-    import pygeostat as gs
-except (ImportError, ModuleNotFoundError):
-    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), r'..')))
-    import pygeostat as gs
+import pytest
+import pygeostat as gs
 
-import unittest
-import warnings
-import subprocess
+def test_token_error():
+    """Test if the proper error handling is in place for wrong access token"""
+    wrong_token = 'wrong_token'
 
+    with pytest.raises(Exception):
+        gs.get_executable(source='ccg', acess_token=wrong_token)
 
-class GetExecutableTest(unittest.TestCase):
 
-    '''
-    Test suite for loading executable files from a protected repository
-    '''
-
-    def setUp(self):
-
-        self.wrong_token = 'wrong_token'
-
-    def test_token_error(self):
-        '''
-        Test if the proper error handleing is in place for wrong access token
-        '''
-
-        with self.assertRaises(Exception):
-            gs.get_executable(source='ccg', access_token=self.wrong_token)
-
-
-if __name__ == '__main__':
-    subprocess.call([sys.executable, '-m', 'unittest', str(__file__), '-v'])