@@ -452,23 +452,111 @@ def test_percentformatter():
 
 def test_EngFormatter_formatting():
     """
-    Create two instances of EngFormatter with default parameters, with and
-    without a unit string ('s' for seconds). Test the formatting in some cases,
-    especially the case when no SI prefix is present, for values in [1, 1000).
+    Test instances of EngFormatter for different values of the kwarg `places`,
+    with and without a unit symbol, as well as with and without a space
+    separator between the value and the prefix/unit.
 
-    Should not raise exceptions.
+    Should not exception.
     """
-    unitless = mticker.EngFormatter()
-    nose.tools.assert_equal(unitless(0.1), u'100 m')
-    nose.tools.assert_equal(unitless(1), u'1')
-    nose.tools.assert_equal(unitless(999.9), u'999.9')
-    nose.tools.assert_equal(unitless(1001), u'1.001 k')
-
-    with_unit = mticker.EngFormatter(unit=u's')
-    nose.tools.assert_equal(with_unit(0.1), u'100 ms')
-    nose.tools.assert_equal(with_unit(1), u'1 s')
-    nose.tools.assert_equal(with_unit(999.9), u'999.9 s')
-    nose.tools.assert_equal(with_unit(1001), u'1.001 ks')
+    UNIT = u's'
+    DIGITS = set([u'{0:d}'.format(d) for d in range(10)])
+
+    # Case A/ With kwarg `places=None` (default)
+    A_wo_unit_w_sep = ((-1234.56789, u'-1.23457 k'),
+                       (-1.23456789, u'-1.23457'),
+                       (-0.123456789, u'-123.457 m'),
+                       (-0.00123456789, u'-1.23457 m'),
+                       (-0.0, u'0'),
+                       (-0, u'0'),
+                       (0, u'0'),
+                       (1.23456789e-6, u'1.23457 \u03bc'),
+                       (0.123456789, u'123.457 m'),
+                       (1, u'1'),
+                       (1.23456789, u'1.23457'),
+                       (999.9, u'999.9'),
+                       (1000, u'1 k'),
+                       (1001, u'1.001 k'),
+                       (100001, u'100.001 k'),
+                       (987654.321, u'987.654 k'))
+
+    # Case B/ With kwarg `places=0`
+    B_wo_unit_w_sep = ((-1234.56789, u'-1 k'),
+                       (-1.23456789, u'-1'),
+                       (-0.123456789, u'-123 m'),
+                       (-0.00123456789, u'-1 m'),
+                       (-0.0, u'0'),
+                       (-0, u'0'),
+                       (0, u'0'),
+                       (1.23456789e-6, u'1 \u03bc'),
+                       (0.123456789, u'123 m'),
+                       (1, u'1'),
+                       (1.23456789, u'1'),
+                       (999.9, u'999'),
+                       (1000, u'1 k'),
+                       (1001, u'1 k'),
+                       (100001, u'100 k'),
+                       (987654.321, u'987 k'))
+
+    # Case C/ With kwarg `places=2`
+    C_wo_unit_w_sep = ((-1234.56789, u'-1.23 k'),
+                       (-1.23456789, u'-1.23'),
+                       (-0.123456789, u'-123.46 m'),
+                       (-0.00123456789, u'-1.23 m'),
+                       (-0.0, u'0.00'),
+                       (-0, u'0.00'),
+                       (0, u'0.00'),
+                       (1.23456789e-6, u'1.23 \u03bc'),
+                       (0.123456789, u'123.46 m'),
+                       (1, u'1.00'),
+                       (1.23456789, u'1.23'),
+                       (999.9, u'999.90'),
+                       (1000, u'1.00 k'),
+                       (1001, u'1.00 k'),
+                       (100001, u'100.00 k'),
+                       (987654.321, u'987.65 k'))
+
+    for ref_cases, places in ((A_wo_unit_w_sep, None),
+                              (B_wo_unit_w_sep, 0),
+                              (C_wo_unit_w_sep, 2)):
+
+        """ Test an EngFormatter instance w/o unit and w/ space separator
+        (default)
+        """
+        eng_formatter = mticker.EngFormatter(places=places)
+        for value, expected_string in ref_cases:
+            nose.tools.assert_equal(eng_formatter(value), expected_string)
+
+        """ Test an EngFormatter instance w/ unit and w/ space separator
+        """
+        eng_formatter = mticker.EngFormatter(unit=UNIT, places=places)
+        # Append a unit symbol to the reference cases
+        # Beware of the case of values in [1, 1000), where there is no prefix!
+        test_cases = ((val, u"{s:s} {u:s}".format(s=s, u=UNIT))
+                      if s[-1] in DIGITS  # i.e. if no prefix is present
+                      else (val, u"{s:s}{u:s}".format(s=s, u=UNIT))
+                      for val, s in ref_cases)
+        for value, expected_string in test_cases:
+            nose.tools.assert_equal(eng_formatter(value), expected_string)
+
+        """ Test an EngFormatter instance w/o unit and w/o space separator
+        """
+        eng_formatter = mticker.EngFormatter(places=places, space_sep=False)
+        # Remove the space separator from the reference cases
+        test_cases = ((val, u"{s:s}".format(s=s.replace(" ", "")))
+                      for val, s in ref_cases)
+        for value, expected_string in test_cases:
+            nose.tools.assert_equal(eng_formatter(value), expected_string)
+
+        """ Test an EngFormatter instance w/ unit and w/o space separator
+        """
+        eng_formatter = mticker.EngFormatter(unit=UNIT, places=places,
+                                             space_sep=False)
+        # Remove the space separator from the reference cases
+        # and append them a unit symbol
+        test_cases = ((val, u"{s:s}{u:s}".format(s=s.replace(" ", ""), u=UNIT))
+                      for val, s in ref_cases)
+        for value, expected_string in test_cases:
+            nose.tools.assert_equal(eng_formatter(value), expected_string)
 
 if __name__ == '__main__':
     import nose