--- a/python/mozbuild/mozbuild/configure/options.py
+++ b/python/mozbuild/mozbuild/configure/options.py
@@ -200,22 +200,22 @@ class Option(object):
                 nargs = '?'
             elif len(self.default) > 1:
                 nargs = '*'
             elif choices:
                 nargs = 1
         self.nargs = nargs
         has_choices = choices is not None
         if isinstance(self.default, PositiveOptionValue):
+            if has_choices and len(self.default) == 0:
+                raise InvalidOptionError(
+                    'A `default` must be given along with `choices`')
             if not self._validate_nargs(len(self.default)):
                 raise InvalidOptionError(
                     "The given `default` doesn't satisfy `nargs`")
-            if has_choices and len(self.default) == 0:
-                raise InvalidOptionError(
-                    'A `default` must be given along with `choices`')
             if has_choices and not all(d in choices for d in self.default):
                 raise InvalidOptionError(
                     'The `default` value must be one of %s' %
                     ', '.join("'%s'" % c for c in choices))
         elif has_choices:
             maxargs = self.maxargs
             if len(choices) < maxargs and maxargs != sys.maxint:
                 raise InvalidOptionError('Not enough `choices` for `nargs`')

--- a/python/mozbuild/mozbuild/test/configure/test_options.py
+++ b/python/mozbuild/mozbuild/test/configure/test_options.py
@@ -60,53 +60,80 @@ class TestOption(unittest.TestCase):
         self.assertEquals(option.env, 'MOZ_OPTION')
 
         option = Option(env='MOZ_OPTION')
         self.assertEquals(option.prefix, '')
         self.assertEquals(option.name, None)
         self.assertEquals(option.env, 'MOZ_OPTION')
         self.assertFalse(option.default)
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs=0, default=('a',))
-
-        with self.assertRaises(InvalidOptionError):
-            Option('--option', nargs=1, default=())
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
-            Option('--option', nargs=1, default=True)
+        with self.assertRaises(InvalidOptionError) as e:
+            Option('--option', nargs=1, default=())
+        self.assertEquals(
+            e.exception.message,
+            'default must be a bool, a string or a tuple of strings')
 
-        with self.assertRaises(InvalidOptionError):
-            Option('--option', nargs=1, default=('a', 'b'))
+        with self.assertRaises(InvalidOptionError) as e:
+            Option('--option', nargs=1, default=True)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
-            Option('--option', nargs=2, default=())
+        with self.assertRaises(InvalidOptionError) as e:
+            Option('--option', nargs=1, default=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
-            Option('--option', nargs=2, default=True)
+        with self.assertRaises(InvalidOptionError) as e:
+            Option('--option', nargs=2, default=())
+        self.assertEquals(
+            e.exception.message,
+            'default must be a bool, a string or a tuple of strings')
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
+            Option('--option', nargs=2, default=True)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
+
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs=2, default=('a',))
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs='?', default=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs='+', default=())
+        self.assertEquals(
+            e.exception.message,
+            'default must be a bool, a string or a tuple of strings')
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs='+', default=True)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
         # --disable options with a nargs value that requires at least one
         # argument need to be given a default.
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--disable-option', nargs=1)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--disable-option', nargs='+')
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
         # Test nargs inference from default value
         option = Option('--with-foo', default=True)
         self.assertEquals(option.nargs, 0)
 
         option = Option('--with-foo', default=False)
         self.assertEquals(option.nargs, 0)
 
@@ -153,46 +180,60 @@ class TestOption(unittest.TestCase):
             opt = Option(option, default=True)
             self.assertEquals(opt.option,
                               option.replace('-enable-', '-disable-')
                                     .replace('-with-', '-without-'))
 
         self.assertEquals(Option(env='FOO').option, 'FOO')
 
     def test_option_choices(self):
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs=3, choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          'Not enough `choices` for `nargs`')
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--without-option', nargs=1, choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          'A `default` must be given along with `choices`')
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--without-option', nargs='+', choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          'A `default` must be given along with `choices`')
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--without-option', default='c', choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          "The `default` value must be one of 'a', 'b'")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--without-option', default=('a', 'c',), choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          "The `default` value must be one of 'a', 'b'")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--without-option', default=('c',), choices=('a', 'b'))
+        self.assertEquals(e.exception.message,
+                          "The `default` value must be one of 'a', 'b'")
 
         option = Option('--with-option', nargs='+', choices=('a', 'b'))
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             option.get_value('--with-option=c')
+        self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
 
         value = option.get_value('--with-option=b,a')
         self.assertTrue(value)
         self.assertEquals(PositiveOptionValue(('b', 'a')), value)
 
         option = Option('--without-option', nargs='*', default='a',
                         choices=('a', 'b'))
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             option.get_value('--with-option=c')
+        self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
 
         value = option.get_value('--with-option=b,a')
         self.assertTrue(value)
         self.assertEquals(PositiveOptionValue(('b', 'a')), value)
 
         # Test nargs inference from choices
         option = Option('--with-option', choices=('a', 'b'))
         self.assertEqual(option.nargs, 1)
@@ -243,18 +284,27 @@ class TestOption(unittest.TestCase):
 
         option = Option('--%s' % name, nargs=nargs, default=default)
 
         if nargs in (0, '?', '*') or disabled:
             value = option.get_value('--%s' % name, 'option')
             self.assertEquals(value, posOptionValue())
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s' % name)
+            if nargs == 1:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes 1 value' % name)
+            elif nargs == '+':
+                self.assertEquals(e.exception.message,
+                                  '--%s takes 1 or more values' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes 2 values' % name)
 
         value = option.get_value('')
         self.assertEquals(value, defaultValue)
         self.assertEquals(value.origin, 'default')
 
         value = option.get_value(None)
         self.assertEquals(value, defaultValue)
         self.assertEquals(value.origin, 'default')
@@ -268,44 +318,76 @@ class TestOption(unittest.TestCase):
         with self.assertRaises(AssertionError):
             value = option.get_value('--foo')
 
         if nargs in (1, '?', '*', '+') and not disabled:
             value = option.get_value('--%s=' % name, 'option')
             self.assertEquals(value, PositiveOptionValue(('',)))
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s=' % name)
+            if disabled:
+                self.assertEquals(e.exception.message,
+                                  'Cannot pass a value to --%s' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes %d values' % (name, nargs))
 
         if nargs in (1, '?', '*', '+') and not disabled:
             value = option.get_value('--%s=foo' % name, 'option')
             self.assertEquals(value, PositiveOptionValue(('foo',)))
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s=foo' % name)
+            if disabled:
+                self.assertEquals(e.exception.message,
+                                  'Cannot pass a value to --%s' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes %d values' % (name, nargs))
 
         if nargs in (2, '*', '+') and not disabled:
             value = option.get_value('--%s=foo,bar' % name, 'option')
             self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s=foo,bar' % name, 'option')
+            if disabled:
+                self.assertEquals(e.exception.message,
+                                  'Cannot pass a value to --%s' % name)
+            elif nargs == '?':
+                self.assertEquals(e.exception.message,
+                                  '--%s takes 0 or 1 values' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes %d value%s'
+                                  % (name, nargs, 's' if nargs != 1 else ''))
 
         option = Option('--%s' % name, env='MOZ_OPTION', nargs=nargs,
                         default=default)
         if nargs in (0, '?', '*') or disabled:
             value = option.get_value('--%s' % name, 'option')
             self.assertEquals(value, posOptionValue())
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s' % name)
+            if disabled:
+                self.assertEquals(e.exception.message,
+                                  'Cannot pass a value to --%s' % name)
+            elif nargs == '+':
+                self.assertEquals(e.exception.message,
+                                  '--%s takes 1 or more values' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes %d value%s'
+                                  % (name, nargs, 's' if nargs != 1 else ''))
 
         value = option.get_value('')
         self.assertEquals(value, defaultValue)
         self.assertEquals(value.origin, 'default')
 
         value = option.get_value(None)
         self.assertEquals(value, defaultValue)
         self.assertEquals(value.origin, 'default')
@@ -318,45 +400,61 @@ class TestOption(unittest.TestCase):
             value = option.get_value('MOZ_OPTION=1', 'environment')
             self.assertEquals(value, PositiveOptionValue())
             self.assertEquals(value.origin, 'environment')
         elif nargs in (1, '+'):
             value = option.get_value('MOZ_OPTION=1', 'environment')
             self.assertEquals(value, PositiveOptionValue(('1',)))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('MOZ_OPTION=1', 'environment')
+            self.assertEquals(e.exception.message, 'MOZ_OPTION takes 2 values')
 
         if nargs in (1, '?', '*', '+') and not disabled:
             value = option.get_value('--%s=' % name, 'option')
             self.assertEquals(value, PositiveOptionValue(('',)))
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s=' % name, 'option')
+            if disabled:
+                self.assertEquals(e.exception.message,
+                                  'Cannot pass a value to --%s' % name)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s takes %d values' % (name, nargs))
 
         with self.assertRaises(AssertionError):
             value = option.get_value('--foo', 'option')
 
         if nargs in (1, '?', '*', '+'):
             value = option.get_value('MOZ_OPTION=foo', 'environment')
             self.assertEquals(value, PositiveOptionValue(('foo',)))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('MOZ_OPTION=foo', 'environment')
+            self.assertEquals(e.exception.message,
+                              'MOZ_OPTION takes %d values' % nargs)
 
         if nargs in (2, '*', '+'):
             value = option.get_value('MOZ_OPTION=foo,bar', 'environment')
             self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('MOZ_OPTION=foo,bar', 'environment')
+            if nargs == '?':
+                self.assertEquals(e.exception.message,
+                                  'MOZ_OPTION takes 0 or 1 values')
+            else:
+                self.assertEquals(e.exception.message,
+                                  'MOZ_OPTION takes %d value%s'
+                                  % (nargs, 's' if nargs != 1 else ''))
 
         if disabled:
             return option
 
         env_option = Option(env='MOZ_OPTION', nargs=nargs, default=default)
         with self.assertRaises(AssertionError):
             env_option.get_value('--%s' % name)
 
@@ -373,40 +471,50 @@ class TestOption(unittest.TestCase):
             self.assertEquals(value, posOptionValue())
             self.assertTrue(value)
             self.assertEquals(value.origin, 'environment')
         elif nargs in (1, '+'):
             value = env_option.get_value('MOZ_OPTION=1', 'environment')
             self.assertEquals(value, PositiveOptionValue(('1',)))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 env_option.get_value('MOZ_OPTION=1', 'environment')
+            self.assertEquals(e.exception.message, 'MOZ_OPTION takes 2 values')
 
-        with self.assertRaises(AssertionError):
+        with self.assertRaises(AssertionError) as e:
             env_option.get_value('--%s' % name)
 
-        with self.assertRaises(AssertionError):
+        with self.assertRaises(AssertionError) as e:
             env_option.get_value('--foo')
 
         if nargs in (1, '?', '*', '+'):
             value = env_option.get_value('MOZ_OPTION=foo', 'environment')
             self.assertEquals(value, PositiveOptionValue(('foo',)))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 env_option.get_value('MOZ_OPTION=foo', 'environment')
+            self.assertEquals(e.exception.message,
+                              'MOZ_OPTION takes %d values' % nargs)
 
         if nargs in (2, '*', '+'):
             value = env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
             self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
             self.assertEquals(value.origin, 'environment')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
+            if nargs == '?':
+                self.assertEquals(e.exception.message,
+                                  'MOZ_OPTION takes 0 or 1 values')
+            else:
+                self.assertEquals(e.exception.message,
+                                  'MOZ_OPTION takes %d value%s'
+                                  % (nargs, 's' if nargs != 1 else ''))
 
         return option
 
     def test_option_value_enable(self, enable='enable', disable='disable',
                                  nargs=0, default=None):
         option = self.test_option_value('%s-option' % enable, nargs=nargs,
                                         default=default)
 
@@ -417,46 +525,64 @@ class TestOption(unittest.TestCase):
         option = self.test_option_value('%s-option' % disable, nargs=nargs,
                                         default=default)
 
         if nargs in (0, '?', '*'):
             value = option.get_value('--%s-option' % enable, 'option')
             self.assertEquals(value, PositiveOptionValue())
             self.assertEquals(value.origin, 'option')
         else:
-            with self.assertRaises(InvalidOptionError):
+            with self.assertRaises(InvalidOptionError) as e:
                 option.get_value('--%s-option' % enable, 'option')
+            if nargs == 1:
+                self.assertEquals(e.exception.message,
+                                  '--%s-option takes 1 value' % enable)
+            elif nargs == '+':
+                self.assertEquals(e.exception.message,
+                                  '--%s-option takes 1 or more values'
+                                  % enable)
+            else:
+                self.assertEquals(e.exception.message,
+                                  '--%s-option takes 2 values' % enable)
 
     def test_option_value_with(self):
         self.test_option_value_enable('with', 'without')
 
     def test_option_value_invalid_nargs(self):
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs='foo')
+        self.assertEquals(e.exception.message,
+                          "nargs must be a positive integer, '?', '*' or '+'")
 
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--option', nargs=-2)
+        self.assertEquals(e.exception.message,
+                          "nargs must be a positive integer, '?', '*' or '+'")
 
     def test_option_value_nargs_1(self):
         self.test_option_value(nargs=1)
         self.test_option_value(nargs=1, default=('a',))
         self.test_option_value_enable(nargs=1, default=('a',))
 
         # A default is required
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--disable-option', nargs=1)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
     def test_option_value_nargs_2(self):
         self.test_option_value(nargs=2)
         self.test_option_value(nargs=2, default=('a', 'b'))
         self.test_option_value_enable(nargs=2, default=('a', 'b'))
 
         # A default is required
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--disable-option', nargs=2)
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
     def test_option_value_nargs_0_or_1(self):
         self.test_option_value(nargs='?')
         self.test_option_value(nargs='?', default=('a',))
         self.test_option_value_enable(nargs='?')
         self.test_option_value_enable(nargs='?', default=('a',))
 
     def test_option_value_nargs_0_or_more(self):
@@ -470,18 +596,20 @@ class TestOption(unittest.TestCase):
     def test_option_value_nargs_1_or_more(self):
         self.test_option_value(nargs='+')
         self.test_option_value(nargs='+', default=('a',))
         self.test_option_value(nargs='+', default=('a', 'b'))
         self.test_option_value_enable(nargs='+', default=('a',))
         self.test_option_value_enable(nargs='+', default=('a', 'b'))
 
         # A default is required
-        with self.assertRaises(InvalidOptionError):
+        with self.assertRaises(InvalidOptionError) as e:
             Option('--disable-option', nargs='+')
+        self.assertEquals(e.exception.message,
+                          "The given `default` doesn't satisfy `nargs`")
 
 
 class TestCommandLineHelper(unittest.TestCase):
     def test_basic(self):
         helper = CommandLineHelper({}, ['cmd', '--foo', '--bar'])
 
         self.assertEquals(['--foo', '--bar'], list(helper))