diff --git a/tests/searchcommands/test_decorators.py b/tests/searchcommands/test_decorators.py
index 082ab184..dd65aa0a 100755
--- a/tests/searchcommands/test_decorators.py
+++ b/tests/searchcommands/test_decorators.py
@@ -381,6 +381,7 @@ def test_option(self):
             validators.Fieldname: ('some.field_name', 'non-fieldname value'),
             validators.File: (__file__, 'non-existent file'),
             validators.Integer: ('100', 'non-integer value'),
+            validators.Float: ('99.9', 'non-float value'),
             validators.List: ('a,b,c', '"non-list value'),
             validators.Map: ('foo', 'non-existent map entry'),
             validators.Match: ('123-45-6789', 'not a social security number'),
@@ -459,17 +460,17 @@ def test_option(self):
                 self.assertEqual(expected[x.name], x.value.pattern)
             elif isinstance(x.value, TextIOWrapper):
                 self.assertEqual(expected[x.name], "'%s'" % x.value.name)
-            elif not isinstance(x.value, (bool,) + (six.text_type,) + (six.binary_type,) + tuplewrap(six.integer_types)):
+            elif not isinstance(x.value, (bool,) + (float,) + (six.text_type,) + (six.binary_type,) + tuplewrap(six.integer_types)):
                 self.assertEqual(expected[x.name], repr(x.value))
             else:
                 self.assertEqual(expected[x.name], x.value)
 
         expected = (
             'foo="f" boolean="f" code="foo == \\"bar\\"" duration="24:59:59" fieldname="some.field_name" '
-            'file=' + json_encode_string(__file__) + ' integer="100" float="99.9" map="foo" match="123-45-6789" '
+            'file=' + json_encode_string(__file__) + ' float="99.9" integer="100" map="foo" match="123-45-6789" '
             'optionname="some_option_name" record="f" regularexpression="\\\\s+" required_boolean="f" '
             'required_code="foo == \\"bar\\"" required_duration="24:59:59" required_fieldname="some.field_name" '
-            'required_file=' + json_encode_string(__file__) + ' required_integer="100" required_float="99.9" required_map="foo" '
+            'required_file=' + json_encode_string(__file__) + ' required_float="99.9" required_integer="100" required_map="foo" '
             'required_match="123-45-6789" required_optionname="some_option_name" required_regularexpression="\\\\s+" '
             'required_set="bar" set="bar" show_configuration="f"')
 
diff --git a/tests/searchcommands/test_validators.py b/tests/searchcommands/test_validators.py
index 8532fa42..38836c4a 100755
--- a/tests/searchcommands/test_validators.py
+++ b/tests/searchcommands/test_validators.py
@@ -208,9 +208,10 @@ def test(integer):
     
     def test_float(self):
         # Float validator test
+        import random
 
-        maxsize = sys.maxsize
-        minsize = -(sys.maxsize - 1)
+        maxsize = random.random() + 1
+        minsize = random.random() - 1
 
         validator = validators.Float()
 
@@ -221,7 +222,7 @@ def test(float_val):
                 assert False
             for s in str(float_val), six.text_type(float_val):
                 value = validator.__call__(s)
-                self.assertEqual(value, float_val)
+                self.assertAlmostEqual(value, float_val)
                 self.assertIsInstance(value, float)
             self.assertEqual(validator.format(float_val), six.text_type(float_val))
 
@@ -240,27 +241,25 @@ def test(float_val):
         self.assertEqual(validator.__call__(0), 0)
         self.assertEqual(validator.__call__(1.154), 1.154)
         self.assertEqual(validator.__call__(888.51), 888.51)
-        self.assertEqual(validator.__call__(2 * maxsize), float(2 * maxsize))
+        self.assertEqual(validator.__call__(2 * maxsize), (2 * maxsize))
         self.assertRaises(ValueError, validator.__call__, -1)
         self.assertRaises(ValueError, validator.__call__, -1111.00578)
         self.assertRaises(ValueError, validator.__call__, -0.005)
 
         validator = validators.Float(minimum=1, maximum=maxsize)
         self.assertEqual(validator.__call__(1), float(1))
-        self.assertEqual(validator.__call__(100.111), 100.111)
-        self.assertEqual(validator.__call__(9999.0), 9999.0)
-        self.assertEqual(validator.__call__(maxsize), float(maxsize))
+        self.assertEqual(validator.__call__(maxsize), maxsize)
         self.assertRaises(ValueError, validator.__call__, 0)
         self.assertRaises(ValueError, validator.__call__, 0.9999)
-        self.assertRaises(ValueError, validator.__call__, -199)
         self.assertRaises(ValueError, validator.__call__, maxsize + 1)
 
-        validator = validators.Float(minimum=-1, maximum=1)
-        self.assertEqual(validator.__call__(0), float(0))
+        validator = validators.Float(minimum=minsize, maximum=maxsize)
+        self.assertEqual(validator.__call__(minsize), minsize)
         self.assertEqual(validator.__call__(0.123456), 0.123456)
+        self.assertEqual(validator.__call__(0), float(0))
         self.assertEqual(validator.__call__(-0.012), -0.012)
-        self.assertRaises(ValueError, validator.__call__, -1.1)
-        self.assertRaises(ValueError, validator.__call__, 100.123456)
+        self.assertEqual(validator.__call__(maxsize), maxsize)
+        self.assertRaises(ValueError, validator.__call__, minsize - 1)
         self.assertRaises(ValueError, validator.__call__, maxsize + 1)
 
         return