First commit1.0

Signed-off-by: Mattias Andrée <maandree@kth.se>

6 files changed, 931 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8a0b878
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+*~
+*\#*
+__pycache__/
+*.pyc
+*.pyo
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2553a69
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+© 2017 Mattias Andrée <maandree@kth.se>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..50ede37
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,26 @@
+.POSIX:
+
+PREFIX = /usr/local
+
+PYTHON_MAJOR = $$(python --version 2>&1 | cut -d . -f 1 | cut -d ' ' -f 2)
+PYTHON_MINOR = $$(python$(PYTHON_MAJOR) --version 2>&1 | cut -d . -f 2)
+
+all:
+	@true
+
+check:
+	python$(PYTHON_MAJOR) ./test.py
+
+install:
+	mkdir -p -- "$(DESTDIR)$(PREFIX)/lib/python$(PYTHON_MAJOR).$(PYTHON_MINOR)/site-packages"
+	cp -- arg.py "$(DESTDIR)$(PREFIX)/lib/python$(PYTHON_MAJOR).$(PYTHON_MINOR)/site-packages/"
+
+uninstall:
+	-rm -f -- "$(DESTDIR)$(PREFIX)/lib/python$(PYTHON_MAJOR).$(PYTHON_MINOR)/site-packages/arg.py"
+
+clean:
+	-rm -rf -- *.pyc *.pyo __pycache__
+
+.SUFFIXES:
+
+.PHONY: all check install uninstall clean
diff --git a/README b/README
new file mode 100644
index 0000000..dd091db
--- /dev/null
+++ b/README
@@ -0,0 +1,42 @@
+A simple argument parser for Python
+
+Example usage:
+	import sys
+	import arg
+
+	def usage():
+		print('usage: %s [-v value] [-xy]' % sys.argv[0], file = sys.stderr)
+		sys.exit(1)
+
+	xflag = False
+	yflag = False
+	vflag = None
+
+	parser = arg.Parser(usage = usage)
+	for c in parser.flags:
+		if c == 'x':
+			xflag = True
+		elif c == 'y':
+			yflag = True
+		elif c == 'v':
+			vflag = parser.arg
+		else:
+			usage()
+
+Supports:
+	Short flags without arguments
+	Short flags with optionally attached arguments
+	Joined short flags
+	Long flags with optional arguments
+	Long flags with mandatory arguments
+	Long flags with mandatory attached arguments
+	Long flags with mandatory detached arguments
+	Long flags with without arguments
+	Long flags with only one dash
+	Flags not starting with a dash
+	Numeral flags
+	Stop parsing flags at --
+	Mixing flags and arguments
+	Stop parsing flags at first argument
+	Returning -- as an argument
+	Not returning -- as an argument
diff --git a/arg.py b/arg.py
new file mode 100644
index 0000000..bb83df1
--- /dev/null
+++ b/arg.py
@@ -0,0 +1,307 @@
+# See LICENSE file for copyright and license details.
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function
+import sys as _sys
+import os as _os
+import errno as _errno
+
+MAY_HAVE_ATTACHED_ARGUMENT = 0
+NEED_ARGUMENT = 1
+NEED_ATTACHED_ARGUMENT = 2
+NEED_DETACHED_ARGUMENT = 3
+NEED_NO_ARGUMENT = 4
+
+class UsageError(Exception):
+    pass
+
+class Parser(object):
+    '''
+    Command line parser
+
+    Example usage:
+        import sys
+        import arg
+        
+        def usage():
+            print('usage: %s [-v value] [-xy]' % sys.argv[0], file = sys.stderr)
+            sys.exit(1)
+        
+        xflag = False
+        yflag = False
+        vflag = None
+        
+        parser = arg.Parser(usage = usage)
+        for c in parser.flags:
+            if c == 'x':
+                xflag = True
+            elif c == 'y':
+                yflag = True
+            elif c == 'v':
+                vflag = parser.arg
+            else:
+                usage()
+    '''
+
+    def __init__(self, argv = None, symbols = '-', keep_dashdash = False, store_nonflags = False, usage = None):
+        '''
+        @param  argv           A list with the arguments to parse, if `None`, `sys.argv[1:]` is used
+        @param  symbols        A string or list contain the characters that will cause an argument
+                               to be parsed as being a flag, multicharacter strings will be ignored
+        @param  keep_dashdash  If `True`, `--` will be returned in `self.argv`
+        @param  keep_nonflags  During parsing, non-flag arguments are ignored, and after the last
+                               flag has been parsed, `self.argv` will have the ignored arguments at
+                               the beginning
+        @param  usage          Function (without arguments) that is to be called if parsing fails
+                               due to usage error, if `None`, `UsageError` will be raised instead
+                               on usage error
+        '''
+        if argv is None:
+            argv = _sys.argv[1:]
+        self._argv = list(argv)
+        self._usage_func = usage
+        self._symbols = symbols
+        self._keep_ddash = keep_dashdash
+        self._stored = [] if store_nonflags else None
+
+    def _usage(self):
+        if self._usage_func is None:
+            raise UsageError()
+        else:
+            self._usage_func()
+
+    @property
+    def flags(self):
+        '''
+        Return a generator that returns the flags in the command line
+        
+        Properties and functions in `self` can be used to after each
+        time a flag is returned
+        
+        Each returned value is a single character
+        '''
+        self._brk = False
+        self._accept_none_arg = False
+        while len(self._argv):
+            if len(self._argv[0]) < 2:
+                if self._stored is not None:
+                    self._stored.append(self._argv[0])
+                    self._argv = self._argv[1:]
+                    continue
+                break
+            self._symbol = self._argv[0][0]
+            self._lflag = self._argv[0]
+            if self._symbol not in self._symbols:
+                if self._stored is not None:
+                    self._stored.append(self._argv[0])
+                    self._argv = self._argv[1:]
+                    continue
+                break
+            if self._argv[0] == 2 * self._symbol:
+                if self._symbol == '-':
+                    if not self._keep_ddash:
+                        self._argv = self._argv[1:]
+                elif self._stored is not None:
+                    self._stored.append(self._argv[0])
+                    self._argv = self._argv[1:]
+                    continue
+                break
+            self._i = 1
+            n = len(self._argv[0])
+            while self._i < n:
+                self._flag = self._argv[0][self._i]
+                if self._flag == self._symbol and self._i != 1:
+                    self._usage()
+                if self._i + 1 < n:
+                    self._arg = self._argv[0][self._i + 1:]
+                elif len(self._argv) > 1:
+                    self._arg = self._argv[1]
+                else:
+                    self._arg = None
+                yield self._flag
+                self._lflag = None
+                self._accept_none_arg = False
+                if self._brk:
+                    if len(self._argv) > 1 and self._arg is self._argv[1]:
+                        self._argv = self._argv[1:]
+                    self._brk = False
+                    break
+                self._i += 1
+            self._argv = self._argv[1:]
+        if self._stored:
+            self._argv = self._stored + self._argv
+        self._stored = None
+
+    @property
+    def flag(self):
+        '''
+        Return the current short flag, for example '-a',
+        this string is always two characters long
+        '''
+        return self._symbol + self._flag
+
+    @property
+    def symbol(self):
+        '''
+        Get the first character in the flag, normally '-'
+        '''
+        return self._symbol
+
+    @property
+    def lflag(self):
+        '''
+        Get the entire current argument, for example
+        '--mode=755', `None` not at the beginning
+        '''
+        return self._lflag
+
+    @property
+    def argv(self):
+        '''
+        Return a list of all remaining arguments
+        '''
+        return self._argv
+
+    @property
+    def argc(self):
+        '''
+        Return the number of remaining arguments
+        '''
+        return len(self._argv)
+
+    @property
+    def arg(self):
+        '''
+        Get the argument specified for the flag, can only be
+        `None` (no argument) if `self.testlong` has returned
+        `True` with `MAY_HAVE_ATTACHED_ARGUMENT` as the second
+        argument for the currnet flag
+        
+        Reading this property will cause the parser to assume
+        that the flag should have an argument, if these is
+        no argument UsageError will be raised (or the specified
+        usage function will be called) unless `self.testlong`
+        has returned `True` with `MAY_HAVE_ATTACHED_ARGUMENT`
+        as the second argument for the currnet flag
+        '''
+        if self._arg is None and not self._accept_none_arg:
+            self._usage()
+        self._brk = True
+        return self._arg
+
+    @property
+    def arghere(self):
+        '''
+        Return the current argument with an offset such that the
+        first character is the character associated with the
+        current flag, for example, if the current argument is
+        '-123' and the current flag is '1', '123' is returned
+        
+        Reading this property will cause the parser to continue
+        with the next argument when getting the next flag
+        '''
+        self._brk = True
+        self._arg = None
+        return self._argv[0][self._i:]
+
+    @property
+    def isargnum(self):
+        '''
+        Check whether the value returned by `arghere` will be a number
+        
+        Calling this function does not affect the parser
+        '''
+        return self._argv[0][self._i:].isdigit()
+
+    @property
+    def argnum(self):
+        '''
+        Identical to `arghere`, except the returned value will
+        be converted to an integer
+        
+        If the value returned by `self.arghere` is not a
+        number, UsageError will be raised (or the specified
+        usage function will be called)
+        '''
+        if not self.isargnum:
+            self._usage()
+        return int(self.arghere)
+
+    def consume(self):
+        '''
+        Cause the parser to skip the rest of current argument
+        and continue with the next argument
+        
+        If `self.arg` has been read and returned the next argument,
+        the parser will still read that argument
+        '''
+        self._arg = None
+        self._brk = True
+
+    def testlong(self, flag, argument = 0):
+        '''
+        Check whether the current flag is specific long flag
+        
+        It is important to use this function, because it will
+        set the parser's state appropriately whe it finds a match
+        
+        If the flag is the specified long flag, but its argument
+        status does not match `argument`, UsageError will be raised
+        (or the specified usage function will be called)
+        
+        @param  flag      The long flag, should start with its symbol prefix (usually '--')
+        @param  argument  arg.MAY_HAVE_ATTACHED_ARGUMENT (default):
+                                  The flag may have an argument attached to the flag
+                                  separated by a '=', for example '--value=2', but
+                                  it is not necessary, so just '--value' is also accepted,
+                                  but the next argument may not be parsed as a value
+                                  associated with the flag
+                          arg.NEED_ARGUMENT:
+                                  The flag must have an attached argument or a detached
+                                  argument, for example '--value=2' is accepted, but
+                                  '--value' is only accepted if it is not the last argument,
+                                  if the current argument does not contain a '='
+                          arg.NEED_ATTACHED_ARGUMENT:
+                                  The flag must have an attached argument, for example
+                                  '--value=2' is accepted but '--value' is not
+                          arg.NEED_DETACHED_ARGUMENT:
+                                  The flag must have a detached argument, for example
+                                  '--value' is accepted, but only if it is not the last
+                                  argument, but '--value=2' is not accepted
+                          arg.NEED_NO_ARGUMENT:
+                                  The flag must not have an argument, for example
+                                  '--value' is accepted but '--value=2' is not
+        '''
+        if self._lflag is None:
+            return False
+        attached = self._lflag.startswith(flag + '=')
+        if attached:
+            arg = self._lflag[self._lflag.index('=') + 1:]
+            lflag = self._lflag[:self._lflag.index('=')]
+        else:
+            arg = self._argv[1] if len(self._argv) > 1 else None
+            lflag = self._lflag
+        if lflag != flag:
+            return False
+        elif argument == MAY_HAVE_ATTACHED_ARGUMENT:
+            if not attached:
+                arg = None
+                self._accept_none_arg = True
+        elif argument == NEED_ARGUMENT:
+            if arg is None:
+                self._usage()
+        elif argument == NEED_ATTACHED_ARGUMENT:
+            if not attached:
+                self._usage()
+        elif argument == NEED_DETACHED_ARGUMENT:
+            if attached or arg is None:
+                self._usage()
+        elif argument == NEED_NO_ARGUMENT:
+            arg = None
+            if attached:
+                self._usage()
+        else:
+            raise OSError(_os.strerror(_errno.EINVAL), _errno.EINVAL)
+        self._arg = arg
+        self._brk = True
+        return True
diff --git a/test.py b/test.py
new file mode 100755
index 0000000..a58eaaa
--- /dev/null
+++ b/test.py
@@ -0,0 +1,536 @@
+#!/usr/bin/env python
+# See LICENSE file for copyright and license details.
+# -*- coding: utf-8 -*-
+
+import sys
+import arg
+
+
+parser = arg.Parser()
+assert parser.argv == sys.argv[1:]
+
+
+parser = arg.Parser(argv = ['-a', '-aa', '-aaa'])
+n = 0
+for c in parser.flags:
+    assert c == 'a'
+    n += 1
+assert n == 6
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['-abc', '-xyz'])
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert parser.symbol == '-'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+assert next(flags) == 'c'
+assert parser.flag == '-c'
+assert next(flags) == 'x'
+assert parser.flag == '-x'
+assert parser.lflag == '-xyz'
+assert next(flags) == 'y'
+assert parser.flag == '-y'
+assert parser.lflag is None
+assert next(flags) == 'z'
+assert parser.flag == '-z'
+assert parser.symbol == '-'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+for mid in ('', '-', 'x'):
+    parser = arg.Parser(argv = ['-abc', mid, '-xyz'])
+    flags = parser.flags
+    assert next(flags) == 'a'
+    assert parser.flag == '-a'
+    assert parser.symbol == '-'
+    assert next(flags) == 'b'
+    assert parser.flag == '-b'
+    assert next(flags) == 'c'
+    assert parser.flag == '-c'
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 2
+    assert type(parser.argc) is int
+    assert parser.argc == 2
+    assert parser.argv == [mid, '-xyz']
+
+
+parser = arg.Parser(argv = ['-abc', '--', '-xyz'])
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert parser.symbol == '-'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+assert next(flags) == 'c'
+assert parser.flag == '-c'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 1
+assert type(parser.argc) is int
+assert parser.argc == 1
+assert parser.argv == ['-xyz']
+
+
+parser = arg.Parser(argv = ['-abc', '--', '-xyz'], keep_dashdash = True)
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert parser.symbol == '-'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+assert next(flags) == 'c'
+assert parser.flag == '-c'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 2
+assert type(parser.argc) is int
+assert parser.argc == 2
+assert parser.argv == ['--', '-xyz']
+
+
+parser = arg.Parser(argv = ['a', '--', 'b'], keep_dashdash = True, store_nonflags = True)
+flags = parser.flags
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 3
+assert type(parser.argc) is int
+assert parser.argc == 3
+assert parser.argv == ['a', '--', 'b']
+
+
+parser = arg.Parser(argv = ['a', '--', 'b'], keep_dashdash = False, store_nonflags = True)
+flags = parser.flags
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 2
+assert type(parser.argc) is int
+assert parser.argc == 2
+assert parser.argv == ['a', 'b']
+
+
+parser = arg.Parser(argv = ['-a-b'])
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+try:
+    next(flags)
+    assert False
+except arg.UsageError:
+    pass
+
+
+parser = arg.Parser(argv = ['-123', '-xyz'])
+flags = parser.flags
+assert next(flags) == '1'
+assert parser.flag == '-1'
+assert next(flags) == '2'
+assert parser.flag == '-2'
+assert next(flags) == '3'
+assert parser.flag == '-3'
+assert next(flags) == 'x'
+assert parser.flag == '-x'
+assert next(flags) == 'y'
+assert parser.flag == '-y'
+assert next(flags) == 'z'
+assert parser.flag == '-z'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['-123', '-xyz'])
+flags = parser.flags
+assert next(flags) == '1'
+assert parser.flag == '-1'
+assert parser.arghere == '123'
+assert parser.isargnum
+assert parser.argnum == 123
+assert next(flags) == 'x'
+assert parser.flag == '-x'
+assert next(flags) == 'y'
+assert parser.flag == '-y'
+assert next(flags) == 'z'
+assert parser.flag == '-z'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['-1', '-xyz'])
+flags = parser.flags
+assert next(flags) == '1'
+assert parser.flag == '-1'
+assert parser.arghere == '1'
+assert parser.isargnum
+assert parser.argnum == 1
+assert next(flags) == 'x'
+assert parser.flag == '-x'
+assert next(flags) == 'y'
+assert parser.flag == '-y'
+assert next(flags) == 'z'
+assert parser.flag == '-z'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['-ab', '--', '-xyz'], store_nonflags = True)
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 1
+assert type(parser.argc) is int
+assert parser.argc == 1
+assert parser.argv == ['-xyz']
+
+
+parser = arg.Parser(argv = ['-ab', '--', '-xyz'], keep_dashdash = True, store_nonflags = True)
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 2
+assert type(parser.argc) is int
+assert parser.argc == 2
+assert parser.argv == ['--', '-xyz']
+
+
+for mid in ('o', 'oo'):
+    parser = arg.Parser(argv = ['-ab', mid, '-xyz'], store_nonflags = True)
+    flags = parser.flags
+    assert next(flags) == 'a'
+    assert parser.flag == '-a'
+    assert next(flags) == 'b'
+    assert parser.flag == '-b'
+    assert next(flags) == 'x'
+    assert parser.flag == '-x'
+    assert next(flags) == 'y'
+    assert parser.flag == '-y'
+    assert next(flags) == 'z'
+    assert parser.flag == '-z'
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 1
+    assert type(parser.argc) is int
+    assert parser.argc == 1
+    assert parser.argv == [mid]
+
+
+parser = arg.Parser(argv = ['-abc'], symbols = '+')
+flags = parser.flags
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 1
+assert type(parser.argc) is int
+assert parser.argc == 1
+assert parser.argv == ['-abc']
+
+
+parser = arg.Parser(argv = ['+xyz', '-abc'], symbols = '+')
+flags = parser.flags
+assert next(flags) == 'x'
+assert parser.flag == '+x'
+assert parser.symbol == '+'
+assert next(flags) == 'y'
+assert parser.flag == '+y'
+assert next(flags) == 'z'
+assert parser.flag == '+z'
+assert parser.symbol == '+'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 1
+assert type(parser.argc) is int
+assert parser.argc == 1
+assert parser.argv == ['-abc']
+
+
+parser = arg.Parser(argv = ['+xyz', '-abc'], symbols = '-+')
+flags = parser.flags
+assert next(flags) == 'x'
+assert parser.flag == '+x'
+assert parser.symbol == '+'
+assert next(flags) == 'y'
+assert parser.flag == '+y'
+assert next(flags) == 'z'
+assert parser.flag == '+z'
+assert parser.symbol == '+'
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+assert parser.symbol == '-'
+assert next(flags) == 'b'
+assert parser.flag == '-b'
+assert next(flags) == 'c'
+assert parser.flag == '-c'
+assert parser.symbol == '-'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['+xyz', '++', '-abc'], symbols = '-+')
+flags = parser.flags
+assert next(flags) == 'x'
+assert parser.flag == '+x'
+assert parser.symbol == '+'
+assert next(flags) == 'y'
+assert parser.flag == '+y'
+assert next(flags) == 'z'
+assert parser.flag == '+z'
+assert parser.symbol == '+'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 2
+assert type(parser.argc) is int
+assert parser.argc == 2
+assert parser.argv == ['++', '-abc']
+
+
+parser = arg.Parser(argv = ['-123', '-xyz'])
+flags = parser.flags
+assert next(flags) == '1'
+assert parser.arg == '23'
+assert next(flags) == 'x'
+assert parser.flag == '-x'
+assert parser.arg == 'yz'
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+for a in ('', '-x'):
+    parser = arg.Parser(argv = ['-1', a])
+    flags = parser.flags
+    assert next(flags) == '1'
+    assert parser.arg == a
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 0
+    assert type(parser.argc) is int
+    assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['-123', '-xyz'])
+flags = parser.flags
+assert next(flags) == '1'
+parser.consume()
+assert next(flags) == 'x'
+parser.consume()
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 0
+assert type(parser.argc) is int
+assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['--123', 'x'])
+flags = parser.flags
+assert next(flags) == '-'
+assert not parser.testlong('--abc')
+assert parser.testlong('--123', arg.NEED_NO_ARGUMENT)
+try:
+    next(flags)
+    assert False
+except StopIteration:
+    pass
+assert type(parser.argv) is list
+assert len(parser.argv) == 1
+assert type(parser.argc) is int
+assert parser.argc == 1
+assert parser.argv == ['x']
+
+
+for check_arg in (True, False):
+    for arg_need in (arg.NEED_ARGUMENT, arg.NEED_DETACHED_ARGUMENT):
+        parser = arg.Parser(argv = ['--123', 'x'])
+        flags = parser.flags
+        assert next(flags) == '-'
+        assert not parser.testlong('--abc')
+        assert parser.testlong('--123', arg_need)
+        if check_arg:
+            assert parser.arg == 'x'
+        try:
+            next(flags)
+            assert False
+        except StopIteration:
+            pass
+        assert type(parser.argv) is list
+        assert len(parser.argv) == 0
+        assert type(parser.argc) is int
+        assert parser.argc == 0
+
+
+for check_arg in (True, False):
+    parser = arg.Parser(argv = ['--123=x'])
+    flags = parser.flags
+    assert next(flags) == '-'
+    assert not parser.testlong('--abc')
+    assert parser.testlong('--123', arg.NEED_ATTACHED_ARGUMENT)
+    if check_arg:
+        assert parser.arg == 'x'
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 0
+    assert type(parser.argc) is int
+    assert parser.argc == 0
+
+
+parser = arg.Parser(argv = ['--123', 'x'])
+flags = parser.flags
+assert next(flags) == '-'
+assert not parser.testlong('--abc')
+try:
+    parser.testlong('--123', arg.NEED_ATTACHED_ARGUMENT)
+    assert False
+except arg.UsageError:
+    pass
+
+
+for a in ('x', ''):
+    parser = arg.Parser(argv = ['--123=' + a])
+    flags = parser.flags
+    assert next(flags) == '-'
+    assert not parser.testlong('--abc')
+    assert parser.testlong('--123', arg.MAY_HAVE_ATTACHED_ARGUMENT)
+    assert parser.arg == a
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 0
+    assert type(parser.argc) is int
+    assert parser.argc == 0
+
+    parser = arg.Parser(argv = ['--123', a])
+    flags = parser.flags
+    assert next(flags) == '-'
+    assert not parser.testlong('--abc')
+    assert parser.testlong('--123', arg.MAY_HAVE_ATTACHED_ARGUMENT)
+    assert parser.arg == None
+    try:
+        next(flags)
+        assert False
+    except StopIteration:
+        pass
+    assert type(parser.argv) is list
+    assert len(parser.argv) == 1
+    assert type(parser.argc) is int
+    assert parser.argc == 1
+    assert parser.argv == [a]
+
+
+parser = arg.Parser(argv = ['-a-'], usage = lambda : sys.exit(0))
+flags = parser.flags
+assert next(flags) == 'a'
+assert parser.flag == '-a'
+next(flags)
+assert False