Exemplo n.º 1
0
    def test_multiword(self):
        def create():
            p = Parser()
            p.multiword('aa')
            p.str('ab')
            return p

        self.assertRaises(MissingValueError, create()._process_command_line, ['--aa'])
        vals = create()._process_command_line(['--aa', 'a', '--ab', 'b'])
        self.assertEqual(vals['aa'], 'a')
        self.assertEqual(vals['ab'], 'b')

        vals = create()._process_command_line(['--aa', 'a c d', '--ab', 'b'])
        self.assertEqual(vals['aa'], 'a c d')

        vals = create()._process_command_line(['--aa', 'a', 'c', 'd', '--ab', 'b'])
        self.assertEqual(vals['aa'], 'a c d')

        p = Parser().set_single_prefix('+').set_double_prefix('M')
        p.multiword('aa')
        p.str('ab').shorthand('a')
        vals = p._process_command_line(['Maa', 'a', 'c', 'd', 'Mab', 'b'])
        self.assertEqual(vals['aa'], 'a c d')

        p = Parser().set_single_prefix('+').set_double_prefix('M')
        p.multiword('aa')
        p.str('ab').shorthand('a')
        vals = p._process_command_line(['Maa', 'a', 'c', 'd', '+a', 'b'])
        self.assertEqual(vals['aa'], 'a c d')

        self.assertRaises(ValueError, Parser().set_single_prefix('++').set_double_prefix, '+')
Exemplo n.º 2
0
 def create():
     p = Parser({})
     p.config('a')
     p.int('b')
     p.str('c')
     p.int('d')
     return p
Exemplo n.º 3
0
    def test_with(self):
        import sys
        sys.argv[1:] = ['--x', 'yes']
        d = {'test_x': None}

        p = Parser(d)
        with p:
            p.str('x').shorthand('test-x')
Exemplo n.º 4
0
        def create():
            p = Parser()
            p.str('x').requires(
                p.str('y'),
                p.str('z'),
                p.str('w')
            )

            return p
Exemplo n.º 5
0
        def create():
            p = Parser()
            p.require_one(
                p.str('x'),
                p.str('y'),
                p.str('z')
            )

            return p
Exemplo n.º 6
0
        def create():
            p = Parser()
            p.at_least_one(
                p.str('x'),
                p.str('y'),
                p.str('z')
            )

            return p
Exemplo n.º 7
0
    def test_basic(self):
        p = Parser()
        p.str('x')
        p.flag('y')
        vals = p._process_command_line([])
        self.assertTrue(vals['x'] is None)
#        self.assertEqual(vals['x'], x)
#        self.assertEqual(vals['y'], y)
        self.assertFalse(vals['y'])
Exemplo n.º 8
0
    def test_requires(self):
        p = Parser()
        r = p.str('x')
        self.assertRaises(ValueError, r.requires, 'y')
        try:
            r.requires(p.str('y'))
        except ValueError:
            self.fail()

        p = Parser()
        y = p.int('y')
        p.int('x').requires(y)

        self.assertRaises(DependencyError, p._process_command_line, ['--x', '5'])
Exemplo n.º 9
0
    def test_multiple(self):
        p = Parser()
        p.str('x')

        self.assertRaises(MultipleSpecifiedArgumentError,
                p._process_command_line, ['--x', '1', '--x', '2'])

        def create():
            p = Parser()
            x = p.int('x').multiple()
            self.assertTrue(x != None)
            return p

        vals = create()._process_command_line(['--x', '1', '--x', '2'])
        self.assertEqual(sorted(vals['x']), [1, 2])
        vals = create()._process_command_line(['--x', '1'])
        self.assertEqual(vals['x'], [1])
        vals = create()._process_command_line([])
        self.assertEqual(vals['x'], [None])
        self.assertRaises(FormatError, create()._process_command_line, ['--x', '1', '--x', 'hello'])
Exemplo n.º 10
0
    def test_cast(self):
        p = Parser()
        p.str('x').cast(int)
        vals = p._process_command_line(['--x', '1'])
        self.assertEqual(vals['x'], 1)

        p = Parser()
        p.str('x').cast(int)
        self.assertRaises(ArgumentError, p._process_command_line, ['--x', 'a'])

        p = Parser()
        p.int('x')
        vals = p._process_command_line(['--x', '1'])

        p = Parser()
        p.multiword('x').cast(lambda x: [float(y) for y in x.split()])
        vals = p._process_command_line(['--x', '1.2 9.8 4.6'])
        self.assertEqual(vals['x'], [1.2, 9.8000000000000007,
            4.5999999999999996])

        p = Parser()
        p.int('x').default('yes')
        self.assertRaises(FormatError, p._process_command_line)
Exemplo n.º 11
0
    def test_add(self):
        p = Parser()
        p.str('x')
        vals = p._process_command_line(['--x', 'hi'])
        self.assertEqual(vals['x'], 'hi')

        p = Parser(locals())
        p.str('x')
        p._process_command_line(['--x', 'hi'])
        self.assertTrue('x' in locals())

        p = Parser()
        p.str('x')
        vals = p._process_command_line(['--x=5'])
        self.assertEqual(vals['x'], '5')
Exemplo n.º 12
0
    def test_required(self):
        p = Parser()
        p.str('x').required()
        self.assertRaises(MissingRequiredArgumentError, p._process_command_line, [])

        p = Parser()
        p.str('x').required()
        self.assertRaises(MissingRequiredArgumentError,
                p._process_command_line, [])

        p = Parser()
        y = p.str('y')
        z = p.str('z')
        x = p.str('x').unless(y.or_(z))
        self.assertTrue(x != None)
        self.assertRaises(ArgumentError,
                p._process_command_line, [])
        p._process_command_line(['--y', 'a'])
        p._process_command_line(['--x', 'a'])
        p._process_command_line(['--x', 'a', '--y', 'b'])
        p._process_command_line(['--z', 'a'])
Exemplo n.º 13
0
 def create():
     p = Parser({})
     p.config('a').default(fname)
     p.int('b').requires(p.int('d'))
     p.str('c')
     return p
Exemplo n.º 14
0
 def test_bad_format(self):
     p = Parser()
     p.str('f')
     p.str('m')
Exemplo n.º 15
0
    def test_unspecified_default(self):
        p = Parser({})
        p.str('x').unspecified_default()
        self.assertRaises(ValueError, Option.unspecified_default, p.str('y'))

        vals = {}
        p = Parser(vals)
        p.str('x').unspecified_default().required()
        p._process_command_line(['ok'])
        self.assertEqual(vals['x'], 'ok')

        p = Parser({})
        p.str('x').unspecified_default().conflicts(p.str('y'))
        self.assertRaises(ConflictError, p._process_command_line,
            ['--y', 'a', 'unspecified_default'])

        p = Parser({})
        p.str('x').unspecified_default().conflicts(p.str('y'))
        self.assertRaises(ConflictError, p._process_command_line,
            ['unspecified_default', '--y', 'a'])

        # multiple
        p = Parser()
        p.str('x').unspecified_default()
        self.assertRaises(ValueError, p.str('y').unspecified_default)
Exemplo n.º 16
0
 def create():
     p = Parser()
     p.multiword('aa')
     p.str('ab')
     return p
Exemplo n.º 17
0
 def create():
     p = Parser()
     p.str('a').requires(p['a'] != 'c')
     return p