Got rid of clutter. These patches have been applied.

git-svn-id: http://pexpect.svn.sourceforge.net/svnroot/pexpect/trunk@495 656d521f-e311-0410-88e0-e7920216d269

2 files changed, 0 insertions, 359 deletions

diff --git a/pexpect/pexpect-487-expect-order.patch b/pexpect/pexpect-487-expect-order.patch
deleted file mode 100644
index 5d14238..0000000
--- a/pexpect/pexpect-487-expect-order.patch
+++ /dev/null
@@ -1,138 +0,0 @@
-This patch restores restores the order in which patterns match
-so that it works as pexpect 2.1 did.  It was my expect_exact()
-patch which broke this back in June 2007.
-
-It also tries to document the behavior, and adds unit tests on
-it.  All tests should pass. test_expect.py passes when applied
-to pexpect 2.1.
-
-It's a patch against pexpect SVN 487, but requires
-pexpect-487-expect_exact-bugs.patch to have been applied first.
-
-/Jörgen
-
-
-diff -aur p/pexpect/pexpect.py pexpect/pexpect/pexpect.py
---- p/pexpect/pexpect.py	2007-11-18 16:31:57.000000000 +0100
-+++ pexpect/pexpect/pexpect.py	2007-11-18 15:30:31.000000000 +0100
-@@ -1187,6 +1187,22 @@
-         list. That will cause expect to match an EOF or TIMEOUT condition
-         instead of raising an exception.
- 
-+        If you pass a list of patterns and more than one matches, the first match
-+        in the stream is chosen. If more than one pattern matches at that point,
-+        the leftmost in the pattern list is chosen. For example::
-+
-+            # the input is 'foobar'
-+            index = p.expect (['bar', 'foo', 'foobar'])
-+            # returns 1 ('foo') even though 'foobar' is a "better" match
-+
-+        Please note, however, that buffering can affect this behavior, since
-+        input arrives in unpredictable chunks. For example::
-+
-+            # the input is 'foobar'
-+            index = p.expect (['foobar', 'foo'])
-+            # returns 0 ('foobar') if all input is available at once,
-+            # but returs 1 ('foo') if parts of the final 'bar' arrive late
-+
-         After a match is found the instance attributes 'before', 'after' and
-         'match' will be set. You can see all the data read before the match in
-         'before'. You can see the data that was matched in 'after'. The
-@@ -1588,8 +1604,7 @@
-                 # better obey searchwindowsize
-                 offset = -searchwindowsize
-             n = buffer.find(s, offset)
--            if n >= 0 and n <= first_match:
--                # note that the last, not the longest, match rules
-+            if n >= 0 and n < first_match:
-                 first_match = n
-                 best_index, best_match = index, s
-         if first_match == absurd_match:
-@@ -1669,8 +1684,7 @@
-             if match is None:
-                 continue
-             n = match.start()
--            if n <= first_match:
--                # note that the last, not the longest, match rules
-+            if n < first_match:
-                 first_match = n
-                 the_match = match
-                 best_index = index
-Only in p/pexpect: pexpect.py.rej
-diff -aur p/pexpect/tests/test_expect.py pexpect/pexpect/tests/test_expect.py
---- p/pexpect/tests/test_expect.py	2007-11-18 16:31:57.000000000 +0100
-+++ pexpect/pexpect/tests/test_expect.py	2007-11-18 16:06:39.000000000 +0100
-@@ -230,8 +230,6 @@
-         else:
-             self.fail ('Expected an EOF exception.')
- 
--class AdditionalExpectTestCase (PexpectTestCase.PexpectTestCase):
--
-     def _before_after(self, p):
-         p.timeout = 5
- 
-@@ -307,6 +305,64 @@
-         p.expect = p.expect_exact
-         self._ordering(p)
- 
-+    def _greed(self, p):
-+        p.timeout = 5
-+        p.expect('>>> ')
-+        p.sendline('import time')
-+        p.expect('>>> ')
-+        # the newline and sleep will (I hope) guarantee that
-+        # pexpect is fed two distinct batches of data,
-+        # "foo\r\n" + "bar\r\n".
-+        foo_then_bar = 'print "f"+"o"+"o" ; time.sleep(3); print "b"+"a"+"r"'
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['foo\r\nbar']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['\r\nbar']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['foo\r\nbar', 'foo', 'bar']), 1)
-+        p.expect('>>> ')
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['foo', 'foo\r\nbar', 'foo', 'bar']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['bar', 'foo\r\nbar']), 1)
-+        p.expect('>>> ')
-+
-+        # If the expect works as if we rematch for every new character,
-+        # 'o\r\nb' should win over 'oo\r\nba'. The latter is longer and
-+        # matches earlier in the input, but isn't satisfied until the 'a'
-+        # arrives.
-+        # However, pexpect doesn't do that (version 2.1 didn't).
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['oo\r\nba', 'o\r\nb']), 0)
-+        p.expect('>>> ')
-+
-+        # distinct patterns, but both suddenly match when the 'r' arrives.
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['foo\r\nbar', 'ar']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline(foo_then_bar)
-+        self.assertEqual(p.expect(['ar', 'foo\r\nbar']), 1)
-+        p.expect('>>> ')
-+
-+    def test_greed(self):
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        self._greed(p)
-+
-+    def test_greed_exact(self):
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        # mangle the spawn so we test expect_exact() instead
-+        p.expect = p.expect_exact
-+        self._greed(p)
-+
- if __name__ == '__main__':
-     unittest.main()
- 
diff --git a/pexpect/pexpect-487-expect_exact-bugs.patch b/pexpect/pexpect-487-expect_exact-bugs.patch
deleted file mode 100644
index 6232fcf..0000000
--- a/pexpect/pexpect-487-expect_exact-bugs.patch
+++ /dev/null
@@ -1,221 +0,0 @@
-Some fixes related to the expect_exact() patches I sent back in June.
-As you see, they are against pexpect, SVN 487.
-
-- Bug fix: expect_exact() was broken for a single TIMEOUT or EOF pattern,
-  and for lists of patterns, where TIMEOUT or EOF were in the list,
-  before a normal string pattern.
-
-- Added tests to expose these bugs (by splicing into those tests
-  which excercised expect() and didn't use REs).
-
-- Added some more tests for regressions since 2.1, in which pattern
-  is chosen as the match when many match -- something Noah brought up
-  earlier this year.  I plan to send another patch to "fix" this later
-  today.
-
-/Jörgen
-
-Index: pexpect.py
-===================================================================
---- pexpect.py	(revision 487)
-+++ pexpect.py	(working copy)
-@@ -35,7 +35,7 @@
- vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
- Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy, Fernando
- Perez, Corey Minyard, Jon Cohen, Guillaume Chazarain, Andrew Ryan, Nick
--Craig-Wood, Andrew Stone (Let me know if I forgot anyone.)
-+Craig-Wood, Andrew Stone, Jorgen Grahn (Let me know if I forgot anyone.)
- 
- Free, open source, and all that good stuff.
- 
-@@ -1267,7 +1267,7 @@
-         This method is also useful when you don't want to have to worry about
-         escaping regular expression characters that you want to match."""
- 
--        if type(pattern_list) in types.StringTypes + (TIMEOUT, EOF):
-+        if type(pattern_list) in types.StringTypes or pattern_list in (TIMEOUT, EOF):
-             pattern_list = [pattern_list]
-         return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
- 
-@@ -1585,16 +1585,16 @@
-                 # or at the very end of the old data
-                 offset = -(freshlen+len(s))
-             else:
--                # better obey_searchwindowsize
-+                # better obey searchwindowsize
-                 offset = -searchwindowsize
-             n = buffer.find(s, offset)
-             if n >= 0 and n <= first_match:
-                 # note that the last, not the longest, match rules
-                 first_match = n
--                best_index = index
-+                best_index, best_match = index, s
-         if first_match == absurd_match:
-             return -1
--        self.match = self._strings[best_index][1]
-+        self.match = best_match
-         self.start = first_match
-         self.end = self.start + len(self.match)
-         return best_index
-Index: tests/test_expect.py
-===================================================================
---- tests/test_expect.py	(revision 487)
-+++ tests/test_expect.py	(working copy)
-@@ -34,6 +34,17 @@
-         p.sendeof () 
-         p.expect (pexpect.EOF)
- 
-+    def test_expect_exact_basic (self):
-+        p = pexpect.spawn('cat')
-+        p.sendline ('Hello')
-+        p.sendline ('there')
-+        p.sendline ('Mr. Python')
-+        p.expect_exact ('Hello')
-+        p.expect_exact ('there')
-+        p.expect_exact ('Mr. Python')
-+        p.sendeof () 
-+        p.expect_exact (pexpect.EOF)
-+
-     def test_expect_ignore_case(self):
-         """This test that the ignorecase flag will match patterns
-         even if case is different using the regex (?i) directive.
-@@ -61,8 +72,21 @@
- 
-     def test_expect_order (self):
-         """This tests that patterns are matched in the same order as given in the pattern_list.
-+
-+        (Or does it?  Doesn't it also pass if expect() always chooses
-+        (one of the) the leftmost matches in the input? -- grahn)
-         """
-         p = pexpect.spawn('cat')
-+        self._expect_order(p)
-+
-+    def test_expect_order_exact (self):
-+        """Like test_expect_order(), but using expect_exact().
-+        """
-+        p = pexpect.spawn('cat')
-+        p.expect = p.expect_exact
-+        self._expect_order(p)
-+
-+    def _expect_order (self, p):
-         p.sendline ('1234') 
-         p.sendline ('abcd') 
-         p.sendline ('wxyz') 
-@@ -89,6 +113,16 @@
-         """This tests that echo can be turned on and off.
-         """
-         p = pexpect.spawn('cat', timeout=10)
-+        self._expect_echo(p)
-+
-+    def test_expect_echo_exact (self):
-+        """Like test_expect_echo(), but using expect_exact().
-+        """
-+        p = pexpect.spawn('cat', timeout=10)
-+        p.expect = p.expect_exact
-+        self._expect_echo(p)
-+
-+    def _expect_echo (self, p):
-         p.sendline ('1234') # Should see this twice (once from tty echo and again from cat).
-         index = p.expect (['1234','abcd','wxyz',pexpect.EOF,pexpect.TIMEOUT])
-         assert index == 0, "index="+str(index)+"\n"+p.before
-@@ -115,6 +149,16 @@
-         """
-         #pdb.set_trace()
-         p = pexpect.spawn('cat')
-+        self._expect_index(p)
-+
-+    def test_expect_index_exact (self):
-+        """Like test_expect_index(), but using expect_exact().
-+        """
-+        p = pexpect.spawn('cat')
-+        p.expect = p.expect_exact
-+        self._expect_index(p)
-+
-+    def _expect_index (self, p):
-         p.setecho(0)
-         p.sendline ('1234')
-         index = p.expect (['abcd','wxyz','1234',pexpect.EOF])
-@@ -186,6 +230,83 @@
-         else:
-             self.fail ('Expected an EOF exception.')
- 
-+class AdditionalExpectTestCase (PexpectTestCase.PexpectTestCase):
-+
-+    def _before_after(self, p):
-+        p.timeout = 5
-+
-+        p.expect('>>> ')
-+        self.assertEqual(p.after, '>>> ')
-+        self.assert_(p.before.startswith('Python '))
-+
-+        p.sendline('range(4*3)')
-+
-+        p.expect('5')
-+        self.assertEqual(p.after, '5')
-+        self.assert_(p.before.startswith('range(4*3)'))
-+
-+        p.expect('>>> ')
-+        self.assertEqual(p.after, '>>> ')
-+        self.assert_(p.before.startswith(', 6, 7, 8'))
-+
-+    def test_before_after(self):
-+        """This tests expect() for some simple before/after things.
-+        """
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        self._before_after(p)
-+
-+    def test_before_after_exact(self):
-+        """This tests some simple before/after things, for
-+        expect_exact(). (Grahn broke it at one point.)
-+        """
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        # mangle the spawn so we test expect_exact() instead
-+        p.expect = p.expect_exact
-+        self._before_after(p)
-+
-+    def _ordering(self, p):
-+        p.timeout = 5
-+        p.expect('>>> ')
-+
-+        p.sendline('range(4*3)')
-+        self.assertEqual(p.expect(['5,', '5,']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline('range(4*3)')
-+        self.assertEqual(p.expect(['7,', '5,']), 1)
-+        p.expect('>>> ')
-+
-+        p.sendline('range(4*3)')
-+        self.assertEqual(p.expect(['5,', '7,']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline('range(4*5)')
-+        self.assertEqual(p.expect(['2,', '12,']), 0)
-+        p.expect('>>> ')
-+
-+        p.sendline('range(4*5)')
-+        self.assertEqual(p.expect(['12,', '2,']), 1)
-+
-+    def test_ordering(self):
-+        """This tests expect() for which pattern is returned
-+        when many may eventually match. I (Grahn) am a bit
-+        confused about what should happen, but this test passes
-+        with pexpect 2.1.
-+        """
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        self._ordering(p)
-+
-+    def test_ordering_exact(self):
-+        """This tests expect_exact() for which pattern is returned
-+        when many may eventually match. I (Grahn) am a bit
-+        confused about what should happen, but this test passes
-+        for the expect() method with pexpect 2.1.
-+        """
-+        p = pexpect.spawn(self.PYTHONBIN)
-+        # mangle the spawn so we test expect_exact() instead
-+        p.expect = p.expect_exact
-+        self._ordering(p)
-+
- if __name__ == '__main__':
-     unittest.main()
-