diff options
| author | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
|---|---|---|
| committer | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
| commit | b9c1b51e45b845debb76d8658edabca70ca56079 (patch) | |
| tree | dfcb5a13ef2b014202340f47036da383eaee74aa /lldb/third_party | |
| parent | d5aa73376966339caad04013510626ec2e42c760 (diff) | |
| download | llvm-b9c1b51e45b845debb76d8658edabca70ca56079.tar.gz | |
*** This commit represents a complete reformatting of the LLDB source code
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
Diffstat (limited to 'lldb/third_party')
56 files changed, 3594 insertions, 2292 deletions
diff --git a/lldb/third_party/Python/module/pexpect-2.4/ANSI.py b/lldb/third_party/Python/module/pexpect-2.4/ANSI.py index 537017e90b29..003bab270e6f 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/ANSI.py +++ b/lldb/third_party/Python/module/pexpect-2.4/ANSI.py @@ -13,90 +13,106 @@ import FSM import copy import string -def Emit (fsm): + +def Emit(fsm): screen = fsm.memory[0] screen.write_ch(fsm.input_symbol) -def StartNumber (fsm): - fsm.memory.append (fsm.input_symbol) +def StartNumber(fsm): + + fsm.memory.append(fsm.input_symbol) -def BuildNumber (fsm): + +def BuildNumber(fsm): ns = fsm.memory.pop() ns = ns + fsm.input_symbol - fsm.memory.append (ns) + fsm.memory.append(ns) + -def DoBackOne (fsm): +def DoBackOne(fsm): screen = fsm.memory[0] - screen.cursor_back () + screen.cursor_back() -def DoBack (fsm): + +def DoBack(fsm): count = int(fsm.memory.pop()) screen = fsm.memory[0] - screen.cursor_back (count) + screen.cursor_back(count) + -def DoDownOne (fsm): +def DoDownOne(fsm): screen = fsm.memory[0] - screen.cursor_down () + screen.cursor_down() -def DoDown (fsm): + +def DoDown(fsm): count = int(fsm.memory.pop()) screen = fsm.memory[0] - screen.cursor_down (count) + screen.cursor_down(count) + -def DoForwardOne (fsm): +def DoForwardOne(fsm): screen = fsm.memory[0] - screen.cursor_forward () + screen.cursor_forward() -def DoForward (fsm): + +def DoForward(fsm): count = int(fsm.memory.pop()) screen = fsm.memory[0] - screen.cursor_forward (count) + screen.cursor_forward(count) + -def DoUpReverse (fsm): +def DoUpReverse(fsm): screen = fsm.memory[0] screen.cursor_up_reverse() -def DoUpOne (fsm): + +def DoUpOne(fsm): screen = fsm.memory[0] - screen.cursor_up () + screen.cursor_up() + -def DoUp (fsm): +def DoUp(fsm): count = int(fsm.memory.pop()) screen = fsm.memory[0] - screen.cursor_up (count) + screen.cursor_up(count) -def DoHome (fsm): + +def DoHome(fsm): c = int(fsm.memory.pop()) r = int(fsm.memory.pop()) screen = fsm.memory[0] - screen.cursor_home (r,c) + screen.cursor_home(r, c) + -def DoHomeOrigin (fsm): +def DoHomeOrigin(fsm): c = 1 r = 1 screen = fsm.memory[0] - screen.cursor_home (r,c) + screen.cursor_home(r, c) + -def DoEraseDown (fsm): +def DoEraseDown(fsm): screen = fsm.memory[0] screen.erase_down() -def DoErase (fsm): + +def DoErase(fsm): arg = int(fsm.memory.pop()) screen = fsm.memory[0] @@ -107,12 +123,14 @@ def DoErase (fsm): elif arg == 2: screen.erase_screen() -def DoEraseEndOfLine (fsm): + +def DoEraseEndOfLine(fsm): screen = fsm.memory[0] screen.erase_end_of_line() -def DoEraseLine (fsm): + +def DoEraseLine(fsm): screen = fsm.memory[0] if arg == 0: @@ -122,146 +140,164 @@ def DoEraseLine (fsm): elif arg == 2: screen.erase_line() -def DoEnableScroll (fsm): + +def DoEnableScroll(fsm): screen = fsm.memory[0] screen.scroll_screen() -def DoCursorSave (fsm): + +def DoCursorSave(fsm): screen = fsm.memory[0] screen.cursor_save_attrs() -def DoCursorRestore (fsm): + +def DoCursorRestore(fsm): screen = fsm.memory[0] screen.cursor_restore_attrs() -def DoScrollRegion (fsm): + +def DoScrollRegion(fsm): screen = fsm.memory[0] r2 = int(fsm.memory.pop()) r1 = int(fsm.memory.pop()) - screen.scroll_screen_rows (r1,r2) + screen.scroll_screen_rows(r1, r2) -def DoMode (fsm): + +def DoMode(fsm): screen = fsm.memory[0] - mode = fsm.memory.pop() # Should be 4 + mode = fsm.memory.pop() # Should be 4 # screen.setReplaceMode () -def Log (fsm): + +def Log(fsm): screen = fsm.memory[0] fsm.memory = [screen] - fout = open ('log', 'a') - fout.write (fsm.input_symbol + ',' + fsm.current_state + '\n') + fout = open('log', 'a') + fout.write(fsm.input_symbol + ',' + fsm.current_state + '\n') fout.close() + class term (screen.screen): - """This is a placeholder. + """This is a placeholder. In theory I might want to add other terminal types. """ - def __init__ (self, r=24, c=80): - screen.screen.__init__(self, r,c) + + def __init__(self, r=24, c=80): + screen.screen.__init__(self, r, c) + class ANSI (term): """This class encapsulates a generic terminal. It filters a stream and maintains the state of a screen object. """ - def __init__ (self, r=24,c=80): + def __init__(self, r=24, c=80): - term.__init__(self,r,c) + term.__init__(self, r, c) #self.screen = screen (24,80) - self.state = FSM.FSM ('INIT',[self]) - self.state.set_default_transition (Log, 'INIT') - self.state.add_transition_any ('INIT', Emit, 'INIT') - self.state.add_transition ('\x1b', 'INIT', None, 'ESC') - self.state.add_transition_any ('ESC', Log, 'INIT') - self.state.add_transition ('(', 'ESC', None, 'G0SCS') - self.state.add_transition (')', 'ESC', None, 'G1SCS') - self.state.add_transition_list ('AB012', 'G0SCS', None, 'INIT') - self.state.add_transition_list ('AB012', 'G1SCS', None, 'INIT') - self.state.add_transition ('7', 'ESC', DoCursorSave, 'INIT') - self.state.add_transition ('8', 'ESC', DoCursorRestore, 'INIT') - self.state.add_transition ('M', 'ESC', DoUpReverse, 'INIT') - self.state.add_transition ('>', 'ESC', DoUpReverse, 'INIT') - self.state.add_transition ('<', 'ESC', DoUpReverse, 'INIT') - self.state.add_transition ('=', 'ESC', None, 'INIT') # Selects application keypad. - self.state.add_transition ('#', 'ESC', None, 'GRAPHICS_POUND') - self.state.add_transition_any ('GRAPHICS_POUND', None, 'INIT') - self.state.add_transition ('[', 'ESC', None, 'ELB') + self.state = FSM.FSM('INIT', [self]) + self.state.set_default_transition(Log, 'INIT') + self.state.add_transition_any('INIT', Emit, 'INIT') + self.state.add_transition('\x1b', 'INIT', None, 'ESC') + self.state.add_transition_any('ESC', Log, 'INIT') + self.state.add_transition('(', 'ESC', None, 'G0SCS') + self.state.add_transition(')', 'ESC', None, 'G1SCS') + self.state.add_transition_list('AB012', 'G0SCS', None, 'INIT') + self.state.add_transition_list('AB012', 'G1SCS', None, 'INIT') + self.state.add_transition('7', 'ESC', DoCursorSave, 'INIT') + self.state.add_transition('8', 'ESC', DoCursorRestore, 'INIT') + self.state.add_transition('M', 'ESC', DoUpReverse, 'INIT') + self.state.add_transition('>', 'ESC', DoUpReverse, 'INIT') + self.state.add_transition('<', 'ESC', DoUpReverse, 'INIT') + # Selects application keypad. + self.state.add_transition('=', 'ESC', None, 'INIT') + self.state.add_transition('#', 'ESC', None, 'GRAPHICS_POUND') + self.state.add_transition_any('GRAPHICS_POUND', None, 'INIT') + self.state.add_transition('[', 'ESC', None, 'ELB') # ELB means Escape Left Bracket. That is ^[[ - self.state.add_transition ('H', 'ELB', DoHomeOrigin, 'INIT') - self.state.add_transition ('D', 'ELB', DoBackOne, 'INIT') - self.state.add_transition ('B', 'ELB', DoDownOne, 'INIT') - self.state.add_transition ('C', 'ELB', DoForwardOne, 'INIT') - self.state.add_transition ('A', 'ELB', DoUpOne, 'INIT') - self.state.add_transition ('J', 'ELB', DoEraseDown, 'INIT') - self.state.add_transition ('K', 'ELB', DoEraseEndOfLine, 'INIT') - self.state.add_transition ('r', 'ELB', DoEnableScroll, 'INIT') - self.state.add_transition ('m', 'ELB', None, 'INIT') - self.state.add_transition ('?', 'ELB', None, 'MODECRAP') - self.state.add_transition_list (string.digits, 'ELB', StartNumber, 'NUMBER_1') - self.state.add_transition_list (string.digits, 'NUMBER_1', BuildNumber, 'NUMBER_1') - self.state.add_transition ('D', 'NUMBER_1', DoBack, 'INIT') - self.state.add_transition ('B', 'NUMBER_1', DoDown, 'INIT') - self.state.add_transition ('C', 'NUMBER_1', DoForward, 'INIT') - self.state.add_transition ('A', 'NUMBER_1', DoUp, 'INIT') - self.state.add_transition ('J', 'NUMBER_1', DoErase, 'INIT') - self.state.add_transition ('K', 'NUMBER_1', DoEraseLine, 'INIT') - self.state.add_transition ('l', 'NUMBER_1', DoMode, 'INIT') - ### It gets worse... the 'm' code can have infinite number of - ### number;number;number before it. I've never seen more than two, - ### but the specs say it's allowed. crap! - self.state.add_transition ('m', 'NUMBER_1', None, 'INIT') - ### LED control. Same problem as 'm' code. - self.state.add_transition ('q', 'NUMBER_1', None, 'INIT') - + self.state.add_transition('H', 'ELB', DoHomeOrigin, 'INIT') + self.state.add_transition('D', 'ELB', DoBackOne, 'INIT') + self.state.add_transition('B', 'ELB', DoDownOne, 'INIT') + self.state.add_transition('C', 'ELB', DoForwardOne, 'INIT') + self.state.add_transition('A', 'ELB', DoUpOne, 'INIT') + self.state.add_transition('J', 'ELB', DoEraseDown, 'INIT') + self.state.add_transition('K', 'ELB', DoEraseEndOfLine, 'INIT') + self.state.add_transition('r', 'ELB', DoEnableScroll, 'INIT') + self.state.add_transition('m', 'ELB', None, 'INIT') + self.state.add_transition('?', 'ELB', None, 'MODECRAP') + self.state.add_transition_list( + string.digits, 'ELB', StartNumber, 'NUMBER_1') + self.state.add_transition_list( + string.digits, 'NUMBER_1', BuildNumber, 'NUMBER_1') + self.state.add_transition('D', 'NUMBER_1', DoBack, 'INIT') + self.state.add_transition('B', 'NUMBER_1', DoDown, 'INIT') + self.state.add_transition('C', 'NUMBER_1', DoForward, 'INIT') + self.state.add_transition('A', 'NUMBER_1', DoUp, 'INIT') + self.state.add_transition('J', 'NUMBER_1', DoErase, 'INIT') + self.state.add_transition('K', 'NUMBER_1', DoEraseLine, 'INIT') + self.state.add_transition('l', 'NUMBER_1', DoMode, 'INIT') + # It gets worse... the 'm' code can have infinite number of + # number;number;number before it. I've never seen more than two, + # but the specs say it's allowed. crap! + self.state.add_transition('m', 'NUMBER_1', None, 'INIT') + # LED control. Same problem as 'm' code. + self.state.add_transition('q', 'NUMBER_1', None, 'INIT') + # \E[?47h appears to be "switch to alternate screen" # \E[?47l restores alternate screen... I think. - self.state.add_transition_list (string.digits, 'MODECRAP', StartNumber, 'MODECRAP_NUM') - self.state.add_transition_list (string.digits, 'MODECRAP_NUM', BuildNumber, 'MODECRAP_NUM') - self.state.add_transition ('l', 'MODECRAP_NUM', None, 'INIT') - self.state.add_transition ('h', 'MODECRAP_NUM', None, 'INIT') - -#RM Reset Mode Esc [ Ps l none - self.state.add_transition (';', 'NUMBER_1', None, 'SEMICOLON') - self.state.add_transition_any ('SEMICOLON', Log, 'INIT') - self.state.add_transition_list (string.digits, 'SEMICOLON', StartNumber, 'NUMBER_2') - self.state.add_transition_list (string.digits, 'NUMBER_2', BuildNumber, 'NUMBER_2') - self.state.add_transition_any ('NUMBER_2', Log, 'INIT') - self.state.add_transition ('H', 'NUMBER_2', DoHome, 'INIT') - self.state.add_transition ('f', 'NUMBER_2', DoHome, 'INIT') - self.state.add_transition ('r', 'NUMBER_2', DoScrollRegion, 'INIT') - ### It gets worse... the 'm' code can have infinite number of - ### number;number;number before it. I've never seen more than two, - ### but the specs say it's allowed. crap! - self.state.add_transition ('m', 'NUMBER_2', None, 'INIT') - ### LED control. Same problem as 'm' code. - self.state.add_transition ('q', 'NUMBER_2', None, 'INIT') - - def process (self, c): + self.state.add_transition_list( + string.digits, 'MODECRAP', StartNumber, 'MODECRAP_NUM') + self.state.add_transition_list( + string.digits, + 'MODECRAP_NUM', + BuildNumber, + 'MODECRAP_NUM') + self.state.add_transition('l', 'MODECRAP_NUM', None, 'INIT') + self.state.add_transition('h', 'MODECRAP_NUM', None, 'INIT') + +# RM Reset Mode Esc [ Ps l none + self.state.add_transition(';', 'NUMBER_1', None, 'SEMICOLON') + self.state.add_transition_any('SEMICOLON', Log, 'INIT') + self.state.add_transition_list( + string.digits, 'SEMICOLON', StartNumber, 'NUMBER_2') + self.state.add_transition_list( + string.digits, 'NUMBER_2', BuildNumber, 'NUMBER_2') + self.state.add_transition_any('NUMBER_2', Log, 'INIT') + self.state.add_transition('H', 'NUMBER_2', DoHome, 'INIT') + self.state.add_transition('f', 'NUMBER_2', DoHome, 'INIT') + self.state.add_transition('r', 'NUMBER_2', DoScrollRegion, 'INIT') + # It gets worse... the 'm' code can have infinite number of + # number;number;number before it. I've never seen more than two, + # but the specs say it's allowed. crap! + self.state.add_transition('m', 'NUMBER_2', None, 'INIT') + # LED control. Same problem as 'm' code. + self.state.add_transition('q', 'NUMBER_2', None, 'INIT') + + def process(self, c): self.state.process(c) - def process_list (self, l): + def process_list(self, l): self.write(l) - def write (self, s): + def write(self, s): for c in s: self.process(c) - def flush (self): + def flush(self): pass - def write_ch (self, ch): - + def write_ch(self, ch): """This puts a character at the current cursor position. cursor position if moved forward with wrap-around, but no scrolling is done if the cursor hits the lower-right corner of the screen. """ @@ -270,7 +306,7 @@ class ANSI (term): ch = ch[0] if ch == '\r': - # self.crlf() + # self.crlf() return if ch == '\n': self.crlf() @@ -281,8 +317,8 @@ class ANSI (term): return if ch not in string.printable: - fout = open ('log', 'a') - fout.write ('Nonprint: ' + str(ord(ch)) + '\n') + fout = open('log', 'a') + fout.write('Nonprint: ' + str(ord(ch)) + '\n') fout.close() return self.put_abs(self.cur_r, self.cur_c, ch) @@ -292,10 +328,10 @@ class ANSI (term): if old_c == self.cur_c: self.cursor_down() if old_r != self.cur_r: - self.cursor_home (self.cur_r, 1) + self.cursor_home(self.cur_r, 1) else: - self.scroll_up () - self.cursor_home (self.cur_r, 1) + self.scroll_up() + self.cursor_home(self.cur_r, 1) self.erase_line() # def test (self): @@ -329,6 +365,6 @@ class ANSI (term): # self.write_ch (c) # print str(self) # -#if __name__ == '__main__': +# if __name__ == '__main__': # t = ANSI(6,65) # t.test() diff --git a/lldb/third_party/Python/module/pexpect-2.4/FSM.py b/lldb/third_party/Python/module/pexpect-2.4/FSM.py index 751eb37e1304..420afb748f12 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/FSM.py +++ b/lldb/third_party/Python/module/pexpect-2.4/FSM.py @@ -66,6 +66,7 @@ you can always prevent this just by defining a default transition. Noah Spurrier 20020822 """ + class ExceptionFSM(Exception): """This is the FSM Exception class.""" @@ -74,7 +75,8 @@ class ExceptionFSM(Exception): self.value = value def __str__(self): - return `self.value` + return repr(self.value) + class FSM: @@ -82,7 +84,6 @@ class FSM: """ def __init__(self, initial_state, memory=None): - """This creates the FSM. You set the initial state here. The "memory" attribute is any object that you want to pass along to the action functions. It is not used by the FSM. For parsing you would typically @@ -101,8 +102,7 @@ class FSM: self.action = None self.memory = memory - def reset (self): - + def reset(self): """This sets the current_state to the initial_state and sets input_symbol to None. The initial state was set by the constructor __init__(). """ @@ -110,8 +110,12 @@ class FSM: self.current_state = self.initial_state self.input_symbol = None - def add_transition (self, input_symbol, state, action=None, next_state=None): - + def add_transition( + self, + input_symbol, + state, + action=None, + next_state=None): """This adds a transition that associates: (input_symbol, current_state) --> (action, next_state) @@ -127,8 +131,12 @@ class FSM: next_state = state self.state_transitions[(input_symbol, state)] = (action, next_state) - def add_transition_list (self, list_input_symbols, state, action=None, next_state=None): - + def add_transition_list( + self, + list_input_symbols, + state, + action=None, + next_state=None): """This adds the same transition for a list of input symbols. You can pass a list or a string. Note that it is handy to use string.digits, string.whitespace, string.letters, etc. to add @@ -141,10 +149,9 @@ class FSM: if next_state is None: next_state = state for input_symbol in list_input_symbols: - self.add_transition (input_symbol, state, action, next_state) - - def add_transition_any (self, state, action=None, next_state=None): + self.add_transition(input_symbol, state, action, next_state) + def add_transition_any(self, state, action=None, next_state=None): """This adds a transition that associates: (current_state) --> (action, next_state) @@ -159,10 +166,9 @@ class FSM: if next_state is None: next_state = state - self.state_transitions_any [state] = (action, next_state) - - def set_default_transition (self, action, next_state): + self.state_transitions_any[state] = (action, next_state) + def set_default_transition(self, action, next_state): """This sets the default transition. This defines an action and next_state if the FSM cannot find the input symbol and the current state in the transition list and if the FSM cannot find the @@ -174,8 +180,7 @@ class FSM: self.default_transition = (action, next_state) - def get_transition (self, input_symbol, state): - + def get_transition(self, input_symbol, state): """This returns (action, next state) given an input_symbol and state. This does not modify the FSM state, so calling this method has no side effects. Normally you do not call this method directly. It is called by @@ -197,18 +202,17 @@ class FSM: 4. No transition was defined. If we get here then raise an exception. """ - if self.state_transitions.has_key((input_symbol, state)): + if (input_symbol, state) in self.state_transitions: return self.state_transitions[(input_symbol, state)] - elif self.state_transitions_any.has_key (state): + elif state in self.state_transitions_any: return self.state_transitions_any[state] elif self.default_transition is not None: return self.default_transition else: - raise ExceptionFSM ('Transition is undefined: (%s, %s).' % - (str(input_symbol), str(state)) ) - - def process (self, input_symbol): + raise ExceptionFSM('Transition is undefined: (%s, %s).' % + (str(input_symbol), str(state))) + def process(self, input_symbol): """This is the main method that you call to process input. This may cause the FSM to change state and call an action. This method calls get_transition() to find the action and next_state associated with the @@ -218,26 +222,26 @@ class FSM: (or a string) by calling process_list(). """ self.input_symbol = input_symbol - (self.action, self.next_state) = self.get_transition (self.input_symbol, self.current_state) + (self.action, self.next_state) = self.get_transition( + self.input_symbol, self.current_state) if self.action is not None: - self.action (self) + self.action(self) self.current_state = self.next_state self.next_state = None - def process_list (self, input_symbols): - + def process_list(self, input_symbols): """This takes a list and sends each element to process(). The list may be a string or any iterable object. """ for s in input_symbols: - self.process (s) + self.process(s) ############################################################################## # The following is an example that demonstrates the use of the FSM class to # process an RPN expression. Run this module from the command line. You will # get a prompt > for input. Enter an RPN Expression. Numbers may be integers. # Operators are * / + - Use the = sign to evaluate and print the expression. -# For example: +# For example: # # 167 3 2 2 * * * 1 - = # @@ -246,58 +250,81 @@ class FSM: # 2003 ############################################################################## -import sys, os, traceback, optparse, time, string +import sys +import os +import traceback +import optparse +import time +import string # -# These define the actions. +# These define the actions. # Note that "memory" is a list being used as a stack. # -def BeginBuildNumber (fsm): - fsm.memory.append (fsm.input_symbol) -def BuildNumber (fsm): - s = fsm.memory.pop () +def BeginBuildNumber(fsm): + fsm.memory.append(fsm.input_symbol) + + +def BuildNumber(fsm): + s = fsm.memory.pop() s = s + fsm.input_symbol - fsm.memory.append (s) + fsm.memory.append(s) + + +def EndBuildNumber(fsm): + s = fsm.memory.pop() + fsm.memory.append(int(s)) -def EndBuildNumber (fsm): - s = fsm.memory.pop () - fsm.memory.append (int(s)) -def DoOperator (fsm): +def DoOperator(fsm): ar = fsm.memory.pop() al = fsm.memory.pop() if fsm.input_symbol == '+': - fsm.memory.append (al + ar) + fsm.memory.append(al + ar) elif fsm.input_symbol == '-': - fsm.memory.append (al - ar) + fsm.memory.append(al - ar) elif fsm.input_symbol == '*': - fsm.memory.append (al * ar) + fsm.memory.append(al * ar) elif fsm.input_symbol == '/': - fsm.memory.append (al / ar) + fsm.memory.append(al / ar) -def DoEqual (fsm): + +def DoEqual(fsm): print str(fsm.memory.pop()) -def Error (fsm): + +def Error(fsm): print 'That does not compute.' print str(fsm.input_symbol) -def main(): +def main(): """This is where the example starts and the FSM state transitions are defined. Note that states are strings (such as 'INIT'). This is not necessary, but it makes the example easier to read. """ - f = FSM ('INIT', []) # "memory" will be used as a stack. - f.set_default_transition (Error, 'INIT') - f.add_transition_any ('INIT', None, 'INIT') - f.add_transition ('=', 'INIT', DoEqual, 'INIT') - f.add_transition_list (string.digits, 'INIT', BeginBuildNumber, 'BUILDING_NUMBER') - f.add_transition_list (string.digits, 'BUILDING_NUMBER', BuildNumber, 'BUILDING_NUMBER') - f.add_transition_list (string.whitespace, 'BUILDING_NUMBER', EndBuildNumber, 'INIT') - f.add_transition_list ('+-*/', 'INIT', DoOperator, 'INIT') + f = FSM('INIT', []) # "memory" will be used as a stack. + f.set_default_transition(Error, 'INIT') + f.add_transition_any('INIT', None, 'INIT') + f.add_transition('=', 'INIT', DoEqual, 'INIT') + f.add_transition_list( + string.digits, + 'INIT', + BeginBuildNumber, + 'BUILDING_NUMBER') + f.add_transition_list( + string.digits, + 'BUILDING_NUMBER', + BuildNumber, + 'BUILDING_NUMBER') + f.add_transition_list( + string.whitespace, + 'BUILDING_NUMBER', + EndBuildNumber, + 'INIT') + f.add_transition_list('+-*/', 'INIT', DoOperator, 'INIT') print print 'Enter an RPN Expression.' @@ -305,26 +332,38 @@ def main(): print 'Use the = sign to evaluate and print the expression.' print 'For example: ' print ' 167 3 2 2 * * * 1 - =' - inputstr = raw_input ('> ') + inputstr = raw_input('> ') f.process_list(inputstr) if __name__ == '__main__': try: start_time = time.time() - parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), usage=globals()['__doc__'], version='$Id: FSM.py 490 2007-12-07 15:46:24Z noah $') - parser.add_option ('-v', '--verbose', action='store_true', default=False, help='verbose output') + parser = optparse.OptionParser( + formatter=optparse.TitledHelpFormatter(), + usage=globals()['__doc__'], + version='$Id: FSM.py 490 2007-12-07 15:46:24Z noah $') + parser.add_option( + '-v', + '--verbose', + action='store_true', + default=False, + help='verbose output') (options, args) = parser.parse_args() - if options.verbose: print time.asctime() + if options.verbose: + print time.asctime() main() - if options.verbose: print time.asctime() - if options.verbose: print 'TOTAL TIME IN MINUTES:', - if options.verbose: print (time.time() - start_time) / 60.0 + if options.verbose: + print time.asctime() + if options.verbose: + print 'TOTAL TIME IN MINUTES:', + if options.verbose: + print (time.time() - start_time) / 60.0 sys.exit(0) - except KeyboardInterrupt, e: # Ctrl-C + except KeyboardInterrupt as e: # Ctrl-C raise e - except SystemExit, e: # sys.exit() + except SystemExit as e: # sys.exit() raise e - except Exception, e: + except Exception as e: print 'ERROR, UNEXPECTED EXCEPTION' print str(e) traceback.print_exc() diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/astat.py b/lldb/third_party/Python/module/pexpect-2.4/examples/astat.py index 82fa3c68b705..a5d1b3514bc2 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/astat.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/astat.py @@ -13,30 +13,42 @@ Example: """ -import os, sys, time, re, getopt, getpass +import os +import sys +import time +import re +import getopt +import getpass import traceback -import pexpect, pxssh +import pexpect +import pxssh + def exit_with_usage(): print globals()['__doc__'] os._exit(1) + def main(): ###################################################################### - ## Parse the options, arguments, get ready, etc. + # Parse the options, arguments, get ready, etc. ###################################################################### try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?s:u:p:', ['help','h','?']) - except Exception, e: + optlist, args = getopt.getopt( + sys.argv[ + 1:], 'h?s:u:p:', [ + 'help', 'h', '?']) + except Exception as e: print str(e) exit_with_usage() options = dict(optlist) if len(args) > 1: exit_with_usage() - if [elem for elem in options if elem in ['-h','--h','-?','--?','--help']]: + if [elem for elem in options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: print "Help:" exit_with_usage() @@ -67,8 +79,7 @@ def main(): if __name__ == "__main__": try: main() - except Exception, e: + except Exception as e: print str(e) traceback.print_exc() os._exit(1) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/bd_client.py b/lldb/third_party/Python/module/pexpect-2.4/examples/bd_client.py index 564739a0aad5..a941bc935552 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/bd_client.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/bd_client.py @@ -4,35 +4,37 @@ for testing rather than normal use. See bd_serv.py """ import socket -import sys, time, select +import sys +import time +import select + def recv_wrapper(s): - r,w,e = select.select([s.fileno()],[],[], 2) + r, w, e = select.select([s.fileno()], [], [], 2) if not r: return '' #cols = int(s.recv(4)) #rows = int(s.recv(4)) cols = 80 rows = 24 - packet_size = cols * rows * 2 # double it for good measure + packet_size = cols * rows * 2 # double it for good measure return s.recv(packet_size) -#HOST = '' #'localhost' # The remote host -#PORT = 1664 # The same port as used by the server +# HOST = '' #'localhost' # The remote host +# PORT = 1664 # The same port as used by the server s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) -s.connect(sys.argv[1])#(HOST, PORT)) +s.connect(sys.argv[1]) # (HOST, PORT)) time.sleep(1) -#s.setblocking(0) +# s.setblocking(0) #s.send('COMMAND' + '\x01' + sys.argv[1]) s.send(':sendline ' + sys.argv[2]) print recv_wrapper(s) s.close() sys.exit() -#while True: +# while True: # data = recv_wrapper(s) # if data == '': # break # sys.stdout.write (data) # sys.stdout.flush() -#s.close() - +# s.close() diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/bd_serv.py b/lldb/third_party/Python/module/pexpect-2.4/examples/bd_serv.py index b7def9e14022..aa6a9ddb2c3f 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/bd_serv.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/bd_serv.py @@ -14,20 +14,30 @@ This exposes an shell terminal on a socket. # Having the password on the command line is not a good idea, but # then this entire project is probably not the most security concious thing # I've ever built. This should be considered an experimental tool -- at best. -import pxssh, pexpect, ANSI -import time, sys, os, getopt, getpass, traceback, threading, socket +import pxssh +import pexpect +import ANSI +import time +import sys +import os +import getopt +import getpass +import traceback +import threading +import socket + def exit_with_usage(exit_code=1): print globals()['__doc__'] os._exit(exit_code) + class roller (threading.Thread): """This runs a function in a loop in a thread.""" def __init__(self, interval, function, args=[], kwargs={}): - """The interval parameter defines time between each call to the function. """ @@ -39,7 +49,6 @@ class roller (threading.Thread): self.finished = threading.Event() def cancel(self): - """Stop the roller.""" self.finished.set() @@ -50,8 +59,8 @@ class roller (threading.Thread): # self.finished.wait(self.interval) self.function(*self.args, **self.kwargs) -def endless_poll (child, prompt, screen, refresh_timeout=0.1): +def endless_poll(child, prompt, screen, refresh_timeout=0.1): """This keeps the screen updated with the output of the child. This runs in a separate thread. See roller(). """ @@ -61,7 +70,7 @@ def endless_poll (child, prompt, screen, refresh_timeout=0.1): screen.write(s) except: pass - #while True: + # while True: # #child.prompt (timeout=refresh_timeout) # try: # #child.read_nonblocking(1,timeout=refresh_timeout) @@ -69,14 +78,14 @@ def endless_poll (child, prompt, screen, refresh_timeout=0.1): # except: # pass -def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'): +def daemonize(stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'): '''This forks the current process into a daemon. Almost none of this is necessary (or advisable) if your daemon is being started by inetd. In that case, stdin, stdout and stderr are all set up for you to refer to the network connection, and the fork()s and session manipulation should not be done (to avoid confusing inetd). Only the chdir() and umask() steps remain - as useful. + as useful. References: UNIX Programming FAQ @@ -94,30 +103,30 @@ def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'): expect. ''' # Do first fork. - try: - pid = os.fork() + try: + pid = os.fork() if pid > 0: sys.exit(0) # Exit first parent. - except OSError, e: - sys.stderr.write ("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror) ) + except OSError as e: + sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror)) sys.exit(1) # Decouple from parent environment. - os.chdir("/") - os.umask(0) - os.setsid() + os.chdir("/") + os.umask(0) + os.setsid() # Do second fork. - try: - pid = os.fork() + try: + pid = os.fork() if pid > 0: sys.exit(0) # Exit second parent. - except OSError, e: - sys.stderr.write ("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror) ) + except OSError as e: + sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror)) sys.exit(1) # Now I am a daemon! - + # Redirect standard file descriptors. si = open(stdin, 'r') so = open(stdout, 'a+') @@ -129,25 +138,32 @@ def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'): # I now return as the daemon return 0 -def add_cursor_blink (response, row, col): - i = (row-1) * 80 + col - return response[:i]+'<img src="http://www.noah.org/cursor.gif">'+response[i:] +def add_cursor_blink(response, row, col): + + i = (row - 1) * 80 + col + return response[:i] + \ + '<img src="http://www.noah.org/cursor.gif">' + response[i:] -def main (): + +def main(): try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?d', ['help','h','?', 'hostname=', 'username=', 'password=', 'port=', 'watch']) - except Exception, e: + optlist, args = getopt.getopt( + sys.argv[ + 1:], 'h?d', [ + 'help', 'h', '?', 'hostname=', 'username=', 'password=', 'port=', 'watch']) + except Exception as e: print str(e) exit_with_usage() command_line_options = dict(optlist) options = dict(optlist) # There are a million ways to cry for help. These are but a few of them. - if [elem for elem in command_line_options if elem in ['-h','--h','-?','--?','--help']]: + if [elem for elem in command_line_options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: exit_with_usage(0) - + hostname = "127.0.0.1" port = 1664 username = os.getenv('USER') @@ -170,38 +186,39 @@ def main (): password = options['--password'] else: password = getpass.getpass('password: ') - - if daemon_mode: + + if daemon_mode: print "daemonizing server" daemonize() - #daemonize('/dev/null','/tmp/daemon.log','/tmp/daemon.log') - - sys.stdout.write ('server started with pid %d\n' % os.getpid() ) + # daemonize('/dev/null','/tmp/daemon.log','/tmp/daemon.log') + + sys.stdout.write('server started with pid %d\n' % os.getpid()) - virtual_screen = ANSI.ANSI (24,80) + virtual_screen = ANSI.ANSI(24, 80) child = pxssh.pxssh() - child.login (hostname, username, password) + child.login(hostname, username, password) print 'created shell. command line prompt is', child.PROMPT #child.sendline ('stty -echo') - #child.setecho(False) - virtual_screen.write (child.before) - virtual_screen.write (child.after) + # child.setecho(False) + virtual_screen.write(child.before) + virtual_screen.write(child.after) - if os.path.exists("/tmp/mysock"): os.remove("/tmp/mysock") + if os.path.exists("/tmp/mysock"): + os.remove("/tmp/mysock") s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) localhost = '127.0.0.1' s.bind('/tmp/mysock') - os.chmod('/tmp/mysock',0777) + os.chmod('/tmp/mysock', 0o777) print 'Listen' s.listen(1) print 'Accept' #s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #localhost = '127.0.0.1' #s.bind((localhost, port)) - #print 'Listen' - #s.listen(1) + # print 'Listen' + # s.listen(1) - r = roller (0.01, endless_poll, (child, child.PROMPT, virtual_screen)) + r = roller(0.01, endless_poll, (child, child.PROMPT, virtual_screen)) r.start() print "screen poll updater started in background thread" sys.stdout.flush() @@ -211,12 +228,12 @@ def main (): conn, addr = s.accept() print 'Connected by', addr data = conn.recv(1024) - if data[0]!=':': + if data[0] != ':': cmd = ':sendline' arg = data.strip() else: request = data.split(' ', 1) - if len(request)>1: + if len(request) > 1: cmd = request[0].strip() arg = request[1].strip() else: @@ -225,45 +242,50 @@ def main (): r.cancel() break elif cmd == ':sendline': - child.sendline (arg) - #child.prompt(timeout=2) + child.sendline(arg) + # child.prompt(timeout=2) time.sleep(0.2) shell_window = str(virtual_screen) - elif cmd == ':send' or cmd==':xsend': - if cmd==':xsend': + elif cmd == ':send' or cmd == ':xsend': + if cmd == ':xsend': arg = arg.decode("hex") - child.send (arg) + child.send(arg) time.sleep(0.2) shell_window = str(virtual_screen) elif cmd == ':cursor': - shell_window = '%x%x' % (virtual_screen.cur_r, virtual_screen.cur_c) + shell_window = '%x%x' % ( + virtual_screen.cur_r, virtual_screen.cur_c) elif cmd == ':refresh': shell_window = str(virtual_screen) response = [] - response.append (shell_window) + response.append(shell_window) #response = add_cursor_blink (response, row, col) sent = conn.send('\n'.join(response)) - if watch_mode: print '\n'.join(response) - if sent < len (response): + if watch_mode: + print '\n'.join(response) + if sent < len(response): print "Sent is too short. Some data was cut off." conn.close() finally: r.cancel() print "cleaning up socket" s.close() - if os.path.exists("/tmp/mysock"): os.remove("/tmp/mysock") + if os.path.exists("/tmp/mysock"): + os.remove("/tmp/mysock") print "done!" -def pretty_box (rows, cols, s): +def pretty_box(rows, cols, s): """This puts an ASCII text box around the given string, s. """ - top_bot = '+' + '-'*cols + '+\n' - return top_bot + '\n'.join(['|'+line+'|' for line in s.split('\n')]) + '\n' + top_bot - -def error_response (msg): + top_bot = '+' + '-' * cols + '+\n' + return top_bot + \ + '\n'.join(['|' + line + '|' for line in s.split('\n')]) + '\n' + top_bot + + +def error_response(msg): response = [] response.append ("""All commands start with : @@ -280,11 +302,11 @@ Example: is equivalent to: :sendline ls -l """) - response.append (msg) + response.append(msg) return '\n'.join(response) -def parse_host_connect_string (hcs): +def parse_host_connect_string(hcs): """This parses a host connection string in the form username:password@hostname:port. All fields are options expcet hostname. A dictionary is returned with all four keys. Keys that were not included are @@ -292,14 +314,16 @@ def parse_host_connect_string (hcs): then you must backslash escape it. """ if '@' in hcs: - p = re.compile (r'(?P<username>[^@:]*)(:?)(?P<password>.*)(?!\\)@(?P<hostname>[^:]*):?(?P<port>[0-9]*)') + p = re.compile( + r'(?P<username>[^@:]*)(:?)(?P<password>.*)(?!\\)@(?P<hostname>[^:]*):?(?P<port>[0-9]*)') else: - p = re.compile (r'(?P<username>)(?P<password>)(?P<hostname>[^:]*):?(?P<port>[0-9]*)') - m = p.search (hcs) + p = re.compile( + r'(?P<username>)(?P<password>)(?P<hostname>[^:]*):?(?P<port>[0-9]*)') + m = p.search(hcs) d = m.groupdict() - d['password'] = d['password'].replace('\\@','@') + d['password'] = d['password'].replace('\\@', '@') return d - + if __name__ == "__main__": try: @@ -309,8 +333,7 @@ if __name__ == "__main__": print time.asctime() print "TOTAL TIME IN MINUTES:", print (time.time() - start_time) / 60.0 - except Exception, e: + except Exception as e: print str(e) tb_dump = traceback.format_exc() print str(tb_dump) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/chess.py b/lldb/third_party/Python/module/pexpect-2.4/examples/chess.py index 8c32cf798f2a..2e785182bd41 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/chess.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/chess.py @@ -11,121 +11,122 @@ import ANSI REGEX_MOVE = '(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)' REGEX_MOVE_PART = '(?:[0-9]|\x1b\[C)(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)' + class Chess: - def __init__(self, engine = "/usr/local/bin/gnuchess -a -h 1"): - self.child = pexpect.spawn (engine) - self.term = ANSI.ANSI () - - self.child.expect ('Chess') - if self.child.after != 'Chess': - raise IOError, 'incompatible chess program' - self.term.process_list (self.before) - self.term.process_list (self.after) - self.last_computer_move = '' - def read_until_cursor (self, r,c) - while 1: - self.child.read(1, 60) - self.term.process (c) - if self.term.cur_r == r and self.term.cur_c == c: - return 1 - - def do_first_move (self, move): - self.child.expect ('Your move is') - self.child.sendline (move) - self.term.process_list (self.before) - self.term.process_list (self.after) - return move - - def do_move (self, move): - read_until_cursor (19,60) - #self.child.expect ('\[19;60H') - self.child.sendline (move) - print 'do_move' move - return move - - def get_first_computer_move (self): - self.child.expect ('My move is') - self.child.expect (REGEX_MOVE) + def __init__(self, engine="/usr/local/bin/gnuchess -a -h 1"): + self.child = pexpect.spawn(engine) + self.term = ANSI.ANSI() + + self.child.expect('Chess') + if self.child.after != 'Chess': + raise IOError, 'incompatible chess program' + self.term.process_list(self.before) + self.term.process_list(self.after) + self.last_computer_move = '' + + def read_until_cursor(self, r, c) + while 1: + self.child.read(1, 60) + self.term.process(c) + if self.term.cur_r == r and self.term.cur_c == c: + return 1 + + def do_first_move(self, move): + self.child.expect('Your move is') + self.child.sendline(move) + self.term.process_list(self.before) + self.term.process_list(self.after) + return move + + def do_move(self, move): + read_until_cursor(19, 60) + #self.child.expect ('\[19;60H') + self.child.sendline(move) + print 'do_move' move + return move + + def get_first_computer_move(self): + self.child.expect('My move is') + self.child.expect(REGEX_MOVE) # print '', self.child.after - return self.child.after - - def get_computer_move (self): - print 'Here' - i = self.child.expect (['\[17;59H', '\[17;58H']) - print i - if i == 0: - self.child.expect (REGEX_MOVE) - if len(self.child.after) < 4: - self.child.after = self.child.after + self.last_computer_move[3] - if i == 1: - self.child.expect (REGEX_MOVE_PART) - self.child.after = self.last_computer_move[0] + self.child.after - print '', self.child.after - self.last_computer_move = self.child.after - return self.child.after - - def switch (self): - self.child.sendline ('switch') - - def set_depth (self, depth): - self.child.sendline ('depth') - self.child.expect ('depth=') - self.child.sendline ('%d' % depth) - - def quit(self): - self.child.sendline ('quit') -import sys, os + return self.child.after + + def get_computer_move(self): + print 'Here' + i = self.child.expect(['\[17;59H', '\[17;58H']) + print i + if i == 0: + self.child.expect(REGEX_MOVE) + if len(self.child.after) < 4: + self.child.after = self.child.after + \ + self.last_computer_move[3] + if i == 1: + self.child.expect(REGEX_MOVE_PART) + self.child.after = self.last_computer_move[0] + self.child.after + print '', self.child.after + self.last_computer_move = self.child.after + return self.child.after + + def switch(self): + self.child.sendline('switch') + + def set_depth(self, depth): + self.child.sendline('depth') + self.child.expect('depth=') + self.child.sendline('%d' % depth) + + def quit(self): + self.child.sendline('quit') +import sys +import os print 'Starting...' white = Chess() white.child.echo = 1 -white.child.expect ('Your move is') +white.child.expect('Your move is') white.set_depth(2) white.switch() move_white = white.get_first_computer_move() print 'first move white:', move_white -white.do_move ('e7e5') +white.do_move('e7e5') move_white = white.get_computer_move() print 'move white:', move_white -white.do_move ('f8c5') +white.do_move('f8c5') move_white = white.get_computer_move() print 'move white:', move_white -white.do_move ('b8a6') +white.do_move('b8a6') move_white = white.get_computer_move() print 'move white:', move_white sys.exit(1) - black = Chess() white = Chess() -white.child.expect ('Your move is') +white.child.expect('Your move is') white.switch() move_white = white.get_first_computer_move() print 'first move white:', move_white -black.do_first_move (move_white) +black.do_first_move(move_white) move_black = black.get_first_computer_move() print 'first move black:', move_black -white.do_move (move_black) +white.do_move(move_black) done = 0 while not done: move_white = white.get_computer_move() print 'move white:', move_white - black.do_move (move_white) + black.do_move(move_white) move_black = black.get_computer_move() print 'move black:', move_black - - white.do_move (move_black) + + white.do_move(move_black) print 'tail of loop' g.quit() - - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/chess2.py b/lldb/third_party/Python/module/pexpect-2.4/examples/chess2.py index c62d5ce37a06..c75b6d8493fa 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/chess2.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/chess2.py @@ -7,125 +7,129 @@ It starts two instances of gnuchess and then pits them against each other. import pexpect import string import ANSI -import sys, os, time +import sys +import os +import time + class Chess: - def __init__(self, engine = "/usr/local/bin/gnuchess -a -h 1"): - self.child = pexpect.spawn (engine) - self.term = ANSI.ANSI () - - #self.child.expect ('Chess') - #if self.child.after != 'Chess': - # raise IOError, 'incompatible chess program' - #self.term.process_list (self.child.before) - #self.term.process_list (self.child.after) - - self.last_computer_move = '' - - def read_until_cursor (self, r,c, e=0): - '''Eventually something like this should move into the screen class or - a subclass. Maybe a combination of pexpect and screen... - ''' - fout = open ('log','a') - while self.term.cur_r != r or self.term.cur_c != c: - try: - k = self.child.read(1, 10) - except Exception, e: - print 'EXCEPTION, (r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c) - sys.stdout.flush() - self.term.process (k) - fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c)) - fout.flush() - if e: - sys.stdout.write (k) - sys.stdout.flush() - if self.term.cur_r == r and self.term.cur_c == c: - fout.close() - return 1 - print 'DIDNT EVEN HIT.' - fout.close() - return 1 - - def expect_region (self): - '''This is another method that would be moved into the - screen class. - ''' - pass - def do_scan (self): - fout = open ('log','a') - while 1: - c = self.child.read(1,10) - self.term.process (c) - fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c)) - fout.flush() - sys.stdout.write (c) + def __init__(self, engine="/usr/local/bin/gnuchess -a -h 1"): + self.child = pexpect.spawn(engine) + self.term = ANSI.ANSI() + + #self.child.expect ('Chess') + # if self.child.after != 'Chess': + # raise IOError, 'incompatible chess program' + #self.term.process_list (self.child.before) + #self.term.process_list (self.child.after) + + self.last_computer_move = '' + + def read_until_cursor(self, r, c, e=0): + '''Eventually something like this should move into the screen class or + a subclass. Maybe a combination of pexpect and screen... + ''' + fout = open('log', 'a') + while self.term.cur_r != r or self.term.cur_c != c: + try: + k = self.child.read(1, 10) + except Exception as e: + print 'EXCEPTION, (r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c) sys.stdout.flush() - - def do_move (self, move, e = 0): - time.sleep(1) - self.read_until_cursor (19,60, e) - self.child.sendline (move) - - def wait (self, color): - while 1: - r = self.term.get_region (14,50,14,60)[0] - r = r.strip() - if r == color: - return - time.sleep (1) - - def parse_computer_move (self, s): - i = s.find ('is: ') - cm = s[i+3:i+9] - return cm - def get_computer_move (self, e = 0): - time.sleep(1) - self.read_until_cursor (19,60, e) - time.sleep(1) - r = self.term.get_region (17,50,17,62)[0] - cm = self.parse_computer_move (r) - return cm - - def switch (self): - print 'switching' - self.child.sendline ('switch') - - def set_depth (self, depth): - self.child.sendline ('depth') - self.child.expect ('depth=') - self.child.sendline ('%d' % depth) - - def quit(self): - self.child.sendline ('quit') - -def LOG (s): + self.term.process(k) + fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c)) + fout.flush() + if e: + sys.stdout.write(k) + sys.stdout.flush() + if self.term.cur_r == r and self.term.cur_c == c: + fout.close() + return 1 + print 'DIDNT EVEN HIT.' + fout.close() + return 1 + + def expect_region(self): + '''This is another method that would be moved into the + screen class. + ''' + pass + + def do_scan(self): + fout = open('log', 'a') + while True: + c = self.child.read(1, 10) + self.term.process(c) + fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c)) + fout.flush() + sys.stdout.write(c) + sys.stdout.flush() + + def do_move(self, move, e=0): + time.sleep(1) + self.read_until_cursor(19, 60, e) + self.child.sendline(move) + + def wait(self, color): + while True: + r = self.term.get_region(14, 50, 14, 60)[0] + r = r.strip() + if r == color: + return + time.sleep(1) + + def parse_computer_move(self, s): + i = s.find('is: ') + cm = s[i + 3:i + 9] + return cm + + def get_computer_move(self, e=0): + time.sleep(1) + self.read_until_cursor(19, 60, e) + time.sleep(1) + r = self.term.get_region(17, 50, 17, 62)[0] + cm = self.parse_computer_move(r) + return cm + + def switch(self): + print 'switching' + self.child.sendline('switch') + + def set_depth(self, depth): + self.child.sendline('depth') + self.child.expect('depth=') + self.child.sendline('%d' % depth) + + def quit(self): + self.child.sendline('quit') + + +def LOG(s): print s - sys.stdout.flush () - fout = open ('moves.log', 'a') - fout.write (s + '\n') + sys.stdout.flush() + fout = open('moves.log', 'a') + fout.write(s + '\n') fout.close() print 'Starting...' black = Chess() white = Chess() -white.read_until_cursor (19,60,1) +white.read_until_cursor(19, 60, 1) white.switch() done = 0 while not done: - white.wait ('Black') + white.wait('Black') move_white = white.get_computer_move(1) - LOG ( 'move white:'+ move_white ) + LOG('move white:' + move_white) - black.do_move (move_white) - black.wait ('White') + black.do_move(move_white) + black.wait('White') move_black = black.get_computer_move() - LOG ( 'move black:'+ move_black ) - - white.do_move (move_black, 1) - -g.quit() + LOG('move black:' + move_black) + white.do_move(move_black, 1) +g.quit() diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/chess3.py b/lldb/third_party/Python/module/pexpect-2.4/examples/chess3.py index 44044420a1c9..2fa7fb62722d 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/chess3.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/chess3.py @@ -11,128 +11,129 @@ import ANSI REGEX_MOVE = '(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)' REGEX_MOVE_PART = '(?:[0-9]|\x1b\[C)(?:[a-z]|\x1b\[C)(?:[0-9]|\x1b\[C)' + class Chess: - def __init__(self, engine = "/usr/local/bin/gnuchess -a -h 1"): - self.child = pexpect.spawn (engine) - self.term = ANSI.ANSI () - + def __init__(self, engine="/usr/local/bin/gnuchess -a -h 1"): + self.child = pexpect.spawn(engine) + self.term = ANSI.ANSI() + # self.child.expect ('Chess') - # if self.child.after != 'Chess': - # raise IOError, 'incompatible chess program' - # self.term.process_list (self.before) - # self.term.process_list (self.after) - self.last_computer_move = '' - def read_until_cursor (self, r,c): - fout = open ('log','a') - while 1: - k = self.child.read(1, 10) - self.term.process (k) - fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c)) - fout.flush() - if self.term.cur_r == r and self.term.cur_c == c: - fout.close() - return 1 - sys.stdout.write (k) - sys.stdout.flush() - - def do_scan (self): - fout = open ('log','a') - while 1: - c = self.child.read(1,10) - self.term.process (c) - fout.write ('(r,c):(%d,%d)\n' %(self.term.cur_r, self.term.cur_c)) - fout.flush() - sys.stdout.write (c) - sys.stdout.flush() - - def do_move (self, move): - self.read_until_cursor (19,60) - self.child.sendline (move) - return move - - def get_computer_move (self): - print 'Here' - i = self.child.expect (['\[17;59H', '\[17;58H']) - print i - if i == 0: - self.child.expect (REGEX_MOVE) - if len(self.child.after) < 4: - self.child.after = self.child.after + self.last_computer_move[3] - if i == 1: - self.child.expect (REGEX_MOVE_PART) - self.child.after = self.last_computer_move[0] + self.child.after - print '', self.child.after - self.last_computer_move = self.child.after - return self.child.after - - def switch (self): - self.child.sendline ('switch') - - def set_depth (self, depth): - self.child.sendline ('depth') - self.child.expect ('depth=') - self.child.sendline ('%d' % depth) - - def quit(self): - self.child.sendline ('quit') -import sys, os + # if self.child.after != 'Chess': + # raise IOError, 'incompatible chess program' + # self.term.process_list (self.before) + # self.term.process_list (self.after) + self.last_computer_move = '' + + def read_until_cursor(self, r, c): + fout = open('log', 'a') + while True: + k = self.child.read(1, 10) + self.term.process(k) + fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c)) + fout.flush() + if self.term.cur_r == r and self.term.cur_c == c: + fout.close() + return 1 + sys.stdout.write(k) + sys.stdout.flush() + + def do_scan(self): + fout = open('log', 'a') + while True: + c = self.child.read(1, 10) + self.term.process(c) + fout.write('(r,c):(%d,%d)\n' % (self.term.cur_r, self.term.cur_c)) + fout.flush() + sys.stdout.write(c) + sys.stdout.flush() + + def do_move(self, move): + self.read_until_cursor(19, 60) + self.child.sendline(move) + return move + + def get_computer_move(self): + print 'Here' + i = self.child.expect(['\[17;59H', '\[17;58H']) + print i + if i == 0: + self.child.expect(REGEX_MOVE) + if len(self.child.after) < 4: + self.child.after = self.child.after + \ + self.last_computer_move[3] + if i == 1: + self.child.expect(REGEX_MOVE_PART) + self.child.after = self.last_computer_move[0] + self.child.after + print '', self.child.after + self.last_computer_move = self.child.after + return self.child.after + + def switch(self): + self.child.sendline('switch') + + def set_depth(self, depth): + self.child.sendline('depth') + self.child.expect('depth=') + self.child.sendline('%d' % depth) + + def quit(self): + self.child.sendline('quit') +import sys +import os print 'Starting...' white = Chess() white.do_move('b2b4') -white.read_until_cursor (19,60) -c1 = white.term.get_abs(17,58) -c2 = white.term.get_abs(17,59) -c3 = white.term.get_abs(17,60) -c4 = white.term.get_abs(17,61) -fout = open ('log','a') -fout.write ('Computer:%s%s%s%s\n' %(c1,c2,c3,c4)) +white.read_until_cursor(19, 60) +c1 = white.term.get_abs(17, 58) +c2 = white.term.get_abs(17, 59) +c3 = white.term.get_abs(17, 60) +c4 = white.term.get_abs(17, 61) +fout = open('log', 'a') +fout.write('Computer:%s%s%s%s\n' % (c1, c2, c3, c4)) fout.close() white.do_move('c2c4') -white.read_until_cursor (19,60) -c1 = white.term.get_abs(17,58) -c2 = white.term.get_abs(17,59) -c3 = white.term.get_abs(17,60) -c4 = white.term.get_abs(17,61) -fout = open ('log','a') -fout.write ('Computer:%s%s%s%s\n' %(c1,c2,c3,c4)) +white.read_until_cursor(19, 60) +c1 = white.term.get_abs(17, 58) +c2 = white.term.get_abs(17, 59) +c3 = white.term.get_abs(17, 60) +c4 = white.term.get_abs(17, 61) +fout = open('log', 'a') +fout.write('Computer:%s%s%s%s\n' % (c1, c2, c3, c4)) fout.close() -white.do_scan () +white.do_scan() #white.do_move ('b8a6') #move_white = white.get_computer_move() -#print 'move white:', move_white +# print 'move white:', move_white sys.exit(1) - black = Chess() white = Chess() -white.child.expect ('Your move is') +white.child.expect('Your move is') white.switch() move_white = white.get_first_computer_move() print 'first move white:', move_white -black.do_first_move (move_white) +black.do_first_move(move_white) move_black = black.get_first_computer_move() print 'first move black:', move_black -white.do_move (move_black) +white.do_move(move_black) done = 0 while not done: move_white = white.get_computer_move() print 'move white:', move_white - black.do_move (move_white) + black.do_move(move_white) move_black = black.get_computer_move() print 'move black:', move_black - - white.do_move (move_black) + + white.do_move(move_black) print 'tail of loop' g.quit() - - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/df.py b/lldb/third_party/Python/module/pexpect-2.4/examples/df.py index 64bbf93a1b29..e6c06a8fb13e 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/df.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/df.py @@ -9,15 +9,15 @@ Apple OSX. """ import pexpect -child = pexpect.spawn ('df') +child = pexpect.spawn('df') # parse 'df' output into a list. pattern = "\n(\S+).*?([0-9]+)%" filesystem_list = [] -for dummy in range (0, 1000): - i = child.expect ([pattern, pexpect.EOF]) +for dummy in range(0, 1000): + i = child.expect([pattern, pexpect.EOF]) if i == 0: - filesystem_list.append (child.match.groups()) + filesystem_list.append(child.match.groups()) else: break @@ -31,4 +31,3 @@ for m in filesystem_list: else: s = ' ' + s print s - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/fix_cvs_files.py b/lldb/third_party/Python/module/pexpect-2.4/examples/fix_cvs_files.py index e75a1496abdd..6fecf7cfbbe5 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/fix_cvs_files.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/fix_cvs_files.py @@ -17,79 +17,82 @@ Noah Spurrier 20030426 """ -import os, sys, time +import os +import sys +import time import pexpect VERBOSE = 1 -def is_binary (filename): +def is_binary(filename): """Assume that any file with a character where the 8th bit is set is binary. """ - fin = open(filename, 'rb') - wholething = fin.read() - fin.close() - for c in wholething: - if ord(c) & 0x80: - return 1 - return 0 + fin = open(filename, 'rb') + wholething = fin.read() + fin.close() + for c in wholething: + if ord(c) & 0x80: + return 1 + return 0 -def is_kb_sticky (filename): +def is_kb_sticky(filename): """This checks if 'cvs status' reports '-kb' for Sticky options. If the Sticky Option status is '-ks' then this returns 1. If the status is 'Unknown' then it returns 1. Otherwise 0 is returned. """ - try: - s = pexpect.spawn ('cvs status %s' % filename) - i = s.expect (['Sticky Options:\s*(.*)\r\n', 'Status: Unknown']) - if i==1 and VERBOSE: - print 'File not part of CVS repository:', filename - return 1 # Pretend it's OK. - if s.match.group(1) == '-kb': - return 1 - s = None - except: - print 'Something went wrong trying to run external cvs command.' - print ' cvs status %s' % filename - print 'The cvs command returned:' - print s.before - return 0 - -def cvs_admin_kb (filename): - + try: + s = pexpect.spawn('cvs status %s' % filename) + i = s.expect(['Sticky Options:\s*(.*)\r\n', 'Status: Unknown']) + if i == 1 and VERBOSE: + print 'File not part of CVS repository:', filename + return 1 # Pretend it's OK. + if s.match.group(1) == '-kb': + return 1 + s = None + except: + print 'Something went wrong trying to run external cvs command.' + print ' cvs status %s' % filename + print 'The cvs command returned:' + print s.before + return 0 + + +def cvs_admin_kb(filename): """This uses 'cvs admin' to set the '-kb' sticky option. """ - s = pexpect.run ('cvs admin -kb %s' % filename) - # There is a timing issue. If I run 'cvs admin' too quickly - # cvs sometimes has trouble obtaining the directory lock. - time.sleep(1) - -def walk_and_clean_cvs_binaries (arg, dirname, names): + s = pexpect.run('cvs admin -kb %s' % filename) + # There is a timing issue. If I run 'cvs admin' too quickly + # cvs sometimes has trouble obtaining the directory lock. + time.sleep(1) + +def walk_and_clean_cvs_binaries(arg, dirname, names): """This contains the logic for processing files. This is the os.path.walk callback. This skips dirnames that end in CVS. """ - if len(dirname)>3 and dirname[-3:]=='CVS': - return - for n in names: - fullpath = os.path.join (dirname, n) - if os.path.isdir(fullpath) or os.path.islink(fullpath): - continue - if is_binary(fullpath): - if not is_kb_sticky (fullpath): - if VERBOSE: print fullpath - cvs_admin_kb (fullpath) - -def main (): - - if len(sys.argv) == 1: - root = '.' - else: - root = sys.argv[1] - os.path.walk (root, walk_and_clean_cvs_binaries, None) + if len(dirname) > 3 and dirname[-3:] == 'CVS': + return + for n in names: + fullpath = os.path.join(dirname, n) + if os.path.isdir(fullpath) or os.path.islink(fullpath): + continue + if is_binary(fullpath): + if not is_kb_sticky(fullpath): + if VERBOSE: + print fullpath + cvs_admin_kb(fullpath) -if __name__ == '__main__': - main () +def main(): + + if len(sys.argv) == 1: + root = '.' + else: + root = sys.argv[1] + os.path.walk(root, walk_and_clean_cvs_binaries, None) + +if __name__ == '__main__': + main() diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/ftp.py b/lldb/third_party/Python/module/pexpect-2.4/examples/ftp.py index 89a502e1b8f4..c859632709bd 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/ftp.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/ftp.py @@ -24,9 +24,9 @@ child.expect('ftp> ') child.sendline('pwd') child.expect('ftp> ') print("Escape character is '^]'.\n") -sys.stdout.write (child.after) +sys.stdout.write(child.after) sys.stdout.flush() -child.interact() # Escape character defaults to ^] +child.interact() # Escape character defaults to ^] # At this point this script blocks until the user presses the escape character # or until the child exits. The human user and the child should be talking # to each other now. @@ -35,13 +35,13 @@ child.interact() # Escape character defaults to ^] print 'Left interactve mode.' # The rest is not strictly necessary. This just demonstrates a few functions. -# This makes sure the child is dead; although it would be killed when Python exits. +# This makes sure the child is dead; although it would be killed when +# Python exits. if child.isalive(): - child.sendline('bye') # Try to ask ftp child to exit. + child.sendline('bye') # Try to ask ftp child to exit. child.close() # Print the final state of the child. Normally isalive() should be FALSE. if child.isalive(): print 'Child did not exit gracefully.' else: print 'Child exited gracefully.' - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/hive.py b/lldb/third_party/Python/module/pexpect-2.4/examples/hive.py index fcb75bcac67f..d2b13d4f081a 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/hive.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/hive.py @@ -12,7 +12,7 @@ Example: $ hive.py --sameuser --samepass host1.example.com host2.example.net username: myusername - password: + password: connecting to host1.example.com - OK connecting to host2.example.net - OK targetting hosts: 192.168.1.104 192.168.1.107 @@ -66,18 +66,27 @@ $Id: hive.py 509 2008-01-05 21:27:47Z noah $ # TODO add feature to support username:password@host combination # TODO add feature to log each host output in separate file -import sys, os, re, optparse, traceback, types, time, getpass -import pexpect, pxssh -import readline, atexit +import sys +import os +import re +import optparse +import traceback +import types +import time +import getpass +import pexpect +import pxssh +import readline +import atexit #histfile = os.path.join(os.environ["HOME"], ".hive_history") -#try: +# try: # readline.read_history_file(histfile) -#except IOError: +# except IOError: # pass #atexit.register(readline.write_history_file, histfile) -CMD_HELP="""Hive commands are preceded by a colon : (just think of vi). +CMD_HELP = """Hive commands are preceded by a colon : (just think of vi). :target name1 name2 name3 ... @@ -85,7 +94,7 @@ CMD_HELP="""Hive commands are preceded by a colon : (just think of vi). :target all - reset list of hosts to target all hosts in the hive. + reset list of hosts to target all hosts in the hive. :to name command @@ -146,21 +155,23 @@ CMD_HELP="""Hive commands are preceded by a colon : (just think of vi). """ -def login (args, cli_username=None, cli_password=None): + +def login(args, cli_username=None, cli_password=None): # I have to keep a separate list of host names because Python dicts are not ordered. # I want to keep the same order as in the args list. host_names = [] hive_connect_info = {} hive = {} - # build up the list of connection information (hostname, username, password, port) + # build up the list of connection information (hostname, username, + # password, port) for host_connect_string in args: - hcd = parse_host_connect_string (host_connect_string) + hcd = parse_host_connect_string(host_connect_string) hostname = hcd['hostname'] - port = hcd['port'] + port = hcd['port'] if port == '': port = None - if len(hcd['username']) > 0: + if len(hcd['username']) > 0: username = hcd['username'] elif cli_username is not None: username = cli_username @@ -178,20 +189,21 @@ def login (args, cli_username=None, cli_password=None): for hostname in host_names: print 'connecting to', hostname try: - fout = file("log_"+hostname, "w") + fout = file("log_" + hostname, "w") hive[hostname] = pxssh.pxssh() hive[hostname].login(*hive_connect_info[hostname]) print hive[hostname].before hive[hostname].logfile = fout print '- OK' - except Exception, e: + except Exception as e: print '- ERROR', print str(e) print 'Skipping', hostname hive[hostname] = None return host_names, hive -def main (): + +def main(): global options, args, CMD_HELP @@ -204,7 +216,7 @@ def main (): cli_password = getpass.getpass('password: ') else: cli_password = None - + host_names, hive = login(args, cli_username, cli_password) synchronous_mode = True @@ -213,11 +225,11 @@ def main (): while True: cmd = raw_input('CMD (? for help) > ') cmd = cmd.strip() - if cmd=='?' or cmd==':help' or cmd==':h': + if cmd == '?' or cmd == ':help' or cmd == ':h': print CMD_HELP continue - elif cmd==':refresh': - refresh (hive, target_hostnames, timeout=0.5) + elif cmd == ':refresh': + refresh(hive, target_hostnames, timeout=0.5) for hostname in target_hostnames: if hive[hostname] is None: print '/=============================================================================' @@ -230,8 +242,8 @@ def main (): print hive[hostname].before print '==============================================================================' continue - elif cmd==':resync': - resync (hive, target_hostnames, timeout=0.5) + elif cmd == ':resync': + resync(hive, target_hostnames, timeout=0.5) for hostname in target_hostnames: if hive[hostname] is None: print '/=============================================================================' @@ -244,62 +256,62 @@ def main (): print hive[hostname].before print '==============================================================================' continue - elif cmd==':sync': + elif cmd == ':sync': synchronous_mode = True - resync (hive, target_hostnames, timeout=0.5) + resync(hive, target_hostnames, timeout=0.5) continue - elif cmd==':async': + elif cmd == ':async': synchronous_mode = False continue - elif cmd==':prompt': + elif cmd == ':prompt': for hostname in target_hostnames: try: if hive[hostname] is not None: hive[hostname].set_unique_prompt() - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None continue elif cmd[:5] == ':send': - cmd, txt = cmd.split(None,1) + cmd, txt = cmd.split(None, 1) for hostname in target_hostnames: try: if hive[hostname] is not None: hive[hostname].send(txt) - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None continue elif cmd[:3] == ':to': - cmd, hostname, txt = cmd.split(None,2) + cmd, hostname, txt = cmd.split(None, 2) if hive[hostname] is None: print '/=============================================================================' print '| ' + hostname + ' is DEAD' print '\\-----------------------------------------------------------------------------' continue try: - hive[hostname].sendline (txt) + hive[hostname].sendline(txt) hive[hostname].prompt(timeout=2) print '/=============================================================================' print '| ' + hostname print '\\-----------------------------------------------------------------------------' print hive[hostname].before - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None continue elif cmd[:7] == ':expect': - cmd, pattern = cmd.split(None,1) + cmd, pattern = cmd.split(None, 1) print 'looking for', pattern try: for hostname in target_hostnames: if hive[hostname] is not None: hive[hostname].expect(pattern) print hive[hostname].before - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None @@ -312,9 +324,9 @@ def main (): continue elif cmd == ':exit' or cmd == ':q' or cmd == ':quit': break - elif cmd[:8] == ':control' or cmd[:5] == ':ctrl' : - cmd, c = cmd.split(None,1) - if ord(c)-96 < 0 or ord(c)-96 > 255: + elif cmd[:8] == ':control' or cmd[:5] == ':ctrl': + cmd, c = cmd.split(None, 1) + if ord(c) - 96 < 0 or ord(c) - 96 > 255: print '/=============================================================================' print '| Invalid character. Must be [a-zA-Z], @, [, ], \\, ^, _, or ?' print '\\-----------------------------------------------------------------------------' @@ -323,7 +335,7 @@ def main (): try: if hive[hostname] is not None: hive[hostname].sendcontrol(c) - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None @@ -339,8 +351,8 @@ def main (): for hostname in target_hostnames: try: if hive[hostname] is not None: - hive[hostname].sendline (cmd) - except Exception, e: + hive[hostname].sendline(cmd) + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None @@ -361,23 +373,23 @@ def main (): print '| ' + hostname print '\\-----------------------------------------------------------------------------' print hive[hostname].before - except Exception, e: + except Exception as e: print "Had trouble communicating with %s, so removing it from the target list." % hostname print str(e) hive[hostname] = None print '==============================================================================' - -def refresh (hive, hive_names, timeout=0.5): + +def refresh(hive, hive_names, timeout=0.5): """This waits for the TIMEOUT on each host. """ # TODO This is ideal for threading. for hostname in hive_names: - hive[hostname].expect([pexpect.TIMEOUT,pexpect.EOF],timeout=timeout) + hive[hostname].expect([pexpect.TIMEOUT, pexpect.EOF], timeout=timeout) -def resync (hive, hive_names, timeout=2, max_attempts=5): +def resync(hive, hive_names, timeout=2, max_attempts=5): """This waits for the shell prompt for each host in an effort to try to get them all to the same state. The timeout is set low so that hosts that are already at the prompt will not slow things down too much. If a prompt match @@ -393,8 +405,8 @@ def resync (hive, hive_names, timeout=2, max_attempts=5): if not hive[hostname].prompt(timeout=timeout): break -def parse_host_connect_string (hcs): +def parse_host_connect_string(hcs): """This parses a host connection string in the form username:password@hostname:port. All fields are options expcet hostname. A dictionary is returned with all four keys. Keys that were not included are @@ -402,35 +414,58 @@ def parse_host_connect_string (hcs): then you must backslash escape it. """ if '@' in hcs: - p = re.compile (r'(?P<username>[^@:]*)(:?)(?P<password>.*)(?!\\)@(?P<hostname>[^:]*):?(?P<port>[0-9]*)') + p = re.compile( + r'(?P<username>[^@:]*)(:?)(?P<password>.*)(?!\\)@(?P<hostname>[^:]*):?(?P<port>[0-9]*)') else: - p = re.compile (r'(?P<username>)(?P<password>)(?P<hostname>[^:]*):?(?P<port>[0-9]*)') - m = p.search (hcs) + p = re.compile( + r'(?P<username>)(?P<password>)(?P<hostname>[^:]*):?(?P<port>[0-9]*)') + m = p.search(hcs) d = m.groupdict() - d['password'] = d['password'].replace('\\@','@') + d['password'] = d['password'].replace('\\@', '@') return d if __name__ == '__main__': try: start_time = time.time() - parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), usage=globals()['__doc__'], version='$Id: hive.py 509 2008-01-05 21:27:47Z noah $',conflict_handler="resolve") - parser.add_option ('-v', '--verbose', action='store_true', default=False, help='verbose output') - parser.add_option ('--samepass', action='store_true', default=False, help='Use same password for each login.') - parser.add_option ('--sameuser', action='store_true', default=False, help='Use same username for each login.') + parser = optparse.OptionParser( + formatter=optparse.TitledHelpFormatter(), + usage=globals()['__doc__'], + version='$Id: hive.py 509 2008-01-05 21:27:47Z noah $', + conflict_handler="resolve") + parser.add_option( + '-v', + '--verbose', + action='store_true', + default=False, + help='verbose output') + parser.add_option( + '--samepass', + action='store_true', + default=False, + help='Use same password for each login.') + parser.add_option( + '--sameuser', + action='store_true', + default=False, + help='Use same username for each login.') (options, args) = parser.parse_args() if len(args) < 1: - parser.error ('missing argument') - if options.verbose: print time.asctime() + parser.error('missing argument') + if options.verbose: + print time.asctime() main() - if options.verbose: print time.asctime() - if options.verbose: print 'TOTAL TIME IN MINUTES:', - if options.verbose: print (time.time() - start_time) / 60.0 + if options.verbose: + print time.asctime() + if options.verbose: + print 'TOTAL TIME IN MINUTES:', + if options.verbose: + print (time.time() - start_time) / 60.0 sys.exit(0) - except KeyboardInterrupt, e: # Ctrl-C + except KeyboardInterrupt as e: # Ctrl-C raise e - except SystemExit, e: # sys.exit() + except SystemExit as e: # sys.exit() raise e - except Exception, e: + except Exception as e: print 'ERROR, UNEXPECTED EXCEPTION' print str(e) traceback.print_exc() diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/monitor.py b/lldb/third_party/Python/module/pexpect-2.4/examples/monitor.py index e31b51b6d210..6ed6589d6707 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/monitor.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/monitor.py @@ -23,40 +23,53 @@ It works like this: Exit the remote host. """ -import os, sys, time, re, getopt, getpass +import os +import sys +import time +import re +import getopt +import getpass import traceback import pexpect # # Some constants. # -COMMAND_PROMPT = '[#$] ' ### This is way too simple for industrial use -- we will change is ASAP. +# This is way too simple for industrial use -- we will change is ASAP. +COMMAND_PROMPT = '[#$] ' TERMINAL_PROMPT = '(?i)terminal type\?' TERMINAL_TYPE = 'vt100' -# This is the prompt we get if SSH does not have the remote host's public key stored in the cache. +# This is the prompt we get if SSH does not have the remote host's public +# key stored in the cache. SSH_NEWKEY = '(?i)are you sure you want to continue connecting' + def exit_with_usage(): print globals()['__doc__'] os._exit(1) + def main(): global COMMAND_PROMPT, TERMINAL_PROMPT, TERMINAL_TYPE, SSH_NEWKEY ###################################################################### - ## Parse the options, arguments, get ready, etc. + # Parse the options, arguments, get ready, etc. ###################################################################### try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?s:u:p:', ['help','h','?']) - except Exception, e: + optlist, args = getopt.getopt( + sys.argv[ + 1:], 'h?s:u:p:', [ + 'help', 'h', '?']) + except Exception as e: print str(e) exit_with_usage() options = dict(optlist) if len(args) > 1: exit_with_usage() - if [elem for elem in options if elem in ['-h','--h','-?','--?','--help']]: + if [elem for elem in options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: print "Help:" exit_with_usage() @@ -76,16 +89,17 @@ def main(): # # Login via SSH # - child = pexpect.spawn('ssh -l %s %s'%(user, host)) - i = child.expect([pexpect.TIMEOUT, SSH_NEWKEY, COMMAND_PROMPT, '(?i)password']) - if i == 0: # Timeout + child = pexpect.spawn('ssh -l %s %s' % (user, host)) + i = child.expect([pexpect.TIMEOUT, SSH_NEWKEY, + COMMAND_PROMPT, '(?i)password']) + if i == 0: # Timeout print 'ERROR! could not login with SSH. Here is what SSH said:' print child.before, child.after print str(child) - sys.exit (1) - if i == 1: # In this case SSH does not have the public key cached. - child.sendline ('yes') - child.expect ('(?i)password') + sys.exit(1) + if i == 1: # In this case SSH does not have the public key cached. + child.sendline('yes') + child.expect('(?i)password') if i == 2: # This may happen if a public key was setup to automatically login. # But beware, the COMMAND_PROMPT at this point is very trivial and @@ -95,25 +109,25 @@ def main(): child.sendline(password) # Now we are either at the command prompt or # the login process is asking for our terminal type. - i = child.expect ([COMMAND_PROMPT, TERMINAL_PROMPT]) + i = child.expect([COMMAND_PROMPT, TERMINAL_PROMPT]) if i == 1: - child.sendline (TERMINAL_TYPE) - child.expect (COMMAND_PROMPT) + child.sendline(TERMINAL_TYPE) + child.expect(COMMAND_PROMPT) # # Set command prompt to something more unique. # COMMAND_PROMPT = "\[PEXPECT\]\$ " - child.sendline ("PS1='[PEXPECT]\$ '") # In case of sh-style - i = child.expect ([pexpect.TIMEOUT, COMMAND_PROMPT], timeout=10) + child.sendline("PS1='[PEXPECT]\$ '") # In case of sh-style + i = child.expect([pexpect.TIMEOUT, COMMAND_PROMPT], timeout=10) if i == 0: print "# Couldn't set sh-style prompt -- trying csh-style." - child.sendline ("set prompt='[PEXPECT]\$ '") - i = child.expect ([pexpect.TIMEOUT, COMMAND_PROMPT], timeout=10) + child.sendline("set prompt='[PEXPECT]\$ '") + i = child.expect([pexpect.TIMEOUT, COMMAND_PROMPT], timeout=10) if i == 0: print "Failed to set command prompt using sh or csh style." print "Response was:" print child.before - sys.exit (1) + sys.exit(1) # Now we should be at the command prompt and ready to run some commands. print '---------------------------------------' @@ -121,8 +135,8 @@ def main(): print '---------------------------------------' # Run uname. - child.sendline ('uname -a') - child.expect (COMMAND_PROMPT) + child.sendline('uname -a') + child.expect(COMMAND_PROMPT) print child.before if 'linux' in child.before.lower(): LINUX_MODE = 1 @@ -130,51 +144,52 @@ def main(): LINUX_MODE = 0 # Run and parse 'uptime'. - child.sendline ('uptime') - child.expect('up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])') + child.sendline('uptime') + child.expect( + 'up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])') duration, users, av1, av5, av15 = child.match.groups() days = '0' hours = '0' mins = '0' if 'day' in duration: - child.match = re.search('([0-9]+)\s+day',duration) + child.match = re.search('([0-9]+)\s+day', duration) days = str(int(child.match.group(1))) if ':' in duration: - child.match = re.search('([0-9]+):([0-9]+)',duration) + child.match = re.search('([0-9]+):([0-9]+)', duration) hours = str(int(child.match.group(1))) mins = str(int(child.match.group(2))) if 'min' in duration: - child.match = re.search('([0-9]+)\s+min',duration) + child.match = re.search('([0-9]+)\s+min', duration) mins = str(int(child.match.group(1))) print print 'Uptime: %s days, %s users, %s (1 min), %s (5 min), %s (15 min)' % ( duration, users, av1, av5, av15) - child.expect (COMMAND_PROMPT) + child.expect(COMMAND_PROMPT) # Run iostat. - child.sendline ('iostat') - child.expect (COMMAND_PROMPT) + child.sendline('iostat') + child.expect(COMMAND_PROMPT) print child.before # Run vmstat. - child.sendline ('vmstat') - child.expect (COMMAND_PROMPT) + child.sendline('vmstat') + child.expect(COMMAND_PROMPT) print child.before # Run free. if LINUX_MODE: - child.sendline ('free') # Linux systems only. - child.expect (COMMAND_PROMPT) + child.sendline('free') # Linux systems only. + child.expect(COMMAND_PROMPT) print child.before # Run df. - child.sendline ('df') - child.expect (COMMAND_PROMPT) + child.sendline('df') + child.expect(COMMAND_PROMPT) print child.before - + # Run lsof. - child.sendline ('lsof') - child.expect (COMMAND_PROMPT) + child.sendline('lsof') + child.expect(COMMAND_PROMPT) print child.before # # Run netstat @@ -191,9 +206,9 @@ def main(): # print child.before # Now exit the remote host. - child.sendline ('exit') + child.sendline('exit') index = child.expect([pexpect.EOF, "(?i)there are stopped jobs"]) - if index==1: + if index == 1: child.sendline("exit") child.expect(EOF) @@ -201,8 +216,7 @@ if __name__ == "__main__": try: main() - except Exception, e: + except Exception as e: print str(e) traceback.print_exc() os._exit(1) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/passmass.py b/lldb/third_party/Python/module/pexpect-2.4/examples/passmass.py index b1e17b9cb036..3d129b67d776 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/passmass.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/passmass.py @@ -4,7 +4,8 @@ Note that login shell prompt on remote machine must end in # or $. """ import pexpect -import sys, getpass +import sys +import getpass USAGE = '''passmass host1 host2 host3 . . .''' COMMAND_PROMPT = '[$#] ' @@ -12,38 +13,42 @@ TERMINAL_PROMPT = r'Terminal type\?' TERMINAL_TYPE = 'vt100' SSH_NEWKEY = r'Are you sure you want to continue connecting \(yes/no\)\?' + def login(host, user, password): - child = pexpect.spawn('ssh -l %s %s'%(user, host)) - fout = file ("LOG.TXT","wb") - child.setlog (fout) + child = pexpect.spawn('ssh -l %s %s' % (user, host)) + fout = file("LOG.TXT", "wb") + child.setlog(fout) i = child.expect([pexpect.TIMEOUT, SSH_NEWKEY, '[Pp]assword: ']) - if i == 0: # Timeout + if i == 0: # Timeout print 'ERROR!' print 'SSH could not login. Here is what SSH said:' print child.before, child.after - sys.exit (1) - if i == 1: # SSH does not have the public key. Just accept it. - child.sendline ('yes') - child.expect ('[Pp]assword: ') + sys.exit(1) + if i == 1: # SSH does not have the public key. Just accept it. + child.sendline('yes') + child.expect('[Pp]assword: ') child.sendline(password) # Now we are either at the command prompt or # the login process is asking for our terminal type. - i = child.expect (['Permission denied', TERMINAL_PROMPT, COMMAND_PROMPT]) + i = child.expect(['Permission denied', TERMINAL_PROMPT, COMMAND_PROMPT]) if i == 0: print 'Permission denied on host:', host - sys.exit (1) + sys.exit(1) if i == 1: - child.sendline (TERMINAL_TYPE) - child.expect (COMMAND_PROMPT) + child.sendline(TERMINAL_TYPE) + child.expect(COMMAND_PROMPT) return child # (current) UNIX password: + + def change_password(child, user, oldpassword, newpassword): - child.sendline('passwd') - i = child.expect(['[Oo]ld [Pp]assword', '.current.*password', '[Nn]ew [Pp]assword']) + child.sendline('passwd') + i = child.expect( + ['[Oo]ld [Pp]assword', '.current.*password', '[Nn]ew [Pp]assword']) # Root does not require old password, so it gets to bypass the next step. if i == 0 or i == 1: child.sendline(oldpassword) @@ -53,11 +58,12 @@ def change_password(child, user, oldpassword, newpassword): if i == 0: print 'Host did not like new password. Here is what it said...' print child.before - child.send (chr(3)) # Ctrl-C - child.sendline('') # This should tell remote passwd command to quit. + child.send(chr(3)) # Ctrl-C + child.sendline('') # This should tell remote passwd command to quit. return child.sendline(newpassword) + def main(): if len(sys.argv) <= 1: @@ -74,7 +80,7 @@ def main(): for host in sys.argv[1:]: child = login(host, user, password) - if child == None: + if child is None: print 'Could not login to host:', host continue print 'Changing password on host:', host @@ -85,6 +91,5 @@ def main(): if __name__ == '__main__': try: main() - except pexpect.ExceptionPexpect, e: + except pexpect.ExceptionPexpect as e: print str(e) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/python.py b/lldb/third_party/Python/module/pexpect-2.4/examples/python.py index d8c986652e6d..e7ef462ba680 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/python.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/python.py @@ -7,10 +7,10 @@ the user interactive control over the session. Why? For fun... """ # c = pexpect.spawn ('/usr/bin/env python ./python.py') import pexpect -c = pexpect.spawn ('/usr/bin/env python') -c.expect ('>>>') +c = pexpect.spawn('/usr/bin/env python') +c.expect('>>>') print 'And now for something completely different...' -f = lambda s:s and f(s[1:])+s[0] # Makes a function to reverse a string. +f = lambda s: s and f(s[1:]) + s[0] # Makes a function to reverse a string. print f(c.before) print 'Yes, it\'s python, but it\'s backwards.' print @@ -19,4 +19,3 @@ print c.after, c.interact() c.kill(1) print 'is alive:', c.isalive() - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/rippy.py b/lldb/third_party/Python/module/pexpect-2.4/examples/rippy.py index e89c314c323c..8967821b1fe2 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/rippy.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/rippy.py @@ -69,7 +69,15 @@ Noah Spurrier $Id: rippy.py 517 2008-08-18 22:23:56Z noah $ """ -import sys, os, re, math, stat, getopt, traceback, types, time +import sys +import os +import re +import math +import stat +import getopt +import traceback +import types +import time import pexpect __version__ = '1.2' @@ -77,7 +85,7 @@ __revision__ = '$Revision: 11 $' __all__ = ['main', __version__, __revision__] GLOBAL_LOGFILE_NAME = "rippy_%d.log" % os.getpid() -GLOBAL_LOGFILE = open (GLOBAL_LOGFILE_NAME, "wb") +GLOBAL_LOGFILE = open(GLOBAL_LOGFILE_NAME, "wb") ############################################################################### # This giant section defines the prompts and defaults used in interactive mode. @@ -85,32 +93,32 @@ GLOBAL_LOGFILE = open (GLOBAL_LOGFILE_NAME, "wb") # Python dictionaries are unordered, so # I have this list that maintains the order of the keys. prompts_key_order = ( -'verbose_flag', -'dry_run_flag', -'video_source_filename', -'video_chapter', -'video_final_filename', -'video_length', -'video_aspect_ratio', -'video_scale', -'video_encode_passes', -'video_codec', -'video_fourcc_override', -'video_bitrate', -'video_bitrate_overhead', -'video_target_size', -'video_deinterlace_flag', -'video_crop_area', -'video_gray_flag', -'subtitle_id', -'audio_id', -'audio_codec', -'audio_raw_filename', -'audio_volume_boost', -'audio_sample_rate', -'audio_bitrate', -#'audio_lowpass_filter', -'delete_tmp_files_flag' + 'verbose_flag', + 'dry_run_flag', + 'video_source_filename', + 'video_chapter', + 'video_final_filename', + 'video_length', + 'video_aspect_ratio', + 'video_scale', + 'video_encode_passes', + 'video_codec', + 'video_fourcc_override', + 'video_bitrate', + 'video_bitrate_overhead', + 'video_target_size', + 'video_deinterlace_flag', + 'video_crop_area', + 'video_gray_flag', + 'subtitle_id', + 'audio_id', + 'audio_codec', + 'audio_raw_filename', + 'audio_volume_boost', + 'audio_sample_rate', + 'audio_bitrate', + #'audio_lowpass_filter', + 'delete_tmp_files_flag' ) # # The 'prompts' dictionary holds all the messages shown to the user in @@ -118,58 +126,58 @@ prompts_key_order = ( # prompt_key : ( default value, prompt string, help string, level of difficulty (0,1,2) ) # prompts = { -'video_source_filename':("dvd://1", 'video source filename?', """This is the filename of the video that you want to convert from. + 'video_source_filename': ("dvd://1", 'video source filename?', """This is the filename of the video that you want to convert from. It can be any file that mencoder supports. You can also choose a DVD device using the dvd://1 syntax. -Title 1 is usually the main title on a DVD.""",0), -'video_chapter':("none",'video chapter?',"""This is the chapter number. Usually disks such as TV series seasons will be divided into chapters. Maybe be set to none.""",0), -'video_final_filename':("video_final.avi", "video final filename?", """This is the name of the final video.""",0), -'audio_raw_filename':("audiodump.wav", "audio raw filename?", """This is the audio raw PCM filename. This is prior to compression. -Note that mplayer automatically names this audiodump.wav, so don't change this.""",1000), -#'audio_compressed_filename':("audiodump.mp3","Audio compressed filename?", """This is the name of the compressed audio that will be mixed -#into the final video. Normally you don't need to change this.""",2), -'video_length':("none","video length in seconds?","""This sets the length of the video in seconds. This is used to estimate the +Title 1 is usually the main title on a DVD.""", 0), + 'video_chapter': ("none", 'video chapter?', """This is the chapter number. Usually disks such as TV series seasons will be divided into chapters. Maybe be set to none.""", 0), + 'video_final_filename': ("video_final.avi", "video final filename?", """This is the name of the final video.""", 0), + 'audio_raw_filename': ("audiodump.wav", "audio raw filename?", """This is the audio raw PCM filename. This is prior to compression. +Note that mplayer automatically names this audiodump.wav, so don't change this.""", 1000), + #'audio_compressed_filename':("audiodump.mp3","Audio compressed filename?", """This is the name of the compressed audio that will be mixed + # into the final video. Normally you don't need to change this.""",2), + 'video_length': ("none", "video length in seconds?", """This sets the length of the video in seconds. This is used to estimate the bitrate for a target video file size. Set to 'calc' to have Rippy calculate the length. Set to 'none' if you don't want rippy to estimate the bitrate -- -you will have to manually specify bitrate.""",1), -'video_aspect_ratio':("calc","aspect ratio?","""This sets the aspect ratio of the video. Most DVDs are 16/9 or 4/3.""",1), -'video_scale':("none","video scale?","""This scales the video to the given output size. The default is to do no scaling. +you will have to manually specify bitrate.""", 1), + 'video_aspect_ratio': ("calc", "aspect ratio?", """This sets the aspect ratio of the video. Most DVDs are 16/9 or 4/3.""", 1), + 'video_scale': ("none", "video scale?", """This scales the video to the given output size. The default is to do no scaling. You may type in a resolution such as 320x240 or you may use presets. qntsc: 352x240 (NTSC quarter screen) qpal: 352x288 (PAL quarter screen) ntsc: 720x480 (standard NTSC) pal: 720x576 (standard PAL) sntsc: 640x480 (square pixel NTSC) - spal: 768x576 (square pixel PAL)""",1), -'video_codec':("mpeg4","video codec?","""This is the video compression to use. This is passed directly to mencoder, so + spal: 768x576 (square pixel PAL)""", 1), + 'video_codec': ("mpeg4", "video codec?", """This is the video compression to use. This is passed directly to mencoder, so any format that it recognizes should work. For XviD or DivX use mpeg4. Almost all MS Windows systems support wmv2 out of the box. Some common codecs include: mjpeg, h263, h263p, h264, mpeg4, msmpeg4, wmv1, wmv2, mpeg1video, mpeg2video, huffyuv, ffv1. -""",2), -'audio_codec':("mp3","audio codec?","""This is the audio compression to use. This is passed directly to mencoder, so +""", 2), + 'audio_codec': ("mp3", "audio codec?", """This is the audio compression to use. This is passed directly to mencoder, so any format that it recognizes will work. Some common codecs include: mp3, mp2, aac, pcm -See mencoder manual for details.""",2), -'video_fourcc_override':("XVID","force fourcc code?","""This forces the fourcc codec to the given value. XVID is safest for Windows. +See mencoder manual for details.""", 2), + 'video_fourcc_override': ("XVID", "force fourcc code?", """This forces the fourcc codec to the given value. XVID is safest for Windows. The following are common fourcc values: FMP4 - This is the mencoder default. This is the "real" value. XVID - used by Xvid (safest) DX50 - - MP4S - Microsoft""",2), -'video_encode_passes':("1","number of encode passes?","""This sets how many passes to use to encode the video. You can choose 1 or 2. + MP4S - Microsoft""", 2), + 'video_encode_passes': ("1", "number of encode passes?", """This sets how many passes to use to encode the video. You can choose 1 or 2. Using two pases takes twice as long as one pass, but produces a better -quality video. I found that the improvement is not that impressive.""",1), -'verbose_flag':("Y","verbose output?","""This sets verbose output. If true then all commands and arguments are printed -before they are run. This is useful to see exactly how commands are run.""",1), -'dry_run_flag':("N","dry run?","""This sets 'dry run' mode. If true then commands are not run. This is useful -if you want to see what would the script would do.""",1), -'video_bitrate':("calc","video bitrate?","""This sets the video bitrate. This overrides video_target_size. +quality video. I found that the improvement is not that impressive.""", 1), + 'verbose_flag': ("Y", "verbose output?", """This sets verbose output. If true then all commands and arguments are printed +before they are run. This is useful to see exactly how commands are run.""", 1), + 'dry_run_flag': ("N", "dry run?", """This sets 'dry run' mode. If true then commands are not run. This is useful +if you want to see what would the script would do.""", 1), + 'video_bitrate': ("calc", "video bitrate?", """This sets the video bitrate. This overrides video_target_size. Set to 'calc' to automatically estimate the bitrate based on the video final target size. If you set video_length to 'none' then -you will have to specify this video_bitrate.""",1), -'video_target_size':("737280000","video final target size?","""This sets the target video size that you want to end up with. +you will have to specify this video_bitrate.""", 1), + 'video_target_size': ("737280000", "video final target size?", """This sets the target video size that you want to end up with. This is over-ridden by video_bitrate. In other words, if you specify video_bitrate then video_target_size is ignored. Due to the unpredictable nature of VBR compression the final video size @@ -177,44 +185,46 @@ may not exactly match. The following are common CDR sizes: 180MB CDR (21 minutes) holds 193536000 bytes 550MB CDR (63 minutes) holds 580608000 bytes 650MB CDR (74 minutes) holds 681984000 bytes - 700MB CDR (80 minutes) holds 737280000 bytes""",0), -'video_bitrate_overhead':("1.0","bitrate overhead factor?","""Adjust this value if you want to leave more room for + 700MB CDR (80 minutes) holds 737280000 bytes""", 0), + 'video_bitrate_overhead': ("1.0", "bitrate overhead factor?", """Adjust this value if you want to leave more room for other files such as subtitle files. -If you specify video_bitrate then this value is ignored.""",2), -'video_crop_area':("detect","crop area?","""This sets the crop area to remove black bars from the top or sides of the video. +If you specify video_bitrate then this value is ignored.""", 2), + 'video_crop_area': ("detect", "crop area?", """This sets the crop area to remove black bars from the top or sides of the video. This helps save space. Set to 'detect' to automatically detect the crop area. -Set to 'none' to not crop the video. Normally you don't need to change this.""",1), -'video_deinterlace_flag':("N","is the video interlaced?","""This sets the deinterlace flag. If set then mencoder will be instructed -to filter out interlace artifacts (using '-vf pp=md').""",1), -'video_gray_flag':("N","is the video black and white (gray)?","""This improves output for black and white video.""",1), -'subtitle_id':("None","Subtitle ID stream?","""This selects the subtitle stream to extract from the source video. +Set to 'none' to not crop the video. Normally you don't need to change this.""", 1), + 'video_deinterlace_flag': ("N", "is the video interlaced?", """This sets the deinterlace flag. If set then mencoder will be instructed +to filter out interlace artifacts (using '-vf pp=md').""", 1), + 'video_gray_flag': ("N", "is the video black and white (gray)?", """This improves output for black and white video.""", 1), + 'subtitle_id': ("None", "Subtitle ID stream?", """This selects the subtitle stream to extract from the source video. Normally, 0 is the English subtitle stream for a DVD. -Subtitles IDs with higher numbers may be other languages.""",1), -'audio_id':("128","audio ID stream?","""This selects the audio stream to extract from the source video. +Subtitles IDs with higher numbers may be other languages.""", 1), + 'audio_id': ("128", "audio ID stream?", """This selects the audio stream to extract from the source video. If your source is a VOB file (DVD) then stream IDs start at 128. Normally, 128 is the main audio track for a DVD. -Tracks with higher numbers may be other language dubs or audio commentary.""",1), -'audio_sample_rate':("32000","audio sample rate (Hz) 48000, 44100, 32000, 24000, 12000","""This sets the rate at which the compressed audio will be resampled. +Tracks with higher numbers may be other language dubs or audio commentary.""", 1), + 'audio_sample_rate': ("32000", "audio sample rate (Hz) 48000, 44100, 32000, 24000, 12000", """This sets the rate at which the compressed audio will be resampled. DVD audio is 48 kHz whereas music CDs use 44.1 kHz. The higher the sample rate the more space the audio track will take. That will leave less space for video. -32 kHz is a good trade-off if you are trying to fit a video onto a CD.""",1), -'audio_bitrate':("96","audio bitrate (kbit/s) 192, 128, 96, 64?","""This sets the bitrate for MP3 audio compression. +32 kHz is a good trade-off if you are trying to fit a video onto a CD.""", 1), + 'audio_bitrate': ("96", "audio bitrate (kbit/s) 192, 128, 96, 64?", """This sets the bitrate for MP3 audio compression. The higher the bitrate the more space the audio track will take. That will leave less space for video. Most people find music to be acceptable -at 128 kBitS. 96 kBitS is a good trade-off if you are trying to fit a video onto a CD.""",1), -'audio_volume_boost':("none","volume dB boost?","""Many DVDs have very low audio volume. This sets an audio volume boost in Decibels. -Values of 6 to 10 usually adjust quiet DVDs to a comfortable level.""",1), -#'audio_lowpass_filter':("16","audio lowpass filter (kHz)?","""This sets the low-pass filter for the audio. -#Normally this should be half of the audio sample rate. -#This improves audio compression and quality. -#Normally you don't need to change this.""",1), -'delete_tmp_files_flag':("N","delete temporary files when finished?","""If Y then %s, audio_raw_filename, and 'divx2pass.log' will be deleted at the end."""%GLOBAL_LOGFILE_NAME,1) +at 128 kBitS. 96 kBitS is a good trade-off if you are trying to fit a video onto a CD.""", 1), + 'audio_volume_boost': ("none", "volume dB boost?", """Many DVDs have very low audio volume. This sets an audio volume boost in Decibels. +Values of 6 to 10 usually adjust quiet DVDs to a comfortable level.""", 1), + #'audio_lowpass_filter':("16","audio lowpass filter (kHz)?","""This sets the low-pass filter for the audio. + # Normally this should be half of the audio sample rate. + # This improves audio compression and quality. + # Normally you don't need to change this.""",1), + 'delete_tmp_files_flag': ("N", "delete temporary files when finished?", """If Y then %s, audio_raw_filename, and 'divx2pass.log' will be deleted at the end.""" % GLOBAL_LOGFILE_NAME, 1) } ############################################################################## # This is the important convert control function ############################################################################## -def convert (options): + + +def convert(options): """This is the heart of it all -- this performs an end-to-end conversion of a video from one format to another. It requires a dictionary of options. The conversion process will also add some keys to the dictionary @@ -224,7 +234,7 @@ def convert (options): """ if options['subtitle_id'] is not None: print "# extract subtitles" - apply_smart (extract_subtitles, options) + apply_smart(extract_subtitles, options) else: print "# do not extract subtitles." @@ -233,47 +243,52 @@ def convert (options): # selected 'calc' for video_bitrate # or # selected 'detect' for video_crop_area. - if options['video_bitrate']=='calc' or options['video_crop_area']=='detect': + if options['video_bitrate'] == 'calc' or options[ + 'video_crop_area'] == 'detect': # As strange as it seems, the only reliable way to calculate the length # of a video (in seconds) is to extract the raw, uncompressed PCM audio stream # and then calculate the length of that. This is because MP4 video is VBR, so # you cannot get exact time based on compressed size. - if options['video_length']=='calc': + if options['video_length'] == 'calc': print "# extract PCM raw audio to %s" % (options['audio_raw_filename']) - apply_smart (extract_audio, options) - options['video_length'] = apply_smart (get_length, options) - print "# Length of raw audio file : %d seconds (%0.2f minutes)" % (options['video_length'], float(options['video_length'])/60.0) - if options['video_bitrate']=='calc': - options['video_bitrate'] = options['video_bitrate_overhead'] * apply_smart (calc_video_bitrate, options) + apply_smart(extract_audio, options) + options['video_length'] = apply_smart(get_length, options) + print "# Length of raw audio file : %d seconds (%0.2f minutes)" % (options['video_length'], float(options['video_length']) / 60.0) + if options['video_bitrate'] == 'calc': + options['video_bitrate'] = options[ + 'video_bitrate_overhead'] * apply_smart(calc_video_bitrate, options) print "# video bitrate : " + str(options['video_bitrate']) - if options['video_crop_area']=='detect': - options['video_crop_area'] = apply_smart (crop_detect, options) + if options['video_crop_area'] == 'detect': + options['video_crop_area'] = apply_smart(crop_detect, options) print "# crop area : " + str(options['video_crop_area']) print "# compression estimate" - print apply_smart (compression_estimate, options) + print apply_smart(compression_estimate, options) print "# compress video" - apply_smart (compress_video, options) + apply_smart(compress_video, options) 'audio_volume_boost', print "# delete temporary files:", if options['delete_tmp_files_flag']: print "yes" - apply_smart (delete_tmp_files, options) + apply_smart(delete_tmp_files, options) else: print "no" - # Finish by saving options to rippy.conf and + # Finish by saving options to rippy.conf and # calclating if final_size is less than target_size. o = ["# options used to create video\n"] - video_actual_size = get_filesize (options['video_final_filename']) + video_actual_size = get_filesize(options['video_final_filename']) if options['video_target_size'] != 'none': - revised_bitrate = calculate_revised_bitrate (options['video_bitrate'], options['video_target_size'], video_actual_size) + revised_bitrate = calculate_revised_bitrate( + options['video_bitrate'], + options['video_target_size'], + video_actual_size) o.append("# revised video_bitrate : %d\n" % revised_bitrate) - for k,v in options.iteritems(): - o.append (" %30s : %s\n" % (k, v)) + for k, v in options.iteritems(): + o.append(" %30s : %s\n" % (k, v)) print '# '.join(o) - fout = open("rippy.conf","wb").write(''.join(o)) + fout = open("rippy.conf", "wb").write(''.join(o)) print "# final actual video size = %d" % video_actual_size if options['video_target_size'] != 'none': if video_actual_size > options['video_target_size']: @@ -289,13 +304,15 @@ def convert (options): ############################################################################## + def exit_with_usage(exit_code=1): print globals()['__doc__'] print 'version:', globals()['__version__'] sys.stdout.flush() os._exit(exit_code) -def check_missing_requirements (): + +def check_missing_requirements(): """This list of missing requirements (mencoder, mplayer, lame, and mkvmerge). Returns None if all requirements are in the execution path. """ @@ -307,21 +324,22 @@ def check_missing_requirements (): cmd = "mencoder -oac help" (command_output, exitstatus) = run(cmd) ar = re.findall("(mp3lame)", command_output) - if len(ar)==0: + if len(ar) == 0: missing.append("Mencoder was not compiled with mp3lame support.") - - #if pexpect.which("lame") is None: + + # if pexpect.which("lame") is None: # missing.append("lame") - #if pexpect.which("mkvmerge") is None: + # if pexpect.which("mkvmerge") is None: # missing.append("mkvmerge") - if len(missing)==0: + if len(missing) == 0: return None return missing -def input_option (message, default_value="", help=None, level=0, max_level=0): + +def input_option(message, default_value="", help=None, level=0, max_level=0): """This is a fancy raw_input function. If the user enters '?' then the contents of help is printed. - + The 'level' and 'max_level' are used to adjust which advanced options are printed. 'max_level' is the level of options that the user wants to see. 'level' is the level of difficulty for this particular option. @@ -333,53 +351,63 @@ def input_option (message, default_value="", help=None, level=0, max_level=0): message = "%s [%s] " % (message, default_value) if level > max_level: return default_value - while 1: - user_input = raw_input (message) - if user_input=='?': + while True: + user_input = raw_input(message) + if user_input == '?': print help - elif user_input=='': + elif user_input == '': return default_value else: break return user_input -def progress_callback (d=None): + +def progress_callback(d=None): """This callback simply prints a dot to show activity. This is used when running external commands with pexpect.run. """ - sys.stdout.write (".") + sys.stdout.write(".") sys.stdout.flush() + def run(cmd): global GLOBAL_LOGFILE print >>GLOBAL_LOGFILE, cmd - (command_output, exitstatus) = pexpect.run(cmd, events={pexpect.TIMEOUT:progress_callback}, timeout=5, withexitstatus=True, logfile=GLOBAL_LOGFILE) + (command_output, + exitstatus) = pexpect.run(cmd, + events={pexpect.TIMEOUT: progress_callback}, + timeout=5, + withexitstatus=True, + logfile=GLOBAL_LOGFILE) if exitstatus != 0: print "RUN FAILED. RETURNED EXIT STATUS:", exitstatus print >>GLOBAL_LOGFILE, "RUN FAILED. RETURNED EXIT STATUS:", exitstatus return (command_output, exitstatus) -def apply_smart (func, args): - """This is similar to func(**args), but this won't complain about - extra keys in 'args'. This ignores keys in 'args' that are + +def apply_smart(func, args): + """This is similar to func(**args), but this won't complain about + extra keys in 'args'. This ignores keys in 'args' that are not required by 'func'. This passes None to arguments that are not defined in 'args'. That's fine for arguments with a default valeue, but that's a bug for required arguments. I should probably raise a TypeError. The func parameter can be a function reference or a string. If it is a string then it is converted to a function reference. """ - if type(func) is type(''): + if isinstance(func, type('')): if func in globals(): func = globals()[func] else: raise NameError("name '%s' is not defined" % func) - if hasattr(func,'im_func'): # Handle case when func is a class method. + if hasattr(func, 'im_func'): # Handle case when func is a class method. func = func.im_func argcount = func.func_code.co_argcount - required_args = dict([(k,args.get(k)) for k in func.func_code.co_varnames[:argcount]]) + required_args = dict([(k, args.get(k)) + for k in func.func_code.co_varnames[:argcount]]) return func(**required_args) -def count_unique (items): + +def count_unique(items): """This takes a list and returns a sorted list of tuples with a count of each unique item in the list. Example 1: count_unique(['a','b','c','a','c','c','a','c','c']) @@ -396,20 +424,25 @@ def count_unique (items): stats[i] = stats[i] + 1 else: stats[i] = 1 - stats = [(v, k) for k, v in stats.items()] - stats.sort() + stats = sorted([(v, k) for k, v in stats.items()]) stats.reverse() return stats -def calculate_revised_bitrate (video_bitrate, video_target_size, video_actual_size): + +def calculate_revised_bitrate( + video_bitrate, + video_target_size, + video_actual_size): """This calculates a revised video bitrate given the video_bitrate used, the actual size that resulted, and the video_target_size. This can be used if you want to compress the video all over again in an attempt to get closer to the video_target_size. """ - return int(math.floor(video_bitrate * (float(video_target_size) / float(video_actual_size)))) + return int(math.floor(video_bitrate * \ + (float(video_target_size) / float(video_actual_size)))) + -def get_aspect_ratio (video_source_filename): +def get_aspect_ratio(video_source_filename): """This returns the aspect ratio of the original video. This is usualy 1.78:1(16/9) or 1.33:1(4/3). This function is very lenient. It basically guesses 16/9 whenever @@ -417,8 +450,10 @@ def get_aspect_ratio (video_source_filename): """ cmd = "mplayer '%s' -vo png -ao null -frames 1" % video_source_filename (command_output, exitstatus) = run(cmd) - ar = re.findall("Movie-Aspect is ([0-9]+\.?[0-9]*:[0-9]+\.?[0-9]*)", command_output) - if len(ar)==0: + ar = re.findall( + "Movie-Aspect is ([0-9]+\.?[0-9]*:[0-9]+\.?[0-9]*)", + command_output) + if len(ar) == 0: return '16/9' if ar[0] == '1.78:1': return '16/9' @@ -426,58 +461,70 @@ def get_aspect_ratio (video_source_filename): return '4/3' return '16/9' #idh = re.findall("ID_VIDEO_HEIGHT=([0-9]+)", command_output) - #if len(idw)==0 or len(idh)==0: + # if len(idw)==0 or len(idh)==0: # print 'WARNING!' # print 'Could not get aspect ration. Assuming 1.78:1 (16/9).' # return 1.78 - #return float(idw[0])/float(idh[0]) -#ID_VIDEO_WIDTH=720 -#ID_VIDEO_HEIGHT=480 -#Movie-Aspect is 1.78:1 - prescaling to correct movie aspect. + # return float(idw[0])/float(idh[0]) +# ID_VIDEO_WIDTH=720 +# ID_VIDEO_HEIGHT=480 +# Movie-Aspect is 1.78:1 - prescaling to correct movie aspect. -def get_aid_list (video_source_filename): +def get_aid_list(video_source_filename): """This returns a list of audio ids in the source video file. TODO: Also extract ID_AID_nnn_LANG to associate language. Not all DVDs include this. """ cmd = "mplayer '%s' -vo null -ao null -frames 0 -identify" % video_source_filename (command_output, exitstatus) = run(cmd) - idl = re.findall("ID_AUDIO_ID=([0-9]+)", command_output) - idl.sort() + idl = sorted(re.findall("ID_AUDIO_ID=([0-9]+)", command_output)) return idl -def get_sid_list (video_source_filename): + +def get_sid_list(video_source_filename): """This returns a list of subtitle ids in the source video file. TODO: Also extract ID_SID_nnn_LANG to associate language. Not all DVDs include this. """ cmd = "mplayer '%s' -vo null -ao null -frames 0 -identify" % video_source_filename (command_output, exitstatus) = run(cmd) - idl = re.findall("ID_SUBTITLE_ID=([0-9]+)", command_output) - idl.sort() + idl = sorted(re.findall("ID_SUBTITLE_ID=([0-9]+)", command_output)) return idl - -def extract_audio (video_source_filename, audio_id=128, verbose_flag=0, dry_run_flag=0): + + +def extract_audio( + video_source_filename, + audio_id=128, + verbose_flag=0, + dry_run_flag=0): """This extracts the given audio_id track as raw uncompressed PCM from the given source video. Note that mplayer always saves this to audiodump.wav. At this time there is no way to set the output audio name. """ #cmd = "mplayer %(video_source_filename)s -vc null -vo null -aid %(audio_id)s -ao pcm:fast -noframedrop" % locals() cmd = "mplayer -quiet '%(video_source_filename)s' -vc dummy -vo null -aid %(audio_id)s -ao pcm:fast -noframedrop" % locals() - if verbose_flag: print cmd + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print -def extract_subtitles (video_source_filename, subtitle_id=0, verbose_flag=0, dry_run_flag=0): + +def extract_subtitles( + video_source_filename, + subtitle_id=0, + verbose_flag=0, + dry_run_flag=0): """This extracts the given subtitle_id track as VOBSUB format from the given source video. """ cmd = "mencoder -quiet '%(video_source_filename)s' -o /dev/null -nosound -ovc copy -vobsubout subtitles -vobsuboutindex 0 -sid %(subtitle_id)s" % locals() - if verbose_flag: print cmd + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print -def get_length (audio_raw_filename): + +def get_length(audio_raw_filename): """This attempts to get the length of the media file (length is time in seconds). This should not be confused with size (in bytes) of the file data. This is best used on a raw PCM AUDIO file because mplayer cannot get an accurate @@ -487,8 +534,7 @@ def get_length (audio_raw_filename): """ cmd = "mplayer %s -vo null -ao null -frames 0 -identify" % audio_raw_filename (command_output, exitstatus) = run(cmd) - idl = re.findall("ID_LENGTH=([0-9.]*)", command_output) - idl.sort() + idl = sorted(re.findall("ID_LENGTH=([0-9.]*)", command_output)) if len(idl) != 1: print "ERROR: cannot get length of raw audio file." print "command_output of mplayer identify:" @@ -498,11 +544,18 @@ def get_length (audio_raw_filename): return -1 return float(idl[0]) -def get_filesize (filename): + +def get_filesize(filename): """This returns the number of bytes a file takes on storage.""" return os.stat(filename)[stat.ST_SIZE] -def calc_video_bitrate (video_target_size, audio_bitrate, video_length, extra_space=0, dry_run_flag=0): + +def calc_video_bitrate( + video_target_size, + audio_bitrate, + video_length, + extra_space=0, + dry_run_flag=0): """This gives an estimate of the video bitrate necessary to fit the final target size. This will take into account room to fit the audio and extra space if given (for container overhead or whatnot). @@ -517,13 +570,15 @@ def calc_video_bitrate (video_target_size, audio_bitrate, video_length, extra_sp """ if dry_run_flag: return -1 - if extra_space is None: extra_space = 0 + if extra_space is None: + extra_space = 0 #audio_size = os.stat(audio_compressed_filename)[stat.ST_SIZE] audio_size = (audio_bitrate * video_length * 1000) / 8.0 video_target_size = video_target_size - audio_size - extra_space - return (int)(calc_video_kbitrate (video_target_size, video_length)) + return (int)(calc_video_kbitrate(video_target_size, video_length)) + -def calc_video_kbitrate (target_size, length_secs): +def calc_video_kbitrate(target_size, length_secs): """Given a target byte size free for video data, this returns the bitrate in kBit/S. For mencoder vbitrate 1 kBit = 1000 Bits -- not 1024 bits. target_size = bitrate * 1000 * length_secs / 8 @@ -532,18 +587,24 @@ def calc_video_kbitrate (target_size, length_secs): """ return int(target_size / (125.0 * length_secs)) -def crop_detect (video_source_filename, video_length, dry_run_flag=0): + +def crop_detect(video_source_filename, video_length, dry_run_flag=0): """This attempts to figure out the best crop for the given video file. Basically it runs crop detect for 10 seconds on five different places in the video. It picks the crop area that was most often detected. """ - skip = int(video_length/9) # offset to skip (-ss option in mencoder) + skip = int(video_length / 9) # offset to skip (-ss option in mencoder) sample_length = 10 - cmd1 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % (video_source_filename, skip, sample_length) - cmd2 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % (video_source_filename, 2*skip, sample_length) - cmd3 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % (video_source_filename, 4*skip, sample_length) - cmd4 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % (video_source_filename, 6*skip, sample_length) - cmd5 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % (video_source_filename, 8*skip, sample_length) + cmd1 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % ( + video_source_filename, skip, sample_length) + cmd2 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % ( + video_source_filename, 2 * skip, sample_length) + cmd3 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % ( + video_source_filename, 4 * skip, sample_length) + cmd4 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % ( + video_source_filename, 6 * skip, sample_length) + cmd5 = "mencoder '%s' -quiet -ss %d -endpos %d -o /dev/null -nosound -ovc lavc -vf cropdetect" % ( + video_source_filename, 8 * skip, sample_length) if dry_run_flag: return "0:0:0:0" (command_output1, exitstatus1) = run(cmd1) @@ -552,36 +613,61 @@ def crop_detect (video_source_filename, video_length, dry_run_flag=0): (command_output4, exitstatus4) = run(cmd4) (command_output5, exitstatus5) = run(cmd5) idl = re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output1) - idl = idl + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output2) - idl = idl + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output3) - idl = idl + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output4) - idl = idl + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output5) + idl = idl + \ + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output2) + idl = idl + \ + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output3) + idl = idl + \ + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output4) + idl = idl + \ + re.findall("-vf crop=([0-9]+:[0-9]+:[0-9]+:[0-9]+)", command_output5) items_count = count_unique(idl) return items_count[0][1] -def build_compression_command (video_source_filename, video_final_filename, video_target_size, audio_id=128, video_bitrate=1000, video_codec='mpeg4', audio_codec='mp3', video_fourcc_override='FMP4', video_gray_flag=0, video_crop_area=None, video_aspect_ratio='16/9', video_scale=None, video_encode_passes=2, video_deinterlace_flag=0, audio_volume_boost=None, audio_sample_rate=None, audio_bitrate=None, seek_skip=None, seek_length=None, video_chapter=None): -#Notes:For DVD, VCD, and SVCD use acodec=mp2 and vcodec=mpeg2video: -#mencoder movie.avi -o movie.VOB -ovc lavc -oac lavc -lavcopts acodec=mp2:abitrate=224:vcodec=mpeg2video:vbitrate=2000 +def build_compression_command( + video_source_filename, + video_final_filename, + video_target_size, + audio_id=128, + video_bitrate=1000, + video_codec='mpeg4', + audio_codec='mp3', + video_fourcc_override='FMP4', + video_gray_flag=0, + video_crop_area=None, + video_aspect_ratio='16/9', + video_scale=None, + video_encode_passes=2, + video_deinterlace_flag=0, + audio_volume_boost=None, + audio_sample_rate=None, + audio_bitrate=None, + seek_skip=None, + seek_length=None, + video_chapter=None): + # Notes:For DVD, VCD, and SVCD use acodec=mp2 and vcodec=mpeg2video: + # mencoder movie.avi -o movie.VOB -ovc lavc -oac lavc -lavcopts + # acodec=mp2:abitrate=224:vcodec=mpeg2video:vbitrate=2000 # - # build video filter (-vf) argument + # build video filter (-vf) argument # video_filter = '' - if video_crop_area and video_crop_area.lower()!='none': + if video_crop_area and video_crop_area.lower() != 'none': video_filter = video_filter + 'crop=%s' % video_crop_area if video_deinterlace_flag: if video_filter != '': video_filter = video_filter + ',' video_filter = video_filter + 'pp=md' - if video_scale and video_scale.lower()!='none': + if video_scale and video_scale.lower() != 'none': if video_filter != '': video_filter = video_filter + ',' video_filter = video_filter + 'scale=%s' % video_scale # optional video rotation -- were you holding your camera sideways? - #if video_filter != '': + # if video_filter != '': # video_filter = video_filter + ',' - #video_filter = video_filter + 'rotate=2' + #video_filter = video_filter + 'rotate=2' if video_filter != '': video_filter = '-vf ' + video_filter @@ -589,7 +675,7 @@ def build_compression_command (video_source_filename, video_final_filename, vide # build chapter argument # if video_chapter is not None: - chapter = '-chapter %d-%d' %(video_chapter,video_chapter) + chapter = '-chapter %d-%d' % (video_chapter, video_chapter) else: chapter = '' # chapter = '-chapter 2-2' @@ -601,15 +687,15 @@ def build_compression_command (video_source_filename, video_final_filename, vide if audio_sample_rate: if audio_filter != '': audio_filter = audio_filter + ',' - audio_filter = audio_filter + 'lavcresample=%s' % audio_sample_rate + audio_filter = audio_filter + 'lavcresample=%s' % audio_sample_rate if audio_volume_boost is not None: if audio_filter != '': audio_filter = audio_filter + ',' - audio_filter = audio_filter + 'volume=%0.1f:1'%audio_volume_boost + audio_filter = audio_filter + 'volume=%0.1f:1' % audio_volume_boost if audio_filter != '': audio_filter = '-af ' + audio_filter # - #if audio_sample_rate: + # if audio_sample_rate: # audio_filter = ('-srate %d ' % audio_sample_rate) + audio_filter # @@ -630,26 +716,164 @@ def build_compression_command (video_source_filename, video_final_filename, vide cmd = "mencoder -quiet -info comment='Arkivist' '%(video_source_filename)s' %(seek_filter)s %(chapter)s -aid %(audio_id)s -o '%(video_final_filename)s' -ffourcc %(video_fourcc_override)s -ovc lavc -oac mp3lame %(lavcopts)s %(video_filter)s %(audio_filter)s" % locals() return cmd -def compression_estimate (video_length, video_source_filename, video_final_filename, video_target_size, audio_id=128, video_bitrate=1000, video_codec='mpeg4', audio_codec='mp3', video_fourcc_override='FMP4', video_gray_flag=0, video_crop_area=None, video_aspect_ratio='16/9', video_scale=None, video_encode_passes=2, video_deinterlace_flag=0, audio_volume_boost=None, audio_sample_rate=None, audio_bitrate=None): + +def compression_estimate( + video_length, + video_source_filename, + video_final_filename, + video_target_size, + audio_id=128, + video_bitrate=1000, + video_codec='mpeg4', + audio_codec='mp3', + video_fourcc_override='FMP4', + video_gray_flag=0, + video_crop_area=None, + video_aspect_ratio='16/9', + video_scale=None, + video_encode_passes=2, + video_deinterlace_flag=0, + audio_volume_boost=None, + audio_sample_rate=None, + audio_bitrate=None): """This attempts to figure out the best compression ratio for a given set of compression options. """ # TODO Need to account for AVI overhead. - skip = int(video_length/9) # offset to skip (-ss option in mencoder) + skip = int(video_length / 9) # offset to skip (-ss option in mencoder) sample_length = 10 - cmd1 = build_compression_command (video_source_filename, "compression_test_1.avi", video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, skip, sample_length) - cmd2 = build_compression_command (video_source_filename, "compression_test_2.avi", video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, skip*2, sample_length) - cmd3 = build_compression_command (video_source_filename, "compression_test_3.avi", video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, skip*4, sample_length) - cmd4 = build_compression_command (video_source_filename, "compression_test_4.avi", video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, skip*6, sample_length) - cmd5 = build_compression_command (video_source_filename, "compression_test_5.avi", video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, skip*8, sample_length) + cmd1 = build_compression_command( + video_source_filename, + "compression_test_1.avi", + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + skip, + sample_length) + cmd2 = build_compression_command( + video_source_filename, + "compression_test_2.avi", + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + skip * 2, + sample_length) + cmd3 = build_compression_command( + video_source_filename, + "compression_test_3.avi", + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + skip * 4, + sample_length) + cmd4 = build_compression_command( + video_source_filename, + "compression_test_4.avi", + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + skip * 6, + sample_length) + cmd5 = build_compression_command( + video_source_filename, + "compression_test_5.avi", + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + skip * 8, + sample_length) run(cmd1) run(cmd2) run(cmd3) run(cmd4) run(cmd5) - size = get_filesize ("compression_test_1.avi")+get_filesize ("compression_test_2.avi")+get_filesize ("compression_test_3.avi")+get_filesize ("compression_test_4.avi")+get_filesize ("compression_test_5.avi") + size = get_filesize("compression_test_1.avi") + get_filesize("compression_test_2.avi") + get_filesize( + "compression_test_3.avi") + get_filesize("compression_test_4.avi") + get_filesize("compression_test_5.avi") return (size / 5.0) -def compress_video (video_source_filename, video_final_filename, video_target_size, audio_id=128, video_bitrate=1000, video_codec='mpeg4', audio_codec='mp3', video_fourcc_override='FMP4', video_gray_flag=0, video_crop_area=None, video_aspect_ratio='16/9', video_scale=None, video_encode_passes=2, video_deinterlace_flag=0, audio_volume_boost=None, audio_sample_rate=None, audio_bitrate=None, seek_skip=None, seek_length=None, video_chapter=None, verbose_flag=0, dry_run_flag=0): + +def compress_video( + video_source_filename, + video_final_filename, + video_target_size, + audio_id=128, + video_bitrate=1000, + video_codec='mpeg4', + audio_codec='mp3', + video_fourcc_override='FMP4', + video_gray_flag=0, + video_crop_area=None, + video_aspect_ratio='16/9', + video_scale=None, + video_encode_passes=2, + video_deinterlace_flag=0, + audio_volume_boost=None, + audio_sample_rate=None, + audio_bitrate=None, + seek_skip=None, + seek_length=None, + video_chapter=None, + verbose_flag=0, + dry_run_flag=0): """This compresses the video and audio of the given source video filename to the transcoded filename. This does a two-pass compression (I'm assuming mpeg4, I should probably make this smarter for other formats). """ @@ -658,18 +882,39 @@ def compress_video (video_source_filename, video_final_filename, video_target_si # #cmd = "mencoder -quiet '%(video_source_filename)s' -ss 65 -endpos 20 -aid %(audio_id)s -o '%(video_final_filename)s' -ffourcc %(video_fourcc_override)s -ovc lavc -oac lavc %(lavcopts)s %(video_filter)s %(audio_filter)s" % locals() - cmd = build_compression_command (video_source_filename, video_final_filename, video_target_size, audio_id, video_bitrate, video_codec, audio_codec, video_fourcc_override, video_gray_flag, video_crop_area, video_aspect_ratio, video_scale, video_encode_passes, video_deinterlace_flag, audio_volume_boost, audio_sample_rate, audio_bitrate, seek_skip, seek_length, video_chapter) - if verbose_flag: print cmd + cmd = build_compression_command( + video_source_filename, + video_final_filename, + video_target_size, + audio_id, + video_bitrate, + video_codec, + audio_codec, + video_fourcc_override, + video_gray_flag, + video_crop_area, + video_aspect_ratio, + video_scale, + video_encode_passes, + video_deinterlace_flag, + audio_volume_boost, + audio_sample_rate, + audio_bitrate, + seek_skip, + seek_length, + video_chapter) + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print # If not doing two passes then return early. - if video_encode_passes!='2': + if video_encode_passes != '2': return if verbose_flag: - video_actual_size = get_filesize (video_final_filename) + video_actual_size = get_filesize(video_final_filename) if video_actual_size > video_target_size: print "=======================================================" print "WARNING!" @@ -681,18 +926,27 @@ def compress_video (video_source_filename, video_final_filename, video_target_si # # do the second pass video compression # - cmd = cmd.replace ('vpass=1', 'vpass=2') - if verbose_flag: print cmd + cmd = cmd.replace('vpass=1', 'vpass=2') + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print return -def compress_audio (audio_raw_filename, audio_compressed_filename, audio_lowpass_filter=None, audio_sample_rate=None, audio_bitrate=None, verbose_flag=0, dry_run_flag=0): + +def compress_audio( + audio_raw_filename, + audio_compressed_filename, + audio_lowpass_filter=None, + audio_sample_rate=None, + audio_bitrate=None, + verbose_flag=0, + dry_run_flag=0): """This is depricated. This compresses the raw audio file to the compressed audio filename. """ - cmd = 'lame -h --athaa-sensitivity 1' # --cwlimit 11" + cmd = 'lame -h --athaa-sensitivity 1' # --cwlimit 11" if audio_lowpass_filter: cmd = cmd + ' --lowpass ' + audio_lowpass_filter if audio_bitrate: @@ -701,30 +955,62 @@ def compress_audio (audio_raw_filename, audio_compressed_filename, audio_lowpass if audio_sample_rate: cmd = cmd + ' --resample ' + audio_sample_rate cmd = cmd + ' ' + audio_raw_filename + ' ' + audio_compressed_filename - if verbose_flag: print cmd + if verbose_flag: + print cmd if not dry_run_flag: (command_output, exitstatus) = run(cmd) print if exitstatus != 0: raise Exception('ERROR: lame failed to compress raw audio file.') -def mux (video_final_filename, video_transcoded_filename, audio_compressed_filename, video_container_format, verbose_flag=0, dry_run_flag=0): + +def mux( + video_final_filename, + video_transcoded_filename, + audio_compressed_filename, + video_container_format, + verbose_flag=0, + dry_run_flag=0): """This is depricated. I used to use a three-pass encoding where I would mix the audio track separately, but this never worked very well (loss of audio sync).""" - if video_container_format.lower() == 'mkv': # Matroska - mux_mkv (video_final_filename, video_transcoded_filename, audio_compressed_filename, verbose_flag, dry_run_flag) + if video_container_format.lower() == 'mkv': # Matroska + mux_mkv( + video_final_filename, + video_transcoded_filename, + audio_compressed_filename, + verbose_flag, + dry_run_flag) if video_container_format.lower() == 'avi': - mux_avi (video_final_filename, video_transcoded_filename, audio_compressed_filename, verbose_flag, dry_run_flag) - -def mux_mkv (video_final_filename, video_transcoded_filename, audio_compressed_filename, verbose_flag=0, dry_run_flag=0): + mux_avi( + video_final_filename, + video_transcoded_filename, + audio_compressed_filename, + verbose_flag, + dry_run_flag) + + +def mux_mkv( + video_final_filename, + video_transcoded_filename, + audio_compressed_filename, + verbose_flag=0, + dry_run_flag=0): """This is depricated.""" - cmd = 'mkvmerge -o %s --noaudio %s %s' % (video_final_filename, video_transcoded_filename, audio_compressed_filename) - if verbose_flag: print cmd + cmd = 'mkvmerge -o %s --noaudio %s %s' % ( + video_final_filename, video_transcoded_filename, audio_compressed_filename) + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print -def mux_avi (video_final_filename, video_transcoded_filename, audio_compressed_filename, verbose_flag=0, dry_run_flag=0): + +def mux_avi( + video_final_filename, + video_transcoded_filename, + audio_compressed_filename, + verbose_flag=0, + dry_run_flag=0): """This is depricated.""" pass # cmd = "mencoder -quiet -oac copy -ovc copy -o '%s' -audiofile %s '%s'" % (video_final_filename, audio_compressed_filename, video_transcoded_filename) @@ -733,19 +1019,24 @@ def mux_avi (video_final_filename, video_transcoded_filename, audio_compressed_f # run(cmd) # print -def delete_tmp_files (audio_raw_filename, verbose_flag=0, dry_run_flag=0): + +def delete_tmp_files(audio_raw_filename, verbose_flag=0, dry_run_flag=0): global GLOBAL_LOGFILE_NAME - file_list = ' '.join([GLOBAL_LOGFILE_NAME, 'divx2pass.log', audio_raw_filename ]) + file_list = ' '.join( + [GLOBAL_LOGFILE_NAME, 'divx2pass.log', audio_raw_filename]) cmd = 'rm -f ' + file_list - if verbose_flag: print cmd + if verbose_flag: + print cmd if not dry_run_flag: run(cmd) print - + ############################################################################## # This is the interactive Q&A that is used if a conf file was not given. ############################################################################## -def interactive_convert (): + + +def interactive_convert(): global prompts, prompts_key_order @@ -755,10 +1046,10 @@ def interactive_convert (): print " Enter '?' at any question to get extra help." print "==============================================" print - - # Ask for the level of options the user wants. + + # Ask for the level of options the user wants. # A lot of code just to print a string! - level_sort = {0:'', 1:'', 2:''} + level_sort = {0: '', 1: '', 2: ''} for k in prompts: level = prompts[k][3] if level < 0 or level > 2: @@ -775,11 +1066,16 @@ def interactive_convert (): for k in prompts_key_order: if k == 'video_aspect_ratio': guess_aspect = get_aspect_ratio(options['video_source_filename']) - options[k] = input_option (prompts[k][1], guess_aspect, prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option( + prompts[k][1], + guess_aspect, + prompts[k][2], + prompts[k][3], + max_prompt_level) elif k == 'audio_id': - aid_list = get_aid_list (options['video_source_filename']) + aid_list = get_aid_list(options['video_source_filename']) default_id = '128' - if max_prompt_level>=prompts[k][3]: + if max_prompt_level >= prompts[k][3]: if len(aid_list) > 1: print "This video has more than one audio stream. The following stream audio IDs were found:" for aid in aid_list: @@ -791,11 +1087,16 @@ def interactive_convert (): print "If reading directly from a DVD then the DVD device might be busy." print "Using a default setting of stream id 128 (main audio on most DVDs)." default_id = '128' - options[k] = input_option (prompts[k][1], default_id, prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option( + prompts[k][1], + default_id, + prompts[k][2], + prompts[k][3], + max_prompt_level) elif k == 'subtitle_id': - sid_list = get_sid_list (options['video_source_filename']) + sid_list = get_sid_list(options['video_source_filename']) default_id = 'None' - if max_prompt_level>=prompts[k][3]: + if max_prompt_level >= prompts[k][3]: if len(sid_list) > 0: print "This video has one or more subtitle streams. The following stream subtitle IDs were found:" for sid in sid_list: @@ -807,24 +1108,45 @@ def interactive_convert (): print "Unable to get the list of subtitle streams from this video. It may have none." print "Setting default to None." default_id = 'None' - options[k] = input_option (prompts[k][1], default_id, prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option( + prompts[k][1], + default_id, + prompts[k][2], + prompts[k][3], + max_prompt_level) elif k == 'audio_lowpass_filter': - lowpass_default = "%.1f" % (math.floor(float(options['audio_sample_rate']) / 2.0)) - options[k] = input_option (prompts[k][1], lowpass_default, prompts[k][2], prompts[k][3], max_prompt_level) + lowpass_default = "%.1f" % (math.floor( + float(options['audio_sample_rate']) / 2.0)) + options[k] = input_option( + prompts[k][1], + lowpass_default, + prompts[k][2], + prompts[k][3], + max_prompt_level) elif k == 'video_bitrate': if options['video_length'].lower() == 'none': - options[k] = input_option (prompts[k][1], '1000', prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option(prompts[k][1], '1000', prompts[k][ + 2], prompts[k][3], max_prompt_level) else: - options[k] = input_option (prompts[k][1], prompts[k][0], prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option(prompts[k][1], prompts[k][0], prompts[ + k][2], prompts[k][3], max_prompt_level) else: - # don't bother asking for video_target_size or video_bitrate_overhead if video_bitrate was set - if (k=='video_target_size' or k=='video_bitrate_overhead') and options['video_bitrate']!='calc': + # don't bother asking for video_target_size or + # video_bitrate_overhead if video_bitrate was set + if (k == 'video_target_size' or k == 'video_bitrate_overhead') and options[ + 'video_bitrate'] != 'calc': continue # don't bother with crop area if video length is none - if k == 'video_crop_area' and options['video_length'].lower() == 'none': + if k == 'video_crop_area' and options[ + 'video_length'].lower() == 'none': options['video_crop_area'] = 'none' continue - options[k] = input_option (prompts[k][1], prompts[k][0], prompts[k][2], prompts[k][3], max_prompt_level) + options[k] = input_option( + prompts[k][1], + prompts[k][0], + prompts[k][2], + prompts[k][3], + max_prompt_level) #options['video_final_filename'] = options['video_final_filename'] + "." + options['video_container_format'] @@ -832,7 +1154,7 @@ def interactive_convert (): print "Ready to Rippy!" print print "The following options will be used:" - for k,v in options.iteritems(): + for k, v in options.iteritems(): print "%27s : %s" % (k, v) print @@ -843,7 +1165,8 @@ def interactive_convert (): os._exit(1) return options -def clean_options (d): + +def clean_options(d): """This validates and cleans up the options dictionary. After reading options interactively or from a conf file we need to make sure that the values make sense and are @@ -859,14 +1182,14 @@ def clean_options (d): d[k] = d[k].strip() # convert all flag options to 0 or 1 if '_flag' in k: - if type(d[k]) is types.StringType: - if d[k].strip().lower()[0] in 'yt1': #Yes, True, 1 + if isinstance(d[k], types.StringType): + if d[k].strip().lower()[0] in 'yt1': # Yes, True, 1 d[k] = 1 else: d[k] = 0 d['video_bitrate'] = d['video_bitrate'].lower() - if d['video_bitrate'][0]=='c': - d['video_bitrate']='calc' + if d['video_bitrate'][0] == 'c': + d['video_bitrate'] = 'calc' else: d['video_bitrate'] = int(float(d['video_bitrate'])) try: @@ -892,7 +1215,7 @@ def clean_options (d): d['subtitle_id'] = int(d['subtitle_id']) except: d['subtitle_id'] = None - + try: d['video_bitrate_overhead'] = float(d['video_bitrate_overhead']) except: @@ -901,45 +1224,47 @@ def clean_options (d): d['audio_bitrate'] = int(d['audio_bitrate']) d['audio_sample_rate'] = int(d['audio_sample_rate']) d['audio_volume_boost'] = d['audio_volume_boost'].lower() - if d['audio_volume_boost'][0]=='n': + if d['audio_volume_boost'][0] == 'n': d['audio_volume_boost'] = None else: - d['audio_volume_boost'] = d['audio_volume_boost'].replace('db','') + d['audio_volume_boost'] = d['audio_volume_boost'].replace('db', '') d['audio_volume_boost'] = float(d['audio_volume_boost']) # assert (d['video_bitrate']=='calc' and d['video_target_size']!='none') # or (d['video_bitrate']!='calc' and d['video_target_size']=='none') d['video_scale'] = d['video_scale'].lower() - if d['video_scale'][0]=='n': - d['video_scale']='none' + if d['video_scale'][0] == 'n': + d['video_scale'] = 'none' else: al = re.findall("([0-9]+).*?([0-9]+)", d['video_scale']) - d['video_scale']=al[0][0]+':'+al[0][1] + d['video_scale'] = al[0][0] + ':' + al[0][1] d['video_crop_area'] = d['video_crop_area'].lower() - if d['video_crop_area'][0]=='n': - d['video_crop_area']='none' + if d['video_crop_area'][0] == 'n': + d['video_crop_area'] = 'none' d['video_length'] = d['video_length'].lower() - if d['video_length'][0]=='c': - d['video_length']='calc' - elif d['video_length'][0]=='n': - d['video_length']='none' + if d['video_length'][0] == 'c': + d['video_length'] = 'calc' + elif d['video_length'][0] == 'n': + d['video_length'] = 'none' else: d['video_length'] = int(float(d['video_length'])) - if d['video_length']==0: + if d['video_length'] == 0: d['video_length'] = 'none' - assert (not (d['video_length']=='none' and d['video_bitrate']=='calc')) + assert (not (d['video_length'] == 'none' and d['video_bitrate'] == 'calc')) return d -def main (): + +def main(): try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?', ['help','h','?']) - except Exception, e: + optlist, args = getopt.getopt(sys.argv[1:], 'h?', ['help', 'h', '?']) + except Exception as e: print str(e) exit_with_usage() command_line_options = dict(optlist) # There are a million ways to cry for help. These are but a few of them. - if [elem for elem in command_line_options if elem in ['-h','--h','-?','--?','--help']]: + if [elem for elem in command_line_options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: exit_with_usage(0) missing = check_missing_requirements() @@ -959,16 +1284,21 @@ def main (): os._exit(1) if len(args) > 0: - # cute one-line string-to-dictionary parser (two-lines if you count this comment): - options = dict(re.findall('([^: \t\n]*)\s*:\s*(".*"|[^ \t\n]*)', file(args[0]).read())) + # cute one-line string-to-dictionary parser (two-lines if you count + # this comment): + options = dict( + re.findall( + '([^: \t\n]*)\s*:\s*(".*"|[^ \t\n]*)', + file( + args[0]).read())) options = clean_options(options) - convert (options) + convert(options) else: - options = interactive_convert () + options = interactive_convert() options = clean_options(options) - convert (options) + convert(options) print "# Done!" - + if __name__ == "__main__": try: start_time = time.time() @@ -977,7 +1307,7 @@ if __name__ == "__main__": print time.asctime() print "TOTAL TIME IN MINUTES:", print (time.time() - start_time) / 60.0 - except Exception, e: + except Exception as e: tb_dump = traceback.format_exc() print "==========================================================================" print "ERROR -- Unexpected exception in script." @@ -990,4 +1320,3 @@ if __name__ == "__main__": print >>GLOBAL_LOGFILE, str(tb_dump) print >>GLOBAL_LOGFILE, "==========================================================================" exit_with_usage(3) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/script.py b/lldb/third_party/Python/module/pexpect-2.4/examples/script.py index 908b91241a63..41e2ea814289 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/script.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/script.py @@ -18,33 +18,45 @@ Example: """ -import os, sys, time, getopt -import signal, fcntl, termios, struct +import os +import sys +import time +import getopt +import signal +import fcntl +import termios +import struct import traceback import pexpect -global_pexpect_instance = None # Used by signal handler +global_pexpect_instance = None # Used by signal handler + def exit_with_usage(): print globals()['__doc__'] os._exit(1) + def main(): ###################################################################### # Parse the options, arguments, get ready, etc. ###################################################################### try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?ac:', ['help','h','?']) - except Exception, e: + optlist, args = getopt.getopt( + sys.argv[ + 1:], 'h?ac:', [ + 'help', 'h', '?']) + except Exception as e: print str(e) exit_with_usage() options = dict(optlist) if len(args) > 1: exit_with_usage() - - if [elem for elem in options if elem in ['-h','--h','-?','--?','--help']]: + + if [elem for elem in options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: print "Help:" exit_with_usage() @@ -53,17 +65,17 @@ def main(): else: script_filename = "script.log" if '-a' in options: - fout = file (script_filename, "ab") + fout = file(script_filename, "ab") else: - fout = file (script_filename, "wb") + fout = file(script_filename, "wb") if '-c' in options: command = options['-c'] else: command = "sh" # Begin log with date/time in the form CCCCyymm.hhmmss - fout.write ('# %4d%02d%02d.%02d%02d%02d \n' % time.localtime()[:-3]) - + fout.write('# %4d%02d%02d.%02d%02d%02d \n' % time.localtime()[:-3]) + ###################################################################### # Start the interactive session ###################################################################### @@ -78,26 +90,26 @@ def main(): fout.close() return 0 -def sigwinch_passthrough (sig, data): + +def sigwinch_passthrough(sig, data): # Check for buggy platforms (see pexpect.setwinsize()). if 'TIOCGWINSZ' in dir(termios): TIOCGWINSZ = termios.TIOCGWINSZ else: - TIOCGWINSZ = 1074295912 # assume - s = struct.pack ("HHHH", 0, 0, 0, 0) - a = struct.unpack ('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ , s)) + TIOCGWINSZ = 1074295912 # assume + s = struct.pack("HHHH", 0, 0, 0, 0) + a = struct.unpack('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ, s)) global global_pexpect_instance - global_pexpect_instance.setwinsize(a[0],a[1]) + global_pexpect_instance.setwinsize(a[0], a[1]) if __name__ == "__main__": try: main() - except SystemExit, e: + except SystemExit as e: raise e - except Exception, e: + except Exception as e: print "ERROR" print str(e) traceback.print_exc() os._exit(1) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_session.py b/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_session.py index 4d0e228a7e33..222a72c16931 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_session.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_session.py @@ -5,10 +5,12 @@ # April 2003 # from pexpect import * -import os, sys +import os +import sys import getpass import time - + + class ssh_session: "Session with extra state including the password to be used." @@ -25,30 +27,29 @@ class ssh_session: '@@@@@@@@@@@@', 'Command not found.', EOF, - ] - - self.f = open('ssh.out','w') - + ] + + self.f = open('ssh.out', 'w') + def __repr__(self): - outl = 'class :'+self.__class__.__name__ + outl = 'class :' + self.__class__.__name__ for attr in self.__dict__: if attr == 'password': - outl += '\n\t'+attr+' : '+'*'*len(self.password) + outl += '\n\t' + attr + ' : ' + '*' * len(self.password) else: - outl += '\n\t'+attr+' : '+str(getattr(self, attr)) + outl += '\n\t' + attr + ' : ' + str(getattr(self, attr)) return outl def __exec(self, command): - "Execute a command on the remote host. Return the output." child = spawn(command, - #timeout=10, - ) + # timeout=10, + ) if self.verbose: sys.stderr.write("-> " + command + "\n") seen = child.expect(self.keys) - self.f.write(str(child.before) + str(child.after)+'\n') + self.f.write(str(child.before) + str(child.after) + '\n') if seen == 0: child.sendline('yes') seen = child.expect(self.keys) @@ -61,13 +62,13 @@ class ssh_session: # Added to allow the background running of remote process if not child.isalive(): seen = child.expect(self.keys) - if seen == 2: + if seen == 2: lines = child.readlines() self.f.write(lines) if self.verbose: sys.stderr.write("<- " + child.before + "|\n") try: - self.f.write(str(child.before) + str(child.after)+'\n') + self.f.write(str(child.before) + str(child.after) + '\n') except: pass self.f.close() @@ -75,20 +76,18 @@ class ssh_session: def ssh(self, command): - return self.__exec("ssh -l %s %s \"%s\"" \ - % (self.user,self.host,command)) + return self.__exec("ssh -l %s %s \"%s\"" + % (self.user, self.host, command)) def scp(self, src, dst): - return self.__exec("scp %s %s@%s:%s" \ - % (src, session.user, session.host, dst)) + return self.__exec("scp %s %s@%s:%s" + % (src, session.user, session.host, dst)) def exists(self, file): - "Retrieve file permissions of specified remote file." seen = self.ssh("/bin/ls -ld %s" % file) if string.find(seen, "No such file") > -1: - return None # File doesn't exist + return None # File doesn't exist else: - return seen.split()[0] # Return permission field of listing. - + return seen.split()[0] # Return permission field of listing. diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_tunnel.py b/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_tunnel.py index 3c8bc09514b4..ae1ce46faeeb 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_tunnel.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/ssh_tunnel.py @@ -23,50 +23,54 @@ host = raw_input('Hostname: ') user = raw_input('Username: ') X = getpass.getpass('Password: ') -def get_process_info (): - # This seems to work on both Linux and BSD, but should otherwise be considered highly UNportable. +def get_process_info(): - ps = pexpect.run ('ps ax -O ppid') + # This seems to work on both Linux and BSD, but should otherwise be + # considered highly UNportable. + + ps = pexpect.run('ps ax -O ppid') pass -def start_tunnel (): + + +def start_tunnel(): try: - ssh_tunnel = pexpect.spawn (tunnel_command % globals()) - ssh_tunnel.expect ('password:') - time.sleep (0.1) - ssh_tunnel.sendline (X) - time.sleep (60) # Cygwin is slow to update process status. - ssh_tunnel.expect (pexpect.EOF) + ssh_tunnel = pexpect.spawn(tunnel_command % globals()) + ssh_tunnel.expect('password:') + time.sleep(0.1) + ssh_tunnel.sendline(X) + time.sleep(60) # Cygwin is slow to update process status. + ssh_tunnel.expect(pexpect.EOF) except Exception, e: print str(e) -def main (): + +def main(): while True: - ps = pexpect.spawn ('ps') - time.sleep (1) - index = ps.expect (['/usr/bin/ssh', pexpect.EOF, pexpect.TIMEOUT]) + ps = pexpect.spawn('ps') + time.sleep(1) + index = ps.expect(['/usr/bin/ssh', pexpect.EOF, pexpect.TIMEOUT]) if index == 2: print 'TIMEOUT in ps command...' print str(ps) - time.sleep (13) + time.sleep(13) if index == 1: print time.asctime(), print 'restarting tunnel' - start_tunnel () - time.sleep (11) - print 'tunnel OK' + start_tunnel() + time.sleep(11) + print 'tunnel OK' else: # print 'tunnel OK' - time.sleep (7) + time.sleep(7) if __name__ == '__main__': - main () + main() # This was for older SSH versions that didn't have -f option #tunnel_command = 'ssh -C -n -L 25:%(host)s:25 -L 110:%(host)s:110 %(user)s@%(host)s -f nothing.sh' -#nothing_script = """#!/bin/sh -#while true; do sleep 53; done +# nothing_script = """#!/bin/sh +# while true; do sleep 53; done #""" - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/sshls.py b/lldb/third_party/Python/module/pexpect-2.4/examples/sshls.py index ef1ab9c23cd5..8e4909ac48c8 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/sshls.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/sshls.py @@ -7,10 +7,11 @@ $Id: sshls.py 489 2007-11-28 23:40:34Z noah $ """ import pexpect -import getpass, os +import getpass +import os -def ssh_command (user, host, password, command): +def ssh_command(user, host, password, command): """This runs a command on the remote host. This could also be done with the pxssh class, but this demonstrates what that class does at a simpler level. This returns a pexpect.spawn object. This handles the case when you try to @@ -18,39 +19,39 @@ connect to a new host and ssh asks you if you want to accept the public key fingerprint and continue connecting. """ ssh_newkey = 'Are you sure you want to continue connecting' - child = pexpect.spawn('ssh -l %s %s %s'%(user, host, command)) + child = pexpect.spawn('ssh -l %s %s %s' % (user, host, command)) i = child.expect([pexpect.TIMEOUT, ssh_newkey, 'password: ']) - if i == 0: # Timeout + if i == 0: # Timeout print 'ERROR!' print 'SSH could not login. Here is what SSH said:' print child.before, child.after return None - if i == 1: # SSH does not have the public key. Just accept it. - child.sendline ('yes') - child.expect ('password: ') + if i == 1: # SSH does not have the public key. Just accept it. + child.sendline('yes') + child.expect('password: ') i = child.expect([pexpect.TIMEOUT, 'password: ']) - if i == 0: # Timeout + if i == 0: # Timeout print 'ERROR!' print 'SSH could not login. Here is what SSH said:' print child.before, child.after - return None + return None child.sendline(password) return child -def main (): + +def main(): host = raw_input('Hostname: ') user = raw_input('User: ') password = getpass.getpass('Password: ') - child = ssh_command (user, host, password, '/bin/ls -l') + child = ssh_command(user, host, password, '/bin/ls -l') child.expect(pexpect.EOF) print child.before if __name__ == '__main__': try: main() - except Exception, e: + except Exception as e: print str(e) traceback.print_exc() os._exit(1) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/topip.py b/lldb/third_party/Python/module/pexpect-2.4/examples/topip.py index 5bd63e2ef224..498f9a3b5167 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/topip.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/topip.py @@ -46,21 +46,30 @@ Noah Spurrier $Id: topip.py 489 2007-11-28 23:40:34Z noah $ """ -import pexpect, pxssh # See http://pexpect.sourceforge.net/ -import os, sys, time, re, getopt, pickle, getpass, smtplib +import pexpect +import pxssh # See http://pexpect.sourceforge.net/ +import os +import sys +import time +import re +import getopt +import pickle +import getpass +import smtplib import traceback from pprint import pprint TOPIP_LOG_FILE = '/var/log/topip.log' TOPIP_LAST_RUN_STATS = '/var/run/topip.last' + def exit_with_usage(): print globals()['__doc__'] os._exit(1) -def stats(r): +def stats(r): """This returns a dict of the median, average, standard deviation, min and max of the given sequence. >>> from topip import stats @@ -75,30 +84,35 @@ def stats(r): """ total = sum(r) - avg = float(total)/float(len(r)) - sdsq = sum([(i-avg)**2 for i in r]) - s = list(r) - s.sort() - return dict(zip(['med', 'avg', 'stddev', 'min', 'max'] , (s[len(s)//2], avg, (sdsq/len(r))**.5, min(r), max(r)))) + avg = float(total) / float(len(r)) + sdsq = sum([(i - avg)**2 for i in r]) + s = sorted(r) + return dict(zip(['med', 'avg', 'stddev', 'min', 'max'], + (s[len(s) // 2], avg, (sdsq / len(r))**.5, min(r), max(r)))) -def send_alert (message, subject, addr_from, addr_to, smtp_server='localhost'): +def send_alert(message, subject, addr_from, addr_to, smtp_server='localhost'): """This sends an email alert. """ - message = 'From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n' % (addr_from, addr_to, subject) + message + message = 'From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n' % ( + addr_from, addr_to, subject) + message server = smtplib.SMTP(smtp_server) server.sendmail(addr_from, addr_to, message) server.quit() + def main(): ###################################################################### - ## Parse the options, arguments, etc. + # Parse the options, arguments, etc. ###################################################################### try: - optlist, args = getopt.getopt(sys.argv[1:], 'h?valqs:u:p:n:', ['help','h','?','ipv6','stddev=']) - except Exception, e: + optlist, args = getopt.getopt( + sys.argv[ + 1:], 'h?valqs:u:p:n:', [ + 'help', 'h', '?', 'ipv6', 'stddev=']) + except Exception as e: print str(e) exit_with_usage() options = dict(optlist) @@ -119,7 +133,8 @@ def main(): print args, len(args) return 0 exit_with_usage() - if [elem for elem in options if elem in ['-h','--h','-?','--?','--help']]: + if [elem for elem in options if elem in [ + '-h', '--h', '-?', '--?', '--help']]: print 'Help:' exit_with_usage() if '-s' in options: @@ -183,10 +198,11 @@ def main(): p.sendline('netstat -n -t') PROMPT = p.PROMPT - # loop through each matching netstat_pattern and put the ip address in the list. + # loop through each matching netstat_pattern and put the ip address in the + # list. ip_list = {} try: - while 1: + while True: i = p.expect([PROMPT, netstat_pattern]) if i == 0: break @@ -199,21 +215,25 @@ def main(): pass # remove a few common, uninteresting addresses from the dictionary. - ip_list = dict([ (key,value) for key,value in ip_list.items() if '192.168.' not in key]) - ip_list = dict([ (key,value) for key,value in ip_list.items() if '127.0.0.1' not in key]) + ip_list = dict([(key, value) + for key, value in ip_list.items() if '192.168.' not in key]) + ip_list = dict([(key, value) + for key, value in ip_list.items() if '127.0.0.1' not in key]) # sort dict by value (count) #ip_list = sorted(ip_list.iteritems(),lambda x,y:cmp(x[1], y[1]),reverse=True) ip_list = ip_list.items() if len(ip_list) < 1: - if verbose: print 'Warning: no networks connections worth looking at.' + if verbose: + print 'Warning: no networks connections worth looking at.' return 0 - ip_list.sort(lambda x,y:cmp(y[1],x[1])) + ip_list.sort(lambda x, y: cmp(y[1], x[1])) # generate some stats for the ip addresses found. if average_n <= 1: average_n = None - s = stats(zip(*ip_list[0:average_n])[1]) # The * unary operator treats the list elements as arguments + # The * unary operator treats the list elements as arguments + s = stats(zip(*ip_list[0:average_n])[1]) s['maxip'] = ip_list[0] # print munin-style or verbose results for the stats. @@ -223,33 +243,44 @@ def main(): print 'connections_stddev.value', s['stddev'] return 0 if verbose: - pprint (s) + pprint(s) print - pprint (ip_list[0:average_n]) + pprint(ip_list[0:average_n]) # load the stats from the last run. try: last_stats = pickle.load(file(TOPIP_LAST_RUN_STATS)) except: - last_stats = {'maxip':None} + last_stats = {'maxip': None} - if s['maxip'][1] > (s['stddev'] * stddev_trigger) and s['maxip']==last_stats['maxip']: - if verbose: print 'The maxip has been above trigger for two consecutive samples.' + if s['maxip'][1] > ( + s['stddev'] * + stddev_trigger) and s['maxip'] == last_stats['maxip']: + if verbose: + print 'The maxip has been above trigger for two consecutive samples.' if alert_flag: - if verbose: print 'SENDING ALERT EMAIL' - send_alert(str(s), 'ALERT on %s' % hostname, alert_addr_from, alert_addr_to) + if verbose: + print 'SENDING ALERT EMAIL' + send_alert( + str(s), + 'ALERT on %s' % + hostname, + alert_addr_from, + alert_addr_to) if log_flag: - if verbose: print 'LOGGING THIS EVENT' - fout = file(TOPIP_LOG_FILE,'a') + if verbose: + print 'LOGGING THIS EVENT' + fout = file(TOPIP_LOG_FILE, 'a') #dts = time.strftime('%Y:%m:%d:%H:%M:%S', time.localtime()) dts = time.asctime() - fout.write ('%s - %d connections from %s\n' % (dts,s['maxip'][1],str(s['maxip'][0]))) + fout.write('%s - %d connections from %s\n' % + (dts, s['maxip'][1], str(s['maxip'][0]))) fout.close() # save state to TOPIP_LAST_RUN_STATS try: - pickle.dump(s, file(TOPIP_LAST_RUN_STATS,'w')) - os.chmod (TOPIP_LAST_RUN_STATS, 0664) + pickle.dump(s, file(TOPIP_LAST_RUN_STATS, 'w')) + os.chmod(TOPIP_LAST_RUN_STATS, 0o664) except: pass # p.logout() @@ -258,10 +289,9 @@ if __name__ == '__main__': try: main() sys.exit(0) - except SystemExit, e: + except SystemExit as e: raise e - except Exception, e: + except Exception as e: print str(e) traceback.print_exc() os._exit(1) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/examples/uptime.py b/lldb/third_party/Python/module/pexpect-2.4/examples/uptime.py index f5018dfe0c18..65cfc6cd7110 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/examples/uptime.py +++ b/lldb/third_party/Python/module/pexpect-2.4/examples/uptime.py @@ -29,29 +29,30 @@ import re # 6:08PM up 4 days, 22:26, 1 user, load averages: 0.13, 0.09, 0.08 # This parses uptime output into the major groups using regex group matching. -p = pexpect.spawn ('uptime') -p.expect('up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])') +p = pexpect.spawn('uptime') +p.expect( + 'up\s+(.*?),\s+([0-9]+) users?,\s+load averages?: ([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9]),?\s+([0-9]+\.[0-9][0-9])') duration, users, av1, av5, av15 = p.match.groups() # The duration is a little harder to parse because of all the different # styles of uptime. I'm sure there is a way to do this all at once with # one single regex, but I bet it would be hard to read and maintain. -# If anyone wants to send me a version using a single regex I'd be happy to see it. +# If anyone wants to send me a version using a single regex I'd be happy +# to see it. days = '0' hours = '0' mins = '0' if 'day' in duration: - p.match = re.search('([0-9]+)\s+day',duration) + p.match = re.search('([0-9]+)\s+day', duration) days = str(int(p.match.group(1))) if ':' in duration: - p.match = re.search('([0-9]+):([0-9]+)',duration) + p.match = re.search('([0-9]+):([0-9]+)', duration) hours = str(int(p.match.group(1))) mins = str(int(p.match.group(2))) if 'min' in duration: - p.match = re.search('([0-9]+)\s+min',duration) + p.match = re.search('([0-9]+)\s+min', duration) mins = str(int(p.match.group(1))) # Print the parsed fields in CSV format. print 'days, hours, minutes, users, cpu avg 1 min, cpu avg 5 min, cpu avg 15 min' print '%s, %s, %s, %s, %s, %s, %s' % (days, hours, mins, users, av1, av5, av15) - diff --git a/lldb/third_party/Python/module/pexpect-2.4/fdpexpect.py b/lldb/third_party/Python/module/pexpect-2.4/fdpexpect.py index 0ece98e6b941..a3f49659d645 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/fdpexpect.py +++ b/lldb/third_party/Python/module/pexpect-2.4/fdpexpect.py @@ -9,58 +9,74 @@ import os __all__ = ['fdspawn'] + class fdspawn (spawn): """This is like pexpect.spawn but allows you to supply your own open file descriptor. For example, you could use it to read through a file looking for patterns, or to control a modem or serial device. """ - def __init__ (self, fd, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None): - + def __init__( + self, + fd, + args=[], + timeout=30, + maxread=2000, + searchwindowsize=None, + logfile=None): """This takes a file descriptor (an int) or an object that support the fileno() method (returning an int). All Python file-like objects support fileno(). """ - ### TODO: Add better handling of trying to use fdspawn in place of spawn - ### TODO: (overload to allow fdspawn to also handle commands as spawn does. + # TODO: Add better handling of trying to use fdspawn in place of spawn + # TODO: (overload to allow fdspawn to also handle commands as spawn + # does. - if type(fd) != type(0) and hasattr(fd, 'fileno'): + if not isinstance(fd, type(0)) and hasattr(fd, 'fileno'): fd = fd.fileno() - if type(fd) != type(0): - raise ExceptionPexpect ('The fd argument is not an int. If this is a command string then maybe you want to use pexpect.spawn.') + if not isinstance(fd, type(0)): + raise ExceptionPexpect( + 'The fd argument is not an int. If this is a command string then maybe you want to use pexpect.spawn.') - try: # make sure fd is a valid file descriptor + try: # make sure fd is a valid file descriptor os.fstat(fd) except OSError: - raise ExceptionPexpect, 'The fd argument is not a valid file descriptor.' + raise ExceptionPexpect( + 'The fd argument is not a valid file descriptor.') self.args = None self.command = None - spawn.__init__(self, None, args, timeout, maxread, searchwindowsize, logfile) + spawn.__init__( + self, + None, + args, + timeout, + maxread, + searchwindowsize, + logfile) self.child_fd = fd self.own_fd = False self.closed = False self.name = '<file descriptor %d>' % fd - def __del__ (self): + def __del__(self): return - def close (self): + def close(self): if self.child_fd == -1: return if self.own_fd: - self.close (self) + self.close(self) else: self.flush() os.close(self.child_fd) self.child_fd = -1 self.closed = True - def isalive (self): - + def isalive(self): """This checks if the file descriptor is still valid. If os.fstat() does not raise an exception then we assume it is alive. """ @@ -72,11 +88,11 @@ class fdspawn (spawn): except: return False - def terminate (self, force=False): + def terminate(self, force=False): - raise ExceptionPexpect ('This method is not valid for file descriptors.') + raise ExceptionPexpect( + 'This method is not valid for file descriptors.') - def kill (self, sig): + def kill(self, sig): return - diff --git a/lldb/third_party/Python/module/pexpect-2.4/pexpect.py b/lldb/third_party/Python/module/pexpect-2.4/pexpect.py index 0bb0a84c1415..4b7d94f7a025 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/pexpect.py +++ b/lldb/third_party/Python/module/pexpect-2.4/pexpect.py @@ -65,7 +65,9 @@ $Id: pexpect.py 516 2008-05-23 20:46:01Z noah $ """ try: - import os, sys, time + import os + import sys + import time import select import string import re @@ -79,7 +81,7 @@ try: import errno import traceback import signal -except ImportError, e: +except ImportError as e: raise ImportError (str(e) + """ A critical module was not found. Probably this operating system does not @@ -88,9 +90,11 @@ support it. Pexpect is intended for UNIX-like operating systems.""") __version__ = '2.4' __revision__ = '$Revision: 516 $' __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which', - 'split_command_line', '__version__', '__revision__'] + 'split_command_line', '__version__', '__revision__'] # Exception classes used by this module. + + class ExceptionPexpect(Exception): """Base class for all exceptions raised by this module. @@ -105,7 +109,6 @@ class ExceptionPexpect(Exception): return str(self.value) def get_trace(self): - """This returns an abbreviated stack trace with lines that only concern the caller. In other words, the stack trace inside the Pexpect module is not included. """ @@ -117,7 +120,6 @@ class ExceptionPexpect(Exception): return ''.join(tblist) def __filter_not_pexpect(self, trace_list_item): - """This returns True if list item 0 the string 'pexpect.py' in it. """ if trace_list_item[0].find('pexpect.py') == -1: @@ -125,25 +127,35 @@ class ExceptionPexpect(Exception): else: return False + class EOF(ExceptionPexpect): """Raised when EOF is read from a child. This usually means the child has exited.""" + class TIMEOUT(ExceptionPexpect): """Raised when a read time exceeds the timeout. """ -##class TIMEOUT_PATTERN(TIMEOUT): -## """Raised when the pattern match time exceeds the timeout. -## This is different than a read TIMEOUT because the child process may -## give output, thus never give a TIMEOUT, but the output -## may never match a pattern. -## """ -##class MAXBUFFER(ExceptionPexpect): +# class TIMEOUT_PATTERN(TIMEOUT): +# """Raised when the pattern match time exceeds the timeout. +# This is different than a read TIMEOUT because the child process may +# give output, thus never give a TIMEOUT, but the output +# may never match a pattern. +# """ +# class MAXBUFFER(ExceptionPexpect): ## """Raised when a scan buffer fills before matching an expected pattern.""" -def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None, logfile=None, cwd=None, env=None): +def run( + command, + timeout=-1, + withexitstatus=False, + events=None, + extra_args=None, + logfile=None, + cwd=None, + env=None): """ This function runs the given command; waits for it to finish; then returns all output as a string. STDERR is included in output. If the full @@ -219,25 +231,31 @@ def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None if timeout == -1: child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env) else: - child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile, cwd=cwd, env=env) + child = spawn( + command, + timeout=timeout, + maxread=2000, + logfile=logfile, + cwd=cwd, + env=env) if events is not None: patterns = events.keys() responses = events.values() else: - patterns=None # We assume that EOF or TIMEOUT will save us. - responses=None + patterns = None # We assume that EOF or TIMEOUT will save us. + responses = None child_result_list = [] event_count = 0 - while 1: + while True: try: - index = child.expect (patterns) + index = child.expect(patterns) if type(child.after) in types.StringTypes: child_result_list.append(child.before + child.after) - else: # child.after may have been a TIMEOUT or EOF, so don't cat those. + else: # child.after may have been a TIMEOUT or EOF, so don't cat those. child_result_list.append(child.before) if type(responses[index]) in types.StringTypes: child.send(responses[index]) - elif type(responses[index]) is types.FunctionType: + elif isinstance(responses[index], types.FunctionType): callback_result = responses[index](locals()) sys.stdout.flush() if type(callback_result) in types.StringTypes: @@ -245,12 +263,13 @@ def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None elif callback_result: break else: - raise TypeError ('The callback must be a string or function type.') + raise TypeError( + 'The callback must be a string or function type.') event_count = event_count + 1 - except TIMEOUT, e: + except TIMEOUT as e: child_result_list.append(child.before) break - except EOF, e: + except EOF as e: child_result_list.append(child.before) break child_result = ''.join(child_result_list) @@ -260,13 +279,22 @@ def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None else: return child_result + class spawn (object): """This is the main class interface for Pexpect. Use this class to start and control child applications. """ - def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None): - + def __init__( + self, + command, + args=[], + timeout=30, + maxread=2000, + searchwindowsize=None, + logfile=None, + cwd=None, + env=None): """This is the constructor. The command parameter may be a string that includes a command and any arguments to the command. For example:: @@ -337,12 +365,12 @@ class spawn (object): the input from the child and output sent to the child. Sometimes you don't want to see everything you write to the child. You only want to log what the child sends back. For example:: - + child = pexpect.spawn('some_command') child.logfile_read = sys.stdout To separately log output sent to the child use logfile_send:: - + self.logfile_send = fout The delaybeforesend helps overcome a weird behavior that many users @@ -391,46 +419,56 @@ class spawn (object): self.terminated = True self.exitstatus = None self.signalstatus = None - self.status = None # status returned by os.waitpid + self.status = None # status returned by os.waitpid self.flag_eof = False self.pid = None - self.child_fd = -1 # initially closed + self.child_fd = -1 # initially closed self.timeout = timeout self.delimiter = EOF self.logfile = logfile - self.logfile_read = None # input from child (read_nonblocking) - self.logfile_send = None # output to send (send, sendline) - self.maxread = maxread # max bytes to read at one time into buffer - self.buffer = '' # This is the read buffer. See maxread. - self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched. - # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms). - self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds. - self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds. - self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds. - self.softspace = False # File-like object. - self.name = '<' + repr(self) + '>' # File-like object. - self.encoding = None # File-like object. - self.closed = True # File-like object. + self.logfile_read = None # input from child (read_nonblocking) + self.logfile_send = None # output to send (send, sendline) + self.maxread = maxread # max bytes to read at one time into buffer + self.buffer = '' # This is the read buffer. See maxread. + # Anything before searchwindowsize point is preserved, but not + # searched. + self.searchwindowsize = searchwindowsize + # Most Linux machines don't like delaybeforesend to be below 0.03 (30 + # ms). + # Sets sleep time used just before sending data to child. Time in + # seconds. + self.delaybeforesend = 0.05 + # Sets delay in close() method to allow kernel time to update process + # status. Time in seconds. + self.delayafterclose = 0.1 + # Sets delay in terminate() method to allow kernel time to update + # process status. Time in seconds. + self.delayafterterminate = 0.1 + self.softspace = False # File-like object. + self.name = '<' + repr(self) + '>' # File-like object. + self.encoding = None # File-like object. + self.closed = True # File-like object. self.cwd = cwd self.env = env - self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix + # This flags if we are running on irix + self.__irix_hack = (sys.platform.lower().find('irix') >= 0) # Solaris uses internal __fork_pty(). All others use pty.fork(). - if (sys.platform.lower().find('solaris')>=0) or (sys.platform.lower().find('sunos5')>=0): + if (sys.platform.lower().find('solaris') >= 0) or ( + sys.platform.lower().find('sunos5') >= 0): self.use_native_pty_fork = False else: self.use_native_pty_fork = True - - # allow dummy instances for subclasses that may not use command or args. + # allow dummy instances for subclasses that may not use command or + # args. if command is None: self.command = None self.args = None self.name = '<pexpect factory incomplete>' else: - self._spawn (command, args) + self._spawn(command, args) def __del__(self): - """This makes sure that no system resources are left open. Python only garbage collects Python objects. OS file descriptors are not Python objects, so they must be handled explicitly. If the child file @@ -448,7 +486,6 @@ class spawn (object): pass def __str__(self): - """This returns a human-readable string that represents the state of the object. """ @@ -481,8 +518,7 @@ class spawn (object): s.append('delayafterterminate: ' + str(self.delayafterterminate)) return '\n'.join(s) - def _spawn(self,command,args=[]): - + def _spawn(self, command, args=[]): """This starts the given command in a child process. This does all the fork/exec type of stuff for a pty. This is called by __init__. If args is empty then command will be parsed (split on spaces) and args will be @@ -498,27 +534,30 @@ class spawn (object): # that performs some task; creates no stdout output; and then dies. # If command is an int type then it may represent a file descriptor. - if type(command) == type(0): - raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.') + if isinstance(command, type(0)): + raise ExceptionPexpect( + 'Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.') - if type (args) != type([]): - raise TypeError ('The argument, args, must be a list.') + if not isinstance(args, type([])): + raise TypeError('The argument, args, must be a list.') if args == []: self.args = split_command_line(command) self.command = self.args[0] else: - self.args = args[:] # work with a copy - self.args.insert (0, command) + self.args = args[:] # work with a copy + self.args.insert(0, command) self.command = command command_with_path = which(self.command) if command_with_path is None: - raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command) + raise ExceptionPexpect( + 'The command was not found or was not executable: %s.' % + self.command) self.command = command_with_path self.args[0] = self.command - self.name = '<' + ' '.join (self.args) + '>' + self.name = '<' + ' '.join(self.args) + '>' assert self.pid is None, 'The pid member should be None.' assert self.command is not None, 'The command member should not be None.' @@ -526,14 +565,14 @@ class spawn (object): if self.use_native_pty_fork: try: self.pid, self.child_fd = pty.fork() - except OSError, e: + except OSError as e: raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e)) - else: # Use internal __fork_pty + else: # Use internal __fork_pty self.pid, self.child_fd = self.__fork_pty() - if self.pid == 0: # Child + if self.pid == 0: # Child try: - self.child_fd = sys.stdout.fileno() # used by setwinsize() + self.child_fd = sys.stdout.fileno() # used by setwinsize() self.setwinsize(24, 80) except: # Some platforms do not like setwinsize (Cygwin). @@ -543,9 +582,9 @@ class spawn (object): pass # Do not allow child to inherit open file descriptors from parent. max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0] - for i in range (3, max_fd): + for i in range(3, max_fd): try: - os.close (i) + os.close(i) except OSError: pass @@ -566,7 +605,6 @@ class spawn (object): self.closed = False def __fork_pty(self): - """This implements a substitute for the forkpty system call. This should be more portable than the pty.fork() function. Specifically, this should work on Solaris. @@ -582,11 +620,12 @@ class spawn (object): parent_fd, child_fd = os.openpty() if parent_fd < 0 or child_fd < 0: - raise ExceptionPexpect, "Error! Could not open pty with os.openpty()." + raise ExceptionPexpect( + "Error! Could not open pty with os.openpty().") pid = os.fork() if pid < 0: - raise ExceptionPexpect, "Error! Failed os.fork()." + raise ExceptionPexpect("Error! Failed os.fork().") elif pid == 0: # Child. os.close(parent_fd) @@ -605,7 +644,6 @@ class spawn (object): return pid, parent_fd def __pty_make_controlling_tty(self, tty_fd): - """This makes the pseudo-terminal the controlling tty. This should be more portable than the pty.fork() function. Specifically, this should work on Solaris. """ @@ -614,7 +652,7 @@ class spawn (object): # Disconnect from controlling tty if still connected. try: - fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY); + fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY) if fd >= 0: os.close(fd) except: @@ -625,37 +663,38 @@ class spawn (object): # Verify we are disconnected from controlling tty try: - fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY); + fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY) if fd >= 0: os.close(fd) - raise ExceptionPexpect, "Error! We are not disconnected from a controlling tty." + raise ExceptionPexpect( + "Error! We are not disconnected from a controlling tty.") except: # Good! We are disconnected from a controlling tty. pass # Verify we can open child pty. - fd = os.open(child_name, os.O_RDWR); + fd = os.open(child_name, os.O_RDWR) if fd < 0: - raise ExceptionPexpect, "Error! Could not open child pty, " + child_name + raise ExceptionPexpect( + "Error! Could not open child pty, " + child_name) else: os.close(fd) # Verify we now have a controlling tty. fd = os.open("/dev/tty", os.O_WRONLY) if fd < 0: - raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty" + raise ExceptionPexpect( + "Error! Could not open controlling tty, /dev/tty") else: os.close(fd) - def fileno (self): # File-like object. - + def fileno(self): # File-like object. """This returns the file descriptor of the pty for the child. """ return self.child_fd - def close (self, force=True): # File-like object. - + def close(self, force=True): # File-like object. """This closes the connection with the child application. Note that calling close() more than once is valid. This emulates standard Python behavior with files. Set force to True if you want to make sure that @@ -664,31 +703,30 @@ class spawn (object): if not self.closed: self.flush() - os.close (self.child_fd) - time.sleep(self.delayafterclose) # Give kernel time to update process status. + os.close(self.child_fd) + # Give kernel time to update process status. + time.sleep(self.delayafterclose) if self.isalive(): if not self.terminate(force): - raise ExceptionPexpect ('close() could not terminate the child using terminate()') + raise ExceptionPexpect( + 'close() could not terminate the child using terminate()') self.child_fd = -1 self.closed = True #self.pid = None - def flush (self): # File-like object. - + def flush(self): # File-like object. """This does nothing. It is here to support the interface for a File-like object. """ pass - def isatty (self): # File-like object. - + def isatty(self): # File-like object. """This returns True if the file descriptor is open and connected to a tty(-like) device, else False. """ return os.isatty(self.child_fd) - def waitnoecho (self, timeout=-1): - + def waitnoecho(self, timeout=-1): """This waits until the terminal ECHO flag is set False. This returns True if the echo mode is off. This returns False if the ECHO flag was not set False before the timeout. This can be used to detect when the @@ -709,7 +747,7 @@ class spawn (object): if timeout == -1: timeout = self.timeout if timeout is not None: - end_time = time.time() + timeout + end_time = time.time() + timeout while True: if not self.getecho(): return True @@ -719,8 +757,7 @@ class spawn (object): timeout = end_time - time.time() time.sleep(0.1) - def getecho (self): - + def getecho(self): """This returns the terminal echo mode. This returns True if echo is on or False if echo is off. Child applications that are expecting you to enter a password often set ECHO False. See waitnoecho(). """ @@ -730,8 +767,7 @@ class spawn (object): return True return False - def setecho (self, state): - + def setecho(self, state): """This sets the terminal echo mode on or off. Note that anything the child sent before the echo will be lost, so you should be sure that your input buffer is empty before you call setecho(). For example, the @@ -768,11 +804,11 @@ class spawn (object): else: attr[3] = attr[3] & ~termios.ECHO # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent - # and blocked on some platforms. TCSADRAIN is probably ideal if it worked. + # and blocked on some platforms. TCSADRAIN is probably ideal if it + # worked. termios.tcsetattr(self.child_fd, termios.TCSANOW, attr) - def read_nonblocking (self, size = 1, timeout = -1): - + def read_nonblocking(self, size=1, timeout=-1): """This reads at most size characters from the child application. It includes a timeout. If the read does not complete within the timeout period then a TIMEOUT exception is raised. If the end of file is read @@ -794,7 +830,8 @@ class spawn (object): implement the timeout. """ if self.closed: - raise ValueError ('I/O operation on closed file in read_nonblocking().') + raise ValueError( + 'I/O operation on closed file in read_nonblocking().') if timeout == -1: timeout = self.timeout @@ -805,52 +842,60 @@ class spawn (object): # For this case, I test isalive() before doing any reading. # If isalive() is false, then I pretend that this is the same as EOF. if not self.isalive(): - r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll" + # timeout of 0 means "poll" + r, w, e = self.__select([self.child_fd], [], [], 0) if not r: self.flag_eof = True - raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.') + raise EOF( + 'End Of File (EOF) in read_nonblocking(). Braindead platform.') elif self.__irix_hack: # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive. - # This adds a 2 second delay, but only when the child is terminated. + # This adds a 2 second delay, but only when the child is + # terminated. r, w, e = self.__select([self.child_fd], [], [], 2) if not r and not self.isalive(): self.flag_eof = True - raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.') + raise EOF( + 'End Of File (EOF) in read_nonblocking(). Pokey platform.') - r,w,e = self.__select([self.child_fd], [], [], timeout) + r, w, e = self.__select([self.child_fd], [], [], timeout) if not r: if not self.isalive(): # Some platforms, such as Irix, will claim that their processes are alive; - # then timeout on the select; and then finally admit that they are not alive. + # then timeout on the select; and then finally admit that they + # are not alive. self.flag_eof = True - raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.') + raise EOF( + 'End of File (EOF) in read_nonblocking(). Very pokey platform.') else: - raise TIMEOUT ('Timeout exceeded in read_nonblocking().') + raise TIMEOUT('Timeout exceeded in read_nonblocking().') if self.child_fd in r: try: s = os.read(self.child_fd, size) - except OSError, e: # Linux does this + except OSError as e: # Linux does this self.flag_eof = True - raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.') - if s == '': # BSD style + raise EOF( + 'End Of File (EOF) in read_nonblocking(). Exception style platform.') + if s == '': # BSD style self.flag_eof = True - raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.') + raise EOF( + 'End Of File (EOF) in read_nonblocking(). Empty string style platform.') if self.logfile is not None: - self.logfile.write (s) + self.logfile.write(s) self.logfile.flush() if self.logfile_read is not None: - self.logfile_read.write (s) + self.logfile_read.write(s) self.logfile_read.flush() return s - raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().') - - def read (self, size = -1): # File-like object. + raise ExceptionPexpect( + 'Reached an unexpected state in read_nonblocking().') + def read(self, size=-1): # File-like object. """This reads at most "size" bytes from the file (less if the read hits EOF before obtaining size bytes). If the size argument is negative or omitted, read all data until EOF is reached. The bytes are returned as @@ -860,7 +905,7 @@ class spawn (object): if size == 0: return '' if size < 0: - self.expect (self.delimiter) # delimiter default is EOF + self.expect(self.delimiter) # delimiter default is EOF return self.before # I could have done this more directly by not using expect(), but @@ -871,13 +916,12 @@ class spawn (object): # Note, it's OK if size==-1 in the regex. That just means it # will never match anything in which case we stop only on EOF. cre = re.compile('.{%d}' % size, re.DOTALL) - index = self.expect ([cre, self.delimiter]) # delimiter default is EOF + index = self.expect([cre, self.delimiter]) # delimiter default is EOF if index == 0: - return self.after ### self.before should be ''. Should I assert this? + return self.after # self.before should be ''. Should I assert this? return self.before - def readline (self, size = -1): # File-like object. - + def readline(self, size=-1): # File-like object. """This reads and returns one entire line. A trailing newline is kept in the string, but may be absent when a file ends with an incomplete line. Note: This readline() looks for a \\r\\n pair even on UNIX @@ -889,21 +933,20 @@ class spawn (object): if size == 0: return '' - index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF + # delimiter default is EOF + index = self.expect(['\r\n', self.delimiter]) if index == 0: return self.before + '\r\n' else: return self.before - def __iter__ (self): # File-like object. - + def __iter__(self): # File-like object. """This is to support iterators over a file-like object. """ return self - def next (self): # File-like object. - + def next(self): # File-like object. """This is to support iterators over a file-like object. """ @@ -912,8 +955,7 @@ class spawn (object): raise StopIteration return result - def readlines (self, sizehint = -1): # File-like object. - + def readlines(self, sizehint=-1): # File-like object. """This reads until EOF using readline() and returns a list containing the lines thus read. The optional "sizehint" argument is ignored. """ @@ -926,49 +968,44 @@ class spawn (object): return lines def write(self, s): # File-like object. - """This is similar to send() except that there is no return value. """ - self.send (s) - - def writelines (self, sequence): # File-like object. + self.send(s) + def writelines(self, sequence): # File-like object. """This calls write() for each element in the sequence. The sequence can be any iterable object producing strings, typically a list of strings. This does not add line separators There is no return value. """ for s in sequence: - self.write (s) + self.write(s) def send(self, s): - """This sends a string to the child process. This returns the number of bytes written. If a log file was set then the data is also written to the log. """ time.sleep(self.delaybeforesend) if self.logfile is not None: - self.logfile.write (s) + self.logfile.write(s) self.logfile.flush() if self.logfile_send is not None: - self.logfile_send.write (s) + self.logfile_send.write(s) self.logfile_send.flush() c = os.write(self.child_fd, s) return c def sendline(self, s=''): - """This is like send(), but it adds a line feed (os.linesep). This returns the number of bytes written. """ n = self.send(s) - n = n + self.send (os.linesep) + n = n + self.send(os.linesep) return n def sendcontrol(self, char): - """This sends a control character to the child such as Ctrl-C or Ctrl-D. For example, to send a Ctrl-G (ASCII 7):: @@ -979,22 +1016,21 @@ class spawn (object): char = char.lower() a = ord(char) - if a>=97 and a<=122: + if a >= 97 and a <= 122: a = a - ord('a') + 1 - return self.send (chr(a)) - d = {'@':0, '`':0, - '[':27, '{':27, - '\\':28, '|':28, - ']':29, '}': 29, - '^':30, '~':30, - '_':31, - '?':127} + return self.send(chr(a)) + d = {'@': 0, '`': 0, + '[': 27, '{': 27, + '\\': 28, '|': 28, + ']': 29, '}': 29, + '^': 30, '~': 30, + '_': 31, + '?': 127} if char not in d: return 0 - return self.send (chr(d[char])) + return self.send(chr(d[char])) def sendeof(self): - """This sends an EOF to the child. This sends a character which causes the pending parent output buffer to be sent to the waiting child program without waiting for end-of-line. If it is the first character @@ -1004,21 +1040,21 @@ class spawn (object): It is the responsibility of the caller to ensure the eof is sent at the beginning of a line. """ - ### Hmmm... how do I send an EOF? - ###C if ((m = write(pty, *buf, p - *buf)) < 0) - ###C return (errno == EWOULDBLOCK) ? n : -1; + # Hmmm... how do I send an EOF? + # C if ((m = write(pty, *buf, p - *buf)) < 0) + # C return (errno == EWOULDBLOCK) ? n : -1; #fd = sys.stdin.fileno() - #old = termios.tcgetattr(fd) # remember current state + # old = termios.tcgetattr(fd) # remember current state #attr = termios.tcgetattr(fd) - #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF - #try: # use try/finally to ensure state gets restored + # attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF + # try: # use try/finally to ensure state gets restored # termios.tcsetattr(fd, termios.TCSADRAIN, attr) # if hasattr(termios, 'CEOF'): # os.write (self.child_fd, '%c' % termios.CEOF) # else: # # Silly platform does not define CEOF so assume CTRL-D # os.write (self.child_fd, '%c' % 4) - #finally: # restore state + # finally: # restore state # termios.tcsetattr(fd, termios.TCSADRAIN, old) if hasattr(termios, 'VEOF'): char = termios.tcgetattr(self.child_fd)[6][termios.VEOF] @@ -1028,7 +1064,6 @@ class spawn (object): self.send(char) def sendintr(self): - """This sends a SIGINT to the child. It does not require the SIGINT to be the first character on a line. """ @@ -1037,17 +1072,15 @@ class spawn (object): else: # platform does not define VINTR so assume CTRL-C char = chr(3) - self.send (char) - - def eof (self): + self.send(char) + def eof(self): """This returns True if the EOF exception was ever raised. """ return self.flag_eof def terminate(self, force=False): - """This forces a child process to terminate. It starts nicely with SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This returns True if the child was terminated. This returns False if the @@ -1076,7 +1109,7 @@ class spawn (object): else: return False return False - except OSError, e: + except OSError as e: # I think there are kernel timing issues that sometimes cause # this to happen. I think isalive() reports True, but the # process is dead to the kernel. @@ -1088,7 +1121,6 @@ class spawn (object): return False def wait(self): - """This waits until the child exits. This is a blocking call. This will not read any data from the child, so this will block forever if the child has unread output and has terminated. In other words, the child @@ -1098,24 +1130,24 @@ class spawn (object): if self.isalive(): pid, status = os.waitpid(self.pid, 0) else: - raise ExceptionPexpect ('Cannot wait for dead child process.') + raise ExceptionPexpect('Cannot wait for dead child process.') self.exitstatus = os.WEXITSTATUS(status) - if os.WIFEXITED (status): + if os.WIFEXITED(status): self.status = status self.exitstatus = os.WEXITSTATUS(status) self.signalstatus = None self.terminated = True - elif os.WIFSIGNALED (status): + elif os.WIFSIGNALED(status): self.status = status self.exitstatus = None self.signalstatus = os.WTERMSIG(status) self.terminated = True - elif os.WIFSTOPPED (status): - raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?') + elif os.WIFSTOPPED(status): + raise ExceptionPexpect( + 'Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?') return self.exitstatus def isalive(self): - """This tests if the child process is running or not. This is non-blocking. If the child was terminated then this will read the exitstatus or signalstatus of the child. This returns True if the child @@ -1135,9 +1167,10 @@ class spawn (object): try: pid, status = os.waitpid(self.pid, waitpid_options) - except OSError, e: # No child processes + except OSError as e: # No child processes if e[0] == errno.ECHILD: - raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?') + raise ExceptionPexpect( + 'isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?') else: raise e @@ -1146,39 +1179,42 @@ class spawn (object): # report, and the value of status is undefined. if pid == 0: try: - pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris! - except OSError, e: # This should never happen... + pid, status = os.waitpid( + self.pid, waitpid_options) # os.WNOHANG) # Solaris! + except OSError as e: # This should never happen... if e[0] == errno.ECHILD: - raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?') + raise ExceptionPexpect( + 'isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?') else: raise e # If pid is still 0 after two calls to waitpid() then # the process really is alive. This seems to work on all platforms, except # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking - # take care of this situation (unfortunately, this requires waiting through the timeout). + # take care of this situation (unfortunately, this requires waiting + # through the timeout). if pid == 0: return True if pid == 0: return True - if os.WIFEXITED (status): + if os.WIFEXITED(status): self.status = status self.exitstatus = os.WEXITSTATUS(status) self.signalstatus = None self.terminated = True - elif os.WIFSIGNALED (status): + elif os.WIFSIGNALED(status): self.status = status self.exitstatus = None self.signalstatus = os.WTERMSIG(status) self.terminated = True - elif os.WIFSTOPPED (status): - raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?') + elif os.WIFSTOPPED(status): + raise ExceptionPexpect( + 'isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?') return False def kill(self, sig): - """This sends the given signal to the child application. In keeping with UNIX tradition it has a misleading name. It does not necessarily kill the child unless you send the right signal. """ @@ -1188,7 +1224,6 @@ class spawn (object): os.kill(self.pid, sig) def compile_pattern_list(self, patterns): - """This compiles a pattern-string or a list of pattern-strings. Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of those. Patterns may also be None which results in an empty list (you @@ -1214,10 +1249,10 @@ class spawn (object): if patterns is None: return [] - if type(patterns) is not types.ListType: + if not isinstance(patterns, types.ListType): patterns = [patterns] - compile_flags = re.DOTALL # Allow dot to match \n + compile_flags = re.DOTALL # Allow dot to match \n if self.ignorecase: compile_flags = compile_flags | re.IGNORECASE compiled_pattern_list = [] @@ -1228,15 +1263,16 @@ class spawn (object): compiled_pattern_list.append(EOF) elif p is TIMEOUT: compiled_pattern_list.append(TIMEOUT) - elif type(p) is type(re.compile('')): + elif isinstance(p, type(re.compile(''))): compiled_pattern_list.append(p) else: - raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p))) + raise TypeError( + 'Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str( + type(p))) return compiled_pattern_list - def expect(self, pattern, timeout = -1, searchwindowsize=-1): - + def expect(self, pattern, timeout=-1, searchwindowsize=-1): """This seeks through the stream until a pattern is matched. The pattern is overloaded and may take several types. The pattern can be a StringType, EOF, a compiled re, or a list of any of those types. @@ -1313,10 +1349,12 @@ class spawn (object): """ compiled_pattern_list = self.compile_pattern_list(pattern) - return self.expect_list(compiled_pattern_list, timeout, searchwindowsize) - - def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1): + return self.expect_list( + compiled_pattern_list, + timeout, + searchwindowsize) + def expect_list(self, pattern_list, timeout=-1, searchwindowsize=-1): """This takes a list of compiled regular expressions and returns the index into the pattern_list that matched the child output. The list may also contain EOF or TIMEOUT (which are not compiled regular @@ -1327,10 +1365,12 @@ class spawn (object): the self.timeout value is used. If searchwindowsize==-1 then the self.searchwindowsize value is used. """ - return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize) - - def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1): + return self.expect_loop( + searcher_re(pattern_list), + timeout, + searchwindowsize) + def expect_exact(self, pattern_list, timeout=-1, searchwindowsize=-1): """This is similar to expect(), but uses plain string matching instead of compiled regular expressions in 'pattern_list'. The 'pattern_list' may be a string; a list or other sequence of strings; or TIMEOUT and @@ -1343,12 +1383,15 @@ class spawn (object): 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 or pattern_list in (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) - - def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1): + return self.expect_loop( + searcher_string(pattern_list), + timeout, + searchwindowsize) + def expect_loop(self, searcher, timeout=-1, searchwindowsize=-1): """This is the common loop used inside expect. The 'searcher' should be an instance of searcher_re or searcher_string, which describes how and what to search for in the input. @@ -1360,33 +1403,33 @@ class spawn (object): if timeout == -1: timeout = self.timeout if timeout is not None: - end_time = time.time() + timeout + end_time = time.time() + timeout if searchwindowsize == -1: searchwindowsize = self.searchwindowsize try: incoming = self.buffer freshlen = len(incoming) - while True: # Keep reading until exception or return. + while True: # Keep reading until exception or return. index = searcher.search(incoming, freshlen, searchwindowsize) if index >= 0: - self.buffer = incoming[searcher.end : ] - self.before = incoming[ : searcher.start] - self.after = incoming[searcher.start : searcher.end] + self.buffer = incoming[searcher.end:] + self.before = incoming[: searcher.start] + self.after = incoming[searcher.start: searcher.end] self.match = searcher.match self.match_index = index return self.match_index # No match at this point if timeout < 0 and timeout is not None: - raise TIMEOUT ('Timeout exceeded in expect_any().') + raise TIMEOUT('Timeout exceeded in expect_any().') # Still have time left, so read more data - c = self.read_nonblocking (self.maxread, timeout) + c = self.read_nonblocking(self.maxread, timeout) freshlen = len(c) - time.sleep (0.0001) + time.sleep(0.0001) incoming = incoming + c if timeout is not None: timeout = end_time - time.time() - except EOF, e: + except EOF as e: self.buffer = '' self.before = incoming self.after = EOF @@ -1398,8 +1441,8 @@ class spawn (object): else: self.match = None self.match_index = None - raise EOF (str(e) + '\n' + str(self)) - except TIMEOUT, e: + raise EOF(str(e) + '\n' + str(self)) + except TIMEOUT as e: self.buffer = incoming self.before = incoming self.after = TIMEOUT @@ -1411,7 +1454,7 @@ class spawn (object): else: self.match = None self.match_index = None - raise TIMEOUT (str(e) + '\n' + str(self)) + raise TIMEOUT(str(e) + '\n' + str(self)) except: self.before = incoming self.after = None @@ -1420,17 +1463,15 @@ class spawn (object): raise def getwinsize(self): - """This returns the terminal window size of the child tty. The return value is a tuple of (rows, cols). """ - TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L) + TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912) s = struct.pack('HHHH', 0, 0, 0, 0) x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s) return struct.unpack('HHHH', x)[0:2] def setwinsize(self, r, c): - """This sets the terminal window size of the child tty. This will cause a SIGWINCH signal to be sent to the child. This does not change the physical window size. It changes the size reported to TTY-aware @@ -1446,8 +1487,11 @@ class spawn (object): s = struct.pack('HHHH', r, c, 0, 0) fcntl.ioctl(self.fileno(), TIOCSWINSZ, s) - def interact(self, escape_character = chr(29), input_filter = None, output_filter = None): - + def interact( + self, + escape_character=chr(29), + input_filter=None, + output_filter=None): """This gives control of the child process to the interactive user (the human at the keyboard). Keystrokes are sent to the child process, and the stdout and stderr output of the child process is printed. This @@ -1482,7 +1526,7 @@ class spawn (object): """ # Flush the buffer. - self.stdout.write (self.buffer) + self.stdout.write(self.buffer) self.stdout.flush() self.buffer = '' mode = tty.tcgetattr(self.STDIN_FILENO) @@ -1493,7 +1537,6 @@ class spawn (object): tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode) def __interact_writen(self, fd, data): - """This is used by the interact() method. """ @@ -1502,29 +1545,33 @@ class spawn (object): data = data[n:] def __interact_read(self, fd): - """This is used by the interact() method. """ return os.read(fd, 1000) - def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None): - + def __interact_copy( + self, + escape_character=None, + input_filter=None, + output_filter=None): """This is used by the interact() method. """ while self.isalive(): - r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], []) + r, w, e = self.__select([self.child_fd, self.STDIN_FILENO], [], []) if self.child_fd in r: data = self.__interact_read(self.child_fd) - if output_filter: data = output_filter(data) + if output_filter: + data = output_filter(data) if self.logfile is not None: - self.logfile.write (data) + self.logfile.write(data) self.logfile.flush() os.write(self.STDOUT_FILENO, data) if self.STDIN_FILENO in r: data = self.__interact_read(self.STDIN_FILENO) - if input_filter: data = input_filter(data) + if input_filter: + data = input_filter(data) i = data.rfind(escape_character) if i != -1: data = data[:i] @@ -1532,8 +1579,7 @@ class spawn (object): break self.__interact_writen(self.child_fd, data) - def __select (self, iwtd, owtd, ewtd, timeout=None): - + def __select(self, iwtd, owtd, ewtd, timeout=None): """This is a wrapper around select.select() that ignores signals. If select.select raises a select.error exception and errno is an EINTR error then it is ignored. Mainly this is used to ignore sigwinch @@ -1545,38 +1591,40 @@ class spawn (object): end_time = time.time() + timeout while True: try: - return select.select (iwtd, owtd, ewtd, timeout) - except select.error, e: + return select.select(iwtd, owtd, ewtd, timeout) + except select.error as e: if e[0] == errno.EINTR: - # if we loop back we have to subtract the amount of time we already waited. + # if we loop back we have to subtract the amount of time we + # already waited. if timeout is not None: timeout = end_time - time.time() if timeout < 0: - return ([],[],[]) - else: # something else caused the select.error, so this really is an exception + return ([], [], []) + else: # something else caused the select.error, so this really is an exception raise ############################################################################## # The following methods are no longer supported or allowed. - def setmaxread (self, maxread): - + def setmaxread(self, maxread): """This method is no longer supported or allowed. I don't like getters and setters without a good reason. """ - raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.') - - def setlog (self, fileobject): + raise ExceptionPexpect( + 'This method is no longer supported or allowed. Just assign a value to the maxread member variable.') + def setlog(self, fileobject): """This method is no longer supported or allowed. """ - raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.') + raise ExceptionPexpect( + 'This method is no longer supported or allowed. Just assign a value to the logfile member variable.') ############################################################################## # End of spawn class ############################################################################## + class searcher_string (object): """This is a plain string search helper for the spawn.expect_any() method. @@ -1595,7 +1643,6 @@ class searcher_string (object): """ def __init__(self, strings): - """This creates an instance of searcher_string. This argument 'strings' may be a list; a sequence of strings; or the EOF or TIMEOUT types. """ @@ -1612,22 +1659,23 @@ class searcher_string (object): self._strings.append((n, s)) def __str__(self): - """This returns a human-readable string that represents the state of the object.""" - ss = [ (ns[0],' %d: "%s"' % ns) for ns in self._strings ] - ss.append((-1,'searcher_string:')) + ss = [(ns[0], ' %d: "%s"' % ns) for ns in self._strings] + ss.append((-1, 'searcher_string:')) if self.eof_index >= 0: - ss.append ((self.eof_index,' %d: EOF' % self.eof_index)) + ss.append((self.eof_index, ' %d: EOF' % self.eof_index)) if self.timeout_index >= 0: - ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index)) + ss.append( + (self.timeout_index, + ' %d: TIMEOUT' % + self.timeout_index)) ss.sort() ss = zip(*ss)[1] return '\n'.join(ss) def search(self, buffer, freshlen, searchwindowsize=None): - """This searches 'buffer' for the first occurence of one of the search strings. 'freshlen' must indicate the number of bytes at the end of 'buffer' which have not been searched before. It helps to avoid @@ -1652,12 +1700,12 @@ class searcher_string (object): # rescanning until we've read three more bytes. # # Sadly, I don't know enough about this interesting topic. /grahn - + for index, s in self._strings: if searchwindowsize is None: # the match, if any, can only be in the fresh data, # or at the very end of the old data - offset = -(freshlen+len(s)) + offset = -(freshlen + len(s)) else: # better obey searchwindowsize offset = -searchwindowsize @@ -1672,6 +1720,7 @@ class searcher_string (object): self.end = self.start + len(self.match) return best_index + class searcher_re (object): """This is regular expression string search helper for the @@ -1692,7 +1741,6 @@ class searcher_re (object): """ def __init__(self, patterns): - """This creates an instance that searches for 'patterns' Where 'patterns' may be a list or other sequence of compiled regular expressions, or the EOF or TIMEOUT types.""" @@ -1710,28 +1758,30 @@ class searcher_re (object): self._searches.append((n, s)) def __str__(self): - """This returns a human-readable string that represents the state of the object.""" - ss = [ (n,' %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches] - ss.append((-1,'searcher_re:')) + ss = [(n, ' %d: re.compile("%s")' % (n, str(s.pattern))) + for n, s in self._searches] + ss.append((-1, 'searcher_re:')) if self.eof_index >= 0: - ss.append ((self.eof_index,' %d: EOF' % self.eof_index)) + ss.append((self.eof_index, ' %d: EOF' % self.eof_index)) if self.timeout_index >= 0: - ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index)) + ss.append( + (self.timeout_index, + ' %d: TIMEOUT' % + self.timeout_index)) ss.sort() ss = zip(*ss)[1] return '\n'.join(ss) def search(self, buffer, freshlen, searchwindowsize=None): - """This searches 'buffer' for the first occurence of one of the regular expressions. 'freshlen' must indicate the number of bytes at the end of 'buffer' which have not been searched before. See class spawn for the 'searchwindowsize' argument. - + If there is a match this returns the index of that string, and sets 'start', 'end' and 'match'. Otherwise, returns -1.""" @@ -1742,7 +1792,7 @@ class searcher_re (object): if searchwindowsize is None: searchstart = 0 else: - searchstart = max(0, len(buffer)-searchwindowsize) + searchstart = max(0, len(buffer) - searchwindowsize) for index, s in self._searches: match = s.search(buffer, searchstart) if match is None: @@ -1759,18 +1809,18 @@ class searcher_re (object): self.end = self.match.end() return best_index -def which (filename): +def which(filename): """This takes a given filename; tries to find it in the environment path; then checks if it is executable. This returns the full path to the filename if found and executable. Otherwise this returns None.""" # Special case where filename already contains a path. if os.path.dirname(filename) != '': - if os.access (filename, os.X_OK): + if os.access(filename, os.X_OK): return filename - if not os.environ.has_key('PATH') or os.environ['PATH'] == '': + if 'PATH' not in os.environ or os.environ['PATH'] == '': p = os.defpath else: p = os.environ['PATH'] @@ -1778,7 +1828,7 @@ def which (filename): # Oddly enough this was the one line that made Pexpect # incompatible with Python 1.5.2. #pathlist = p.split (os.pathsep) - pathlist = string.split (p, os.pathsep) + pathlist = string.split(p, os.pathsep) for path in pathlist: f = os.path.join(path, filename) @@ -1786,8 +1836,8 @@ def which (filename): return f return None -def split_command_line(command_line): +def split_command_line(command_line): """This splits a command line into a list of arguments. It splits arguments on spaces, but handles embedded quotes, doublequotes, and escaped characters. It's impossible to do this with a regular expression, so I @@ -1801,21 +1851,21 @@ def split_command_line(command_line): state_esc = 1 state_singlequote = 2 state_doublequote = 3 - state_whitespace = 4 # The state of consuming whitespace between commands. + state_whitespace = 4 # The state of consuming whitespace between commands. state = state_basic for c in command_line: if state == state_basic or state == state_whitespace: - if c == '\\': # Escape the next character + if c == '\\': # Escape the next character state = state_esc - elif c == r"'": # Handle single quote + elif c == r"'": # Handle single quote state = state_singlequote - elif c == r'"': # Handle double quote + elif c == r'"': # Handle double quote state = state_doublequote elif c.isspace(): # Add arg to arg_list if we aren't in the middle of whitespace. if state == state_whitespace: - None # Do nothing. + None # Do nothing. else: arg_list.append(arg) arg = '' diff --git a/lldb/third_party/Python/module/pexpect-2.4/pxssh.py b/lldb/third_party/Python/module/pexpect-2.4/pxssh.py index 04ba25cbff5b..59db8d2a31e4 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/pxssh.py +++ b/lldb/third_party/Python/module/pexpect-2.4/pxssh.py @@ -11,10 +11,13 @@ import time __all__ = ['ExceptionPxssh', 'pxssh'] # Exception classes used by this module. + + class ExceptionPxssh(ExceptionPexpect): """Raised for pxssh exceptions. """ + class pxssh (spawn): """This class extends pexpect.spawn to specialize setting up SSH @@ -30,10 +33,10 @@ class pxssh (spawn): shells. Example that runs a few commands on a remote server and prints the result:: - + import pxssh import getpass - try: + try: s = pxssh.pxssh() hostname = raw_input('hostname: ') username = raw_input('username: ') @@ -70,19 +73,34 @@ class pxssh (spawn): s.login (hostname, username, password) """ - def __init__ (self, timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None): - spawn.__init__(self, None, timeout=timeout, maxread=maxread, searchwindowsize=searchwindowsize, logfile=logfile, cwd=cwd, env=env) + def __init__( + self, + timeout=30, + maxread=2000, + searchwindowsize=None, + logfile=None, + cwd=None, + env=None): + spawn.__init__( + self, + None, + timeout=timeout, + maxread=maxread, + searchwindowsize=searchwindowsize, + logfile=logfile, + cwd=cwd, + env=env) self.name = '<pxssh>' - - #SUBTLE HACK ALERT! Note that the command to set the prompt uses a - #slightly different string than the regular expression to match it. This - #is because when you set the prompt the command will echo back, but we - #don't want to match the echoed command. So if we make the set command - #slightly different than the regex we eliminate the problem. To make the - #set command different we add a backslash in front of $. The $ doesn't - #need to be escaped, but it doesn't hurt and serves to make the set - #prompt command different than the regex. + + # SUBTLE HACK ALERT! Note that the command to set the prompt uses a + # slightly different string than the regular expression to match it. This + # is because when you set the prompt the command will echo back, but we + # don't want to match the echoed command. So if we make the set command + # slightly different than the regex we eliminate the problem. To make the + # set command different we add a backslash in front of $. The $ doesn't + # need to be escaped, but it doesn't hurt and serves to make the set + # prompt command different than the regex. # used to match the command-line prompt self.UNIQUE_PROMPT = "\[PEXPECT\][\$\#] " @@ -98,30 +116,28 @@ class pxssh (spawn): # Unsetting SSH_ASKPASS on the remote side doesn't disable it! Annoying! #self.SSH_OPTS = "-x -o'RSAAuthentication=no' -o 'PubkeyAuthentication=no'" self.force_password = False - self.auto_prompt_reset = True - - def levenshtein_distance(self, a,b): + self.auto_prompt_reset = True + def levenshtein_distance(self, a, b): """This calculates the Levenshtein distance between a and b. """ n, m = len(a), len(b) if n > m: - a,b = b,a - n,m = m,n - current = range(n+1) - for i in range(1,m+1): - previous, current = current, [i]+[0]*n - for j in range(1,n+1): - add, delete = previous[j]+1, current[j-1]+1 - change = previous[j-1] - if a[j-1] != b[i-1]: + a, b = b, a + n, m = m, n + current = range(n + 1) + for i in range(1, m + 1): + previous, current = current, [i] + [0] * n + for j in range(1, n + 1): + add, delete = previous[j] + 1, current[j - 1] + 1 + change = previous[j - 1] + if a[j - 1] != b[i - 1]: change = change + 1 current[j] = min(add, delete, change) return current[n] - def sync_original_prompt (self): - + def sync_original_prompt(self): """This attempts to find the prompt. Basically, press enter and record the response; press enter again and record the response; if the two responses are similar then assume we are at the original prompt. This @@ -133,33 +149,42 @@ class pxssh (spawn): # If latency is worse than these values then this will fail. try: - self.read_nonblocking(size=10000,timeout=1) # GAS: Clear out the cache before getting the prompt + # GAS: Clear out the cache before getting the prompt + self.read_nonblocking(size=10000, timeout=1) except TIMEOUT: pass time.sleep(0.1) self.sendline() time.sleep(0.5) - x = self.read_nonblocking(size=1000,timeout=1) + x = self.read_nonblocking(size=1000, timeout=1) time.sleep(0.1) self.sendline() time.sleep(0.5) - a = self.read_nonblocking(size=1000,timeout=1) + a = self.read_nonblocking(size=1000, timeout=1) time.sleep(0.1) self.sendline() time.sleep(0.5) - b = self.read_nonblocking(size=1000,timeout=1) - ld = self.levenshtein_distance(a,b) + b = self.read_nonblocking(size=1000, timeout=1) + ld = self.levenshtein_distance(a, b) len_a = len(a) if len_a == 0: return False - if float(ld)/len_a < 0.4: + if float(ld) / len_a < 0.4: return True return False - ### TODO: This is getting messy and I'm pretty sure this isn't perfect. - ### TODO: I need to draw a flow chart for this. - def login (self,server,username,password='',terminal_type='ansi',original_prompt=r"[#$]",login_timeout=10,port=None,auto_prompt_reset=True): - + # TODO: This is getting messy and I'm pretty sure this isn't perfect. + # TODO: I need to draw a flow chart for this. + def login( + self, + server, + username, + password='', + terminal_type='ansi', + original_prompt=r"[#$]", + login_timeout=10, + port=None, + auto_prompt_reset=True): """This logs the user into the given server. It uses the 'original_prompt' to try to find the prompt right after login. When it finds the prompt it immediately tries to reset the prompt to something @@ -175,7 +200,7 @@ class pxssh (spawn): to guess when we have reached the prompt. Then we hope for the best and blindly try to reset the prompt to something more unique. If that fails then login() raises an ExceptionPxssh exception. - + In some situations it is not possible or desirable to reset the original prompt. In this case, set 'auto_prompt_reset' to False to inhibit setting the prompt to the UNIQUE_PROMPT. Remember that pxssh @@ -187,88 +212,120 @@ class pxssh (spawn): if self.force_password: ssh_options = ssh_options + ' ' + self.SSH_OPTS if port is not None: - ssh_options = ssh_options + ' -p %s'%(str(port)) + ssh_options = ssh_options + ' -p %s' % (str(port)) cmd = "ssh %s -l %s %s" % (ssh_options, username, server) # This does not distinguish between a remote server 'password' prompt # and a local ssh 'passphrase' prompt (for unlocking a private key). spawn._spawn(self, cmd) - i = self.expect(["(?i)are you sure you want to continue connecting", original_prompt, "(?i)(?:password)|(?:passphrase for key)", "(?i)permission denied", "(?i)terminal type", TIMEOUT, "(?i)connection closed by remote host"], timeout=login_timeout) + i = self.expect( + [ + "(?i)are you sure you want to continue connecting", + original_prompt, + "(?i)(?:password)|(?:passphrase for key)", + "(?i)permission denied", + "(?i)terminal type", + TIMEOUT, + "(?i)connection closed by remote host"], + timeout=login_timeout) # First phase - if i==0: + if i == 0: # New certificate -- always accept it. # This is what you get if SSH does not have the remote host's # public key stored in the 'known_hosts' cache. self.sendline("yes") - i = self.expect(["(?i)are you sure you want to continue connecting", original_prompt, "(?i)(?:password)|(?:passphrase for key)", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) - if i==2: # password or passphrase + i = self.expect( + [ + "(?i)are you sure you want to continue connecting", + original_prompt, + "(?i)(?:password)|(?:passphrase for key)", + "(?i)permission denied", + "(?i)terminal type", + TIMEOUT]) + if i == 2: # password or passphrase self.sendline(password) - i = self.expect(["(?i)are you sure you want to continue connecting", original_prompt, "(?i)(?:password)|(?:passphrase for key)", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) - if i==4: + i = self.expect( + [ + "(?i)are you sure you want to continue connecting", + original_prompt, + "(?i)(?:password)|(?:passphrase for key)", + "(?i)permission denied", + "(?i)terminal type", + TIMEOUT]) + if i == 4: self.sendline(terminal_type) - i = self.expect(["(?i)are you sure you want to continue connecting", original_prompt, "(?i)(?:password)|(?:passphrase for key)", "(?i)permission denied", "(?i)terminal type", TIMEOUT]) + i = self.expect( + [ + "(?i)are you sure you want to continue connecting", + original_prompt, + "(?i)(?:password)|(?:passphrase for key)", + "(?i)permission denied", + "(?i)terminal type", + TIMEOUT]) # Second phase - if i==0: + if i == 0: # This is weird. This should not happen twice in a row. self.close() - raise ExceptionPxssh ('Weird error. Got "are you sure" prompt twice.') - elif i==1: # can occur if you have a public key pair set to authenticate. - ### TODO: May NOT be OK if expect() got tricked and matched a false prompt. + raise ExceptionPxssh( + 'Weird error. Got "are you sure" prompt twice.') + elif i == 1: # can occur if you have a public key pair set to authenticate. + # TODO: May NOT be OK if expect() got tricked and matched a false + # prompt. pass - elif i==2: # password prompt again + elif i == 2: # password prompt again # For incorrect passwords, some ssh servers will # ask for the password again, others return 'denied' right away. # If we get the password prompt again then this means - # we didn't get the password right the first time. + # we didn't get the password right the first time. self.close() - raise ExceptionPxssh ('password refused') - elif i==3: # permission denied -- password was bad. + raise ExceptionPxssh('password refused') + elif i == 3: # permission denied -- password was bad. self.close() - raise ExceptionPxssh ('permission denied') - elif i==4: # terminal type again? WTF? + raise ExceptionPxssh('permission denied') + elif i == 4: # terminal type again? WTF? self.close() - raise ExceptionPxssh ('Weird error. Got "terminal type" prompt twice.') - elif i==5: # Timeout - #This is tricky... I presume that we are at the command-line prompt. - #It may be that the shell prompt was so weird that we couldn't match - #it. Or it may be that we couldn't log in for some other reason. I - #can't be sure, but it's safe to guess that we did login because if - #I presume wrong and we are not logged in then this should be caught - #later when I try to set the shell prompt. + raise ExceptionPxssh( + 'Weird error. Got "terminal type" prompt twice.') + elif i == 5: # Timeout + # This is tricky... I presume that we are at the command-line prompt. + # It may be that the shell prompt was so weird that we couldn't match + # it. Or it may be that we couldn't log in for some other reason. I + # can't be sure, but it's safe to guess that we did login because if + # I presume wrong and we are not logged in then this should be caught + # later when I try to set the shell prompt. pass - elif i==6: # Connection closed by remote host + elif i == 6: # Connection closed by remote host self.close() - raise ExceptionPxssh ('connection closed') - else: # Unexpected + raise ExceptionPxssh('connection closed') + else: # Unexpected self.close() - raise ExceptionPxssh ('unexpected login response') + raise ExceptionPxssh('unexpected login response') if not self.sync_original_prompt(): self.close() - raise ExceptionPxssh ('could not synchronize with original prompt') + raise ExceptionPxssh('could not synchronize with original prompt') # We appear to be in. # set shell prompt to something unique. if auto_prompt_reset: if not self.set_unique_prompt(): self.close() - raise ExceptionPxssh ('could not set shell prompt\n'+self.before) + raise ExceptionPxssh( + 'could not set shell prompt\n' + self.before) return True - def logout (self): - + def logout(self): """This sends exit to the remote shell. If there are stopped jobs then this automatically sends exit twice. """ self.sendline("exit") index = self.expect([EOF, "(?i)there are stopped jobs"]) - if index==1: + if index == 1: self.sendline("exit") self.expect(EOF) self.close() - def prompt (self, timeout=20): - + def prompt(self, timeout=20): """This matches the shell prompt. This is little more than a short-cut to the expect() method. This returns True if the shell prompt was matched. This returns False if there was a timeout. Note that if you @@ -277,12 +334,11 @@ class pxssh (spawn): prompt. """ i = self.expect([self.PROMPT, TIMEOUT], timeout=timeout) - if i==1: + if i == 1: return False return True - - def set_unique_prompt (self): + def set_unique_prompt(self): """This sets the remote prompt to something more unique than # or $. This makes it easier for the prompt() method to match the shell prompt unambiguously. This method is called automatically by the login() @@ -298,12 +354,12 @@ class pxssh (spawn): attribute. After that the prompt() method will try to match your prompt pattern.""" - self.sendline ("unset PROMPT_COMMAND") - self.sendline (self.PROMPT_SET_SH) # sh-style - i = self.expect ([TIMEOUT, self.PROMPT], timeout=10) - if i == 0: # csh-style - self.sendline (self.PROMPT_SET_CSH) - i = self.expect ([TIMEOUT, self.PROMPT], timeout=10) + self.sendline("unset PROMPT_COMMAND") + self.sendline(self.PROMPT_SET_SH) # sh-style + i = self.expect([TIMEOUT, self.PROMPT], timeout=10) + if i == 0: # csh-style + self.sendline(self.PROMPT_SET_CSH) + i = self.expect([TIMEOUT, self.PROMPT], timeout=10) if i == 0: return False return True diff --git a/lldb/third_party/Python/module/pexpect-2.4/screen.py b/lldb/third_party/Python/module/pexpect-2.4/screen.py index 13699f93b5b5..ea0bb81eb12d 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/screen.py +++ b/lldb/third_party/Python/module/pexpect-2.4/screen.py @@ -11,8 +11,8 @@ import copy NUL = 0 # Fill character; ignored on input. ENQ = 5 # Transmit answerback message. BEL = 7 # Ring the bell. -BS = 8 # Move cursor left. -HT = 9 # Move cursor to next tab stop. +BS = 8 # Move cursor left. +HT = 9 # Move cursor to next tab stop. LF = 10 # Line feed. VT = 11 # Same as LF. FF = 12 # Same as LF. @@ -25,10 +25,10 @@ CAN = 24 # Cancel escape sequence. SUB = 26 # Same as CAN. ESC = 27 # Introduce a control sequence. DEL = 127 # Fill character; ignored on input. -SPACE = chr(32) # Space or blank character. +SPACE = chr(32) # Space or blank character. -def constrain (n, min, max): +def constrain(n, min, max): """This returns a number, n constrained to the min and max bounds. """ if n < min: @@ -37,6 +37,7 @@ def constrain (n, min, max): return max return n + class screen: """This object maintains the state of a virtual text screen as a @@ -45,8 +46,7 @@ class screen: by an ANSI text screen. Row and column indexes are 1-based (not zero-based, like arrays). """ - def __init__ (self, r=24,c=80): - + def __init__(self, r=24, c=80): """This initializes a blank scree of the given dimentions.""" self.rows = r @@ -57,222 +57,205 @@ class screen: self.cur_saved_c = 1 self.scroll_row_start = 1 self.scroll_row_end = self.rows - self.w = [ [SPACE] * self.cols for c in range(self.rows)] - - def __str__ (self): + self.w = [[SPACE] * self.cols for c in range(self.rows)] + def __str__(self): """This returns a printable representation of the screen. The end of each screen line is terminated by a newline. """ - return '\n'.join ([ ''.join(c) for c in self.w ]) - - def dump (self): + return '\n'.join([''.join(c) for c in self.w]) + def dump(self): """This returns a copy of the screen as a string. This is similar to __str__ except that lines are not terminated with line feeds. """ - return ''.join ([ ''.join(c) for c in self.w ]) - - def pretty (self): + return ''.join([''.join(c) for c in self.w]) + def pretty(self): """This returns a copy of the screen as a string with an ASCII text box around the screen border. This is similar to __str__ except that it adds a box. """ - top_bot = '+' + '-'*self.cols + '+\n' - return top_bot + '\n'.join(['|'+line+'|' for line in str(self).split('\n')]) + '\n' + top_bot + top_bot = '+' + '-' * self.cols + '+\n' + return top_bot + \ + '\n'.join(['|' + line + '|' for line in str(self).split('\n')]) + '\n' + top_bot - def fill (self, ch=SPACE): + def fill(self, ch=SPACE): - self.fill_region (1,1,self.rows,self.cols, ch) + self.fill_region(1, 1, self.rows, self.cols, ch) - def fill_region (self, rs,cs, re,ce, ch=SPACE): + def fill_region(self, rs, cs, re, ce, ch=SPACE): - rs = constrain (rs, 1, self.rows) - re = constrain (re, 1, self.rows) - cs = constrain (cs, 1, self.cols) - ce = constrain (ce, 1, self.cols) + rs = constrain(rs, 1, self.rows) + re = constrain(re, 1, self.rows) + cs = constrain(cs, 1, self.cols) + ce = constrain(ce, 1, self.cols) if rs > re: rs, re = re, rs if cs > ce: cs, ce = ce, cs - for r in range (rs, re+1): - for c in range (cs, ce + 1): - self.put_abs (r,c,ch) - - def cr (self): + for r in range(rs, re + 1): + for c in range(cs, ce + 1): + self.put_abs(r, c, ch) + def cr(self): """This moves the cursor to the beginning (col 1) of the current row. """ - self.cursor_home (self.cur_r, 1) - - def lf (self): + self.cursor_home(self.cur_r, 1) + def lf(self): """This moves the cursor down with scrolling. """ old_r = self.cur_r self.cursor_down() if old_r == self.cur_r: - self.scroll_up () + self.scroll_up() self.erase_line() - def crlf (self): - + def crlf(self): """This advances the cursor with CRLF properties. The cursor will line wrap and the screen may scroll. """ - self.cr () - self.lf () - - def newline (self): + self.cr() + self.lf() + def newline(self): """This is an alias for crlf(). """ self.crlf() - def put_abs (self, r, c, ch): - + def put_abs(self, r, c, ch): """Screen array starts at 1 index.""" - r = constrain (r, 1, self.rows) - c = constrain (c, 1, self.cols) + r = constrain(r, 1, self.rows) + c = constrain(c, 1, self.cols) ch = str(ch)[0] - self.w[r-1][c-1] = ch - - def put (self, ch): + self.w[r - 1][c - 1] = ch + def put(self, ch): """This puts a characters at the current cursor position. """ - self.put_abs (self.cur_r, self.cur_c, ch) - - def insert_abs (self, r, c, ch): + self.put_abs(self.cur_r, self.cur_c, ch) + def insert_abs(self, r, c, ch): """This inserts a character at (r,c). Everything under and to the right is shifted right one character. The last character of the line is lost. """ - r = constrain (r, 1, self.rows) - c = constrain (c, 1, self.cols) - for ci in range (self.cols, c, -1): - self.put_abs (r,ci, self.get_abs(r,ci-1)) - self.put_abs (r,c,ch) + r = constrain(r, 1, self.rows) + c = constrain(c, 1, self.cols) + for ci in range(self.cols, c, -1): + self.put_abs(r, ci, self.get_abs(r, ci - 1)) + self.put_abs(r, c, ch) - def insert (self, ch): + def insert(self, ch): - self.insert_abs (self.cur_r, self.cur_c, ch) + self.insert_abs(self.cur_r, self.cur_c, ch) - def get_abs (self, r, c): - - r = constrain (r, 1, self.rows) - c = constrain (c, 1, self.cols) - return self.w[r-1][c-1] + def get_abs(self, r, c): - def get (self): + r = constrain(r, 1, self.rows) + c = constrain(c, 1, self.cols) + return self.w[r - 1][c - 1] - self.get_abs (self.cur_r, self.cur_c) + def get(self): - def get_region (self, rs,cs, re,ce): + self.get_abs(self.cur_r, self.cur_c) + def get_region(self, rs, cs, re, ce): """This returns a list of lines representing the region. """ - rs = constrain (rs, 1, self.rows) - re = constrain (re, 1, self.rows) - cs = constrain (cs, 1, self.cols) - ce = constrain (ce, 1, self.cols) + rs = constrain(rs, 1, self.rows) + re = constrain(re, 1, self.rows) + cs = constrain(cs, 1, self.cols) + ce = constrain(ce, 1, self.cols) if rs > re: rs, re = re, rs if cs > ce: cs, ce = ce, cs sc = [] - for r in range (rs, re+1): + for r in range(rs, re + 1): line = '' - for c in range (cs, ce + 1): - ch = self.get_abs (r,c) + for c in range(cs, ce + 1): + ch = self.get_abs(r, c) line = line + ch - sc.append (line) + sc.append(line) return sc - def cursor_constrain (self): - + def cursor_constrain(self): """This keeps the cursor within the screen area. """ - self.cur_r = constrain (self.cur_r, 1, self.rows) - self.cur_c = constrain (self.cur_c, 1, self.cols) + self.cur_r = constrain(self.cur_r, 1, self.rows) + self.cur_c = constrain(self.cur_c, 1, self.cols) - def cursor_home (self, r=1, c=1): # <ESC>[{ROW};{COLUMN}H + def cursor_home(self, r=1, c=1): # <ESC>[{ROW};{COLUMN}H self.cur_r = r self.cur_c = c - self.cursor_constrain () + self.cursor_constrain() - def cursor_back (self,count=1): # <ESC>[{COUNT}D (not confused with down) + def cursor_back(self, count=1): # <ESC>[{COUNT}D (not confused with down) self.cur_c = self.cur_c - count - self.cursor_constrain () + self.cursor_constrain() - def cursor_down (self,count=1): # <ESC>[{COUNT}B (not confused with back) + def cursor_down(self, count=1): # <ESC>[{COUNT}B (not confused with back) self.cur_r = self.cur_r + count - self.cursor_constrain () + self.cursor_constrain() - def cursor_forward (self,count=1): # <ESC>[{COUNT}C + def cursor_forward(self, count=1): # <ESC>[{COUNT}C self.cur_c = self.cur_c + count - self.cursor_constrain () + self.cursor_constrain() - def cursor_up (self,count=1): # <ESC>[{COUNT}A + def cursor_up(self, count=1): # <ESC>[{COUNT}A self.cur_r = self.cur_r - count - self.cursor_constrain () + self.cursor_constrain() - def cursor_up_reverse (self): # <ESC> M (called RI -- Reverse Index) + def cursor_up_reverse(self): # <ESC> M (called RI -- Reverse Index) old_r = self.cur_r self.cursor_up() if old_r == self.cur_r: self.scroll_up() - def cursor_force_position (self, r, c): # <ESC>[{ROW};{COLUMN}f - + def cursor_force_position(self, r, c): # <ESC>[{ROW};{COLUMN}f """Identical to Cursor Home.""" - self.cursor_home (r, c) - - def cursor_save (self): # <ESC>[s + self.cursor_home(r, c) + def cursor_save(self): # <ESC>[s """Save current cursor position.""" self.cursor_save_attrs() - def cursor_unsave (self): # <ESC>[u - + def cursor_unsave(self): # <ESC>[u """Restores cursor position after a Save Cursor.""" self.cursor_restore_attrs() - def cursor_save_attrs (self): # <ESC>7 - + def cursor_save_attrs(self): # <ESC>7 """Save current cursor position.""" self.cur_saved_r = self.cur_r self.cur_saved_c = self.cur_c - def cursor_restore_attrs (self): # <ESC>8 - + def cursor_restore_attrs(self): # <ESC>8 """Restores cursor position after a Save Cursor.""" - self.cursor_home (self.cur_saved_r, self.cur_saved_c) - - def scroll_constrain (self): + self.cursor_home(self.cur_saved_r, self.cur_saved_c) + def scroll_constrain(self): """This keeps the scroll region within the screen region.""" if self.scroll_row_start <= 0: @@ -280,95 +263,82 @@ class screen: if self.scroll_row_end > self.rows: self.scroll_row_end = self.rows - def scroll_screen (self): # <ESC>[r - + def scroll_screen(self): # <ESC>[r """Enable scrolling for entire display.""" self.scroll_row_start = 1 self.scroll_row_end = self.rows - def scroll_screen_rows (self, rs, re): # <ESC>[{start};{end}r - + def scroll_screen_rows(self, rs, re): # <ESC>[{start};{end}r """Enable scrolling from row {start} to row {end}.""" self.scroll_row_start = rs self.scroll_row_end = re self.scroll_constrain() - def scroll_down (self): # <ESC>D - + def scroll_down(self): # <ESC>D """Scroll display down one line.""" # Screen is indexed from 1, but arrays are indexed from 0. s = self.scroll_row_start - 1 e = self.scroll_row_end - 1 - self.w[s+1:e+1] = copy.deepcopy(self.w[s:e]) - - def scroll_up (self): # <ESC>M + self.w[s + 1:e + 1] = copy.deepcopy(self.w[s:e]) + def scroll_up(self): # <ESC>M """Scroll display up one line.""" # Screen is indexed from 1, but arrays are indexed from 0. s = self.scroll_row_start - 1 e = self.scroll_row_end - 1 - self.w[s:e] = copy.deepcopy(self.w[s+1:e+1]) - - def erase_end_of_line (self): # <ESC>[0K -or- <ESC>[K + self.w[s:e] = copy.deepcopy(self.w[s + 1:e + 1]) + def erase_end_of_line(self): # <ESC>[0K -or- <ESC>[K """Erases from the current cursor position to the end of the current line.""" - self.fill_region (self.cur_r, self.cur_c, self.cur_r, self.cols) - - def erase_start_of_line (self): # <ESC>[1K + self.fill_region(self.cur_r, self.cur_c, self.cur_r, self.cols) + def erase_start_of_line(self): # <ESC>[1K """Erases from the current cursor position to the start of the current line.""" - self.fill_region (self.cur_r, 1, self.cur_r, self.cur_c) - - def erase_line (self): # <ESC>[2K + self.fill_region(self.cur_r, 1, self.cur_r, self.cur_c) + def erase_line(self): # <ESC>[2K """Erases the entire current line.""" - self.fill_region (self.cur_r, 1, self.cur_r, self.cols) - - def erase_down (self): # <ESC>[0J -or- <ESC>[J + self.fill_region(self.cur_r, 1, self.cur_r, self.cols) + def erase_down(self): # <ESC>[0J -or- <ESC>[J """Erases the screen from the current line down to the bottom of the screen.""" - self.erase_end_of_line () - self.fill_region (self.cur_r + 1, 1, self.rows, self.cols) - - def erase_up (self): # <ESC>[1J + self.erase_end_of_line() + self.fill_region(self.cur_r + 1, 1, self.rows, self.cols) + def erase_up(self): # <ESC>[1J """Erases the screen from the current line up to the top of the screen.""" - self.erase_start_of_line () - self.fill_region (self.cur_r-1, 1, 1, self.cols) - - def erase_screen (self): # <ESC>[2J + self.erase_start_of_line() + self.fill_region(self.cur_r - 1, 1, 1, self.cols) + def erase_screen(self): # <ESC>[2J """Erases the screen with the background color.""" - self.fill () - - def set_tab (self): # <ESC>H + self.fill() + def set_tab(self): # <ESC>H """Sets a tab at the current position.""" pass - def clear_tab (self): # <ESC>[g - + def clear_tab(self): # <ESC>[g """Clears tab at the current position.""" pass - def clear_all_tabs (self): # <ESC>[3g - + def clear_all_tabs(self): # <ESC>[3g """Clears all tabs.""" pass @@ -377,4 +347,3 @@ class screen: # Delete line Esc [ Pn M # Delete character Esc [ Pn P # Scrolling region Esc [ Pn(top);Pn(bot) r - diff --git a/lldb/third_party/Python/module/pexpect-2.4/setup.py b/lldb/third_party/Python/module/pexpect-2.4/setup.py index 81a442bed355..87f95ba1067c 100644 --- a/lldb/third_party/Python/module/pexpect-2.4/setup.py +++ b/lldb/third_party/Python/module/pexpect-2.4/setup.py @@ -3,16 +3,16 @@ $Revision: 485 $ $Date: 2007-07-12 15:23:15 -0700 (Thu, 12 Jul 2007) $ ''' from distutils.core import setup -setup (name='pexpect', - version='2.4', - py_modules=['pexpect', 'pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'], - description='Pexpect is a pure Python Expect. It allows easy control of other applications.', - author='Noah Spurrier', - author_email='noah@noah.org', - url='http://pexpect.sourceforge.net/', - license='MIT license', - platforms='UNIX', -) +setup(name='pexpect', + version='2.4', + py_modules=['pexpect', 'pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'], + description='Pexpect is a pure Python Expect. It allows easy control of other applications.', + author='Noah Spurrier', + author_email='noah@noah.org', + url='http://pexpect.sourceforge.net/', + license='MIT license', + platforms='UNIX', + ) # classifiers = [ # 'Development Status :: 4 - Beta', @@ -34,6 +34,3 @@ setup (name='pexpect', # 'Topic :: System :: Software Distribution', # 'Topic :: Terminals, Utilities', # ], - - - diff --git a/lldb/third_party/Python/module/progress/progress.py b/lldb/third_party/Python/module/progress/progress.py index 734627d4b16e..3397cf043017 100644 --- a/lldb/third_party/Python/module/progress/progress.py +++ b/lldb/third_party/Python/module/progress/progress.py @@ -8,10 +8,11 @@ import six import sys import time + class ProgressBar(object): """ProgressBar class holds the options of the progress bar. The options are: - start State from which start the progress. For example, if start is + start State from which start the progress. For example, if start is 5 and the end is 10, the progress of this state is 50% end State in which the progress has terminated. width -- @@ -23,15 +24,15 @@ class ProgressBar(object): light_block = six.unichr(0x2591).encode("utf-8") solid_block = six.unichr(0x2588).encode("utf-8") solid_right_arrow = six.unichr(0x25BA).encode("utf-8") - - def __init__(self, - start=0, - end=10, - width=12, - fill=six.unichr(0x25C9).encode("utf-8"), - blank=six.unichr(0x25CC).encode("utf-8"), - marker=six.unichr(0x25CE).encode("utf-8"), - format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', + + def __init__(self, + start=0, + end=10, + width=12, + fill=six.unichr(0x25C9).encode("utf-8"), + blank=six.unichr(0x25CC).encode("utf-8"), + marker=six.unichr(0x25CE).encode("utf-8"), + format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', incremental=True): super(ProgressBar, self).__init__() @@ -43,7 +44,7 @@ class ProgressBar(object): self.marker = marker self.format = format self.incremental = incremental - self.step = 100 / float(width) #fix + self.step = 100 / float(width) # fix self.reset() def __add__(self, increment): @@ -59,10 +60,15 @@ class ProgressBar(object): return self def __str__(self): - progressed = int(self.progress / self.step) #fix + progressed = int(self.progress / self.step) # fix fill = progressed * self.fill blank = (self.width - progressed) * self.blank - return self.format % {'fill': fill, 'blank': blank, 'marker': self.marker, 'progress': int(self.progress)} + return self.format % { + 'fill': fill, + 'blank': blank, + 'marker': self.marker, + 'progress': int( + self.progress)} __repr__ = __str__ @@ -80,17 +86,28 @@ class AnimatedProgressBar(ProgressBar): Accepts an extra keyword argument named `stdout` (by default use sys.stdout) and may be any file-object to which send the progress status. """ - def __init__(self, - start=0, - end=10, - width=12, - fill=six.unichr(0x25C9).encode("utf-8"), - blank=six.unichr(0x25CC).encode("utf-8"), - marker=six.unichr(0x25CE).encode("utf-8"), - format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', + + def __init__(self, + start=0, + end=10, + width=12, + fill=six.unichr(0x25C9).encode("utf-8"), + blank=six.unichr(0x25CC).encode("utf-8"), + marker=six.unichr(0x25CE).encode("utf-8"), + format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', incremental=True, stdout=sys.stdout): - super(AnimatedProgressBar, self).__init__(start,end,width,fill,blank,marker,format,incremental) + super( + AnimatedProgressBar, + self).__init__( + start, + end, + width, + fill, + blank, + marker, + format, + incremental) self.stdout = stdout def show_progress(self): @@ -101,25 +118,38 @@ class AnimatedProgressBar(ProgressBar): self.stdout.write(str(self)) self.stdout.flush() + class ProgressWithEvents(AnimatedProgressBar): """Extends AnimatedProgressBar to allow you to track a set of events that cause the progress to move. For instance, in a deletion progress bar, you can track files that were nuked and files that the user doesn't have access to """ - def __init__(self, - start=0, - end=10, - width=12, - fill=six.unichr(0x25C9).encode("utf-8"), - blank=six.unichr(0x25CC).encode("utf-8"), - marker=six.unichr(0x25CE).encode("utf-8"), - format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', + + def __init__(self, + start=0, + end=10, + width=12, + fill=six.unichr(0x25C9).encode("utf-8"), + blank=six.unichr(0x25CC).encode("utf-8"), + marker=six.unichr(0x25CE).encode("utf-8"), + format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%', incremental=True, stdout=sys.stdout): - super(ProgressWithEvents, self).__init__(start,end,width,fill,blank,marker,format,incremental,stdout) + super( + ProgressWithEvents, + self).__init__( + start, + end, + width, + fill, + blank, + marker, + format, + incremental, + stdout) self.events = {} - def add_event(self,event): + def add_event(self, event): if event in self.events: self.events[event] += 1 else: @@ -151,4 +181,4 @@ if __name__ == '__main__': time.sleep(0.3) if p.progress == 100: break - print() #new line
\ No newline at end of file + print() # new line diff --git a/lldb/third_party/Python/module/six/six.py b/lldb/third_party/Python/module/six/six.py index 190c0239cd7d..0df2e259237d 100644 --- a/lldb/third_party/Python/module/six/six.py +++ b/lldb/third_party/Python/module/six/six.py @@ -353,8 +353,12 @@ del attr Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes -_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), - "moves.urllib_parse", "moves.urllib.parse") +_importer._add_module( + Module_six_moves_urllib_parse( + __name__ + + ".moves.urllib_parse"), + "moves.urllib_parse", + "moves.urllib.parse") class Module_six_moves_urllib_error(_LazyModule): @@ -373,8 +377,12 @@ del attr Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes -_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), - "moves.urllib_error", "moves.urllib.error") +_importer._add_module( + Module_six_moves_urllib_error( + __name__ + + ".moves.urllib.error"), + "moves.urllib_error", + "moves.urllib.error") class Module_six_moves_urllib_request(_LazyModule): @@ -423,8 +431,12 @@ del attr Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes -_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), - "moves.urllib_request", "moves.urllib.request") +_importer._add_module( + Module_six_moves_urllib_request( + __name__ + + ".moves.urllib.request"), + "moves.urllib_request", + "moves.urllib.request") class Module_six_moves_urllib_response(_LazyModule): @@ -444,8 +456,12 @@ del attr Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes -_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), - "moves.urllib_response", "moves.urllib.response") +_importer._add_module( + Module_six_moves_urllib_response( + __name__ + + ".moves.urllib.response"), + "moves.urllib_response", + "moves.urllib.response") class Module_six_moves_urllib_robotparser(_LazyModule): @@ -462,8 +478,11 @@ del attr Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes -_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), - "moves.urllib_robotparser", "moves.urllib.robotparser") +_importer._add_module( + Module_six_moves_urllib_robotparser( + __name__ + ".moves.urllib.robotparser"), + "moves.urllib_robotparser", + "moves.urllib.robotparser") class Module_six_moves_urllib(types.ModuleType): diff --git a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/__init__.py index 8ec6c7a478a6..14fea5a2599e 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/__init__.py @@ -34,7 +34,7 @@ if sys.version_info[0] >= 3: else: cmp_ = cmp -reversed_cmp_ = lambda x, y: -cmp_(x,y) +reversed_cmp_ = lambda x, y: -cmp_(x, y) __all__ = ['TestResult', 'TestCase', 'TestSuite', 'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main', @@ -69,7 +69,7 @@ except ImportError: # Compatibility with platforms that don't have the signal module pass else: - __all__.extend(['installHandler', 'registerResult', 'removeResult', + __all__.extend(['installHandler', 'registerResult', 'removeResult', 'removeHandler']) # deprecated diff --git a/lldb/third_party/Python/module/unittest2/unittest2/case.py b/lldb/third_party/Python/module/unittest2/unittest2/case.py index de7cb6a71e98..7d6c54eff967 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/case.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/case.py @@ -21,7 +21,8 @@ __unittest = True DIFF_OMITTED = ('\nDiff is %s characters long. ' - 'Set self.maxDiff to None to see it.') + 'Set self.maxDiff to None to see it.') + class SkipTest(Exception): """ @@ -31,6 +32,7 @@ class SkipTest(Exception): instead of raising this directly. """ + class _ExpectedFailure(Exception): """ Raise this when a test is expected to fail. @@ -44,6 +46,7 @@ class _ExpectedFailure(Exception): self.exc_info = exc_info self.bugnumber = bugnumber + class _UnexpectedSuccess(Exception): """ The test was supposed to fail, but it didn't! @@ -55,25 +58,33 @@ class _UnexpectedSuccess(Exception): self.exc_info = exc_info self.bugnumber = bugnumber + def _id(obj): return obj + def skip(reason): """ Unconditionally skip a test. """ def decorator(test_item): - if not (isinstance(test_item, type) and issubclass(test_item, TestCase)): + if not ( + isinstance( + test_item, + type) and issubclass( + test_item, + TestCase)): @wraps(test_item) def skip_wrapper(*args, **kwargs): raise SkipTest(reason) test_item = skip_wrapper - + test_item.__unittest_skip__ = True test_item.__unittest_skip_why__ = reason return test_item return decorator + def skipIf(condition, reason): """ Skip a test if the condition is true. @@ -82,6 +93,7 @@ def skipIf(condition, reason): return skip(reason) return _id + def skipUnless(condition, reason): """ Skip a test unless the condition is true. @@ -90,28 +102,30 @@ def skipUnless(condition, reason): return skip(reason) return _id + def expectedFailure(bugnumber=None): - if callable(bugnumber): + if callable(bugnumber): @wraps(bugnumber) def expectedFailure_easy_wrapper(*args, **kwargs): - try: + try: bugnumber(*args, **kwargs) - except Exception: - raise _ExpectedFailure(sys.exc_info(),None) - raise _UnexpectedSuccess(sys.exc_info(),None) + except Exception: + raise _ExpectedFailure(sys.exc_info(), None) + raise _UnexpectedSuccess(sys.exc_info(), None) return expectedFailure_easy_wrapper - else: + else: def expectedFailure_impl(func): - @wraps(func) - def wrapper(*args, **kwargs): - try: - func(*args, **kwargs) - except Exception: - raise _ExpectedFailure(sys.exc_info(),bugnumber) - raise _UnexpectedSuccess(sys.exc_info(),bugnumber) - return wrapper + @wraps(func) + def wrapper(*args, **kwargs): + try: + func(*args, **kwargs) + except Exception: + raise _ExpectedFailure(sys.exc_info(), bugnumber) + raise _UnexpectedSuccess(sys.exc_info(), bugnumber) + return wrapper return expectedFailure_impl + class _AssertRaisesContext(object): """A context manager used to implement TestCase.assertRaises* methods.""" @@ -134,7 +148,7 @@ class _AssertRaisesContext(object): if not issubclass(exc_type, self.expected): # let unexpected exceptions pass through return False - self.exception = exc_value # store for later retrieval + self.exception = exc_value # store for later retrieval if self.expected_regexp is None: return True @@ -142,26 +156,27 @@ class _AssertRaisesContext(object): if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(str(exc_value)): - raise self.failureException('"%s" does not match "%s"' % - (expected_regexp.pattern, str(exc_value))) + raise self.failureException( + '"%s" does not match "%s"' % + (expected_regexp.pattern, str(exc_value))) return True class _TypeEqualityDict(object): - + def __init__(self, testcase): self.testcase = testcase self._store = {} - + def __setitem__(self, key, value): self._store[key] = value - + def __getitem__(self, key): value = self._store[key] if isinstance(value, six.string_types): return getattr(self.testcase, value) return value - + def get(self, key, default=None): if key in self._store: return self[key] @@ -200,16 +215,16 @@ class TestCase(unittest.TestCase): # by assert methods using difflib. It is looked up as an instance attribute # so can be configured by individual tests if required. - maxDiff = 80*8 + maxDiff = 80 * 8 # This attribute determines whether long messages (including repr of # objects used in assert methods) will be printed on failure in *addition* # to any explicit message passed. longMessage = True - + # Attribute used by TestSuite for classSetUp - + _classSetupFailed = False def __init__(self, methodName='runTest'): @@ -222,8 +237,8 @@ class TestCase(unittest.TestCase): try: testMethod = getattr(self, methodName) except AttributeError: - raise ValueError("no such test method in %s: %s" % \ - (self.__class__, methodName)) + raise ValueError("no such test method in %s: %s" % + (self.__class__, methodName)) self._testMethodDoc = testMethod.__doc__ self._cleanups = [] @@ -266,7 +281,7 @@ class TestCase(unittest.TestCase): def setUp(self): "Hook method for setting up the test fixture before exercising it." - + @classmethod def setUpClass(cls): "Hook method for setting up class fixture before running tests in the class." @@ -294,12 +309,11 @@ class TestCase(unittest.TestCase): doc = self._testMethodDoc return doc and doc.split("\n")[0].strip() or None - def id(self): return "%s.%s" % (strclass(self.__class__), self._testMethodName) def __eq__(self, other): - if type(self) is not type(other): + if not isinstance(self, type(other)): return NotImplemented return self._testMethodName == other._testMethodName @@ -316,14 +330,16 @@ class TestCase(unittest.TestCase): def __repr__(self): return "<%s testMethod=%s>" % \ (strclass(self.__class__), self._testMethodName) - + def _addSkip(self, result, reason): addSkip = getattr(result, 'addSkip', None) if addSkip is not None: addSkip(self, reason) else: - warnings.warn("Use of a TestResult without an addSkip method is deprecated", - DeprecationWarning, 2) + warnings.warn( + "Use of a TestResult without an addSkip method is deprecated", + DeprecationWarning, + 2) result.addSuccess(self) def run(self, result=None): @@ -336,15 +352,21 @@ class TestCase(unittest.TestCase): self._resultForDoCleanups = result result.startTest(self) - + testMethod = getattr(self, self._testMethodName) - - if (getattr(self.__class__, "__unittest_skip__", False) or - getattr(testMethod, "__unittest_skip__", False)): + + if (getattr(self.__class__, "__unittest_skip__", False) or + getattr(testMethod, "__unittest_skip__", False)): # If the class or method was skipped. try: - skip_why = (getattr(self.__class__, '__unittest_skip_why__', '') - or getattr(testMethod, '__unittest_skip_why__', '')) + skip_why = ( + getattr( + self.__class__, + '__unittest_skip_why__', + '') or getattr( + testMethod, + '__unittest_skip_why__', + '')) self._addSkip(result, skip_why) finally: result.stopTest(self) @@ -396,16 +418,19 @@ class TestCase(unittest.TestCase): if addExpectedFailure is not None: addExpectedFailure(self, e.exc_info, e.bugnumber) else: - warnings.warn("Use of a TestResult without an addExpectedFailure method is deprecated", - DeprecationWarning) + warnings.warn( + "Use of a TestResult without an addExpectedFailure method is deprecated", + DeprecationWarning) result.addSuccess(self) except _UnexpectedSuccess as x: - addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None) + addUnexpectedSuccess = getattr( + result, 'addUnexpectedSuccess', None) if addUnexpectedSuccess is not None: addUnexpectedSuccess(self, x.bugnumber) else: - warnings.warn("Use of a TestResult without an addUnexpectedSuccess method is deprecated", - DeprecationWarning) + warnings.warn( + "Use of a TestResult without an addUnexpectedSuccess method is deprecated", + DeprecationWarning) result.addFailure(self, sys.exc_info()) except SkipTest as e: self._addSkip(result, str(e)) @@ -480,7 +505,6 @@ class TestCase(unittest.TestCase): except UnicodeDecodeError: return '%s : %s' % (safe_str(standardMsg), safe_str(msg)) - def assertRaises(self, excClass, callableObj=None, *args, **kwargs): """Fail unless an exception of class excClass is thrown by callableObj when invoked with arguments args and keyword @@ -510,8 +534,8 @@ class TestCase(unittest.TestCase): callableObj(*args, **kwargs) except excClass: return - - if hasattr(excClass,'__name__'): + + if hasattr(excClass, '__name__'): excName = excClass.__name__ else: excName = str(excClass) @@ -534,7 +558,7 @@ class TestCase(unittest.TestCase): # subclasses if the detailed comparison is desired and appropriate. # See the discussion in http://bugs.python.org/issue2578. # - if type(first) is type(second): + if isinstance(first, type(second)): asserter = self._type_equality_funcs.get(type(first)) if asserter is not None: return asserter @@ -560,11 +584,17 @@ class TestCase(unittest.TestCase): operator. """ if not first != second: - msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), - safe_repr(second))) + msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), + safe_repr(second))) raise self.failureException(msg) - def assertAlmostEqual(self, first, second, places=None, msg=None, delta=None): + def assertAlmostEqual( + self, + first, + second, + places=None, + msg=None, + delta=None): """Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the @@ -581,28 +611,34 @@ class TestCase(unittest.TestCase): return if delta is not None and places is not None: raise TypeError("specify delta or places not both") - + if delta is not None: if abs(first - second) <= delta: return - - standardMsg = '%s != %s within %s delta' % (safe_repr(first), - safe_repr(second), + + standardMsg = '%s != %s within %s delta' % (safe_repr(first), + safe_repr(second), safe_repr(delta)) else: if places is None: places = 7 - - if round(abs(second-first), places) == 0: + + if round(abs(second - first), places) == 0: return - - standardMsg = '%s != %s within %r places' % (safe_repr(first), - safe_repr(second), - places) + + standardMsg = '%s != %s within %r places' % (safe_repr(first), + safe_repr(second), + places) msg = self._formatMessage(msg, standardMsg) raise self.failureException(msg) - def assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None): + def assertNotAlmostEqual( + self, + first, + second, + places=None, + msg=None, + delta=None): """Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the @@ -618,15 +654,16 @@ class TestCase(unittest.TestCase): if delta is not None: if not (first == second) and abs(first - second) > delta: return - standardMsg = '%s == %s within %s delta' % (safe_repr(first), + standardMsg = '%s == %s within %s delta' % (safe_repr(first), safe_repr(second), safe_repr(delta)) else: if places is None: places = 7 - if not (first == second) and round(abs(second-first), places) != 0: + if not (first == second) and round( + abs(second - first), places) != 0: return - standardMsg = '%s == %s within %r places' % (safe_repr(first), + standardMsg = '%s == %s within %r places' % (safe_repr(first), safe_repr(second), places) @@ -663,7 +700,7 @@ class TestCase(unittest.TestCase): failIf = _deprecate(assertFalse) def assertSequenceEqual(self, seq1, seq2, - msg=None, seq_type=None, max_diff=80*8): + msg=None, seq_type=None, max_diff=80 * 8): """An equality assertion for ordered sequences (like lists and tuples). For the purposes of this function, a valid ordered sequence type is one @@ -694,14 +731,14 @@ class TestCase(unittest.TestCase): len1 = len(seq1) except (TypeError, NotImplementedError): differing = 'First %s has no length. Non-sequence?' % ( - seq_type_name) + seq_type_name) if differing is None: try: len2 = len(seq2) except (TypeError, NotImplementedError): differing = 'Second %s has no length. Non-sequence?' % ( - seq_type_name) + seq_type_name) if differing is None: if seq1 == seq2: @@ -721,29 +758,29 @@ class TestCase(unittest.TestCase): item1 = seq1[i] except (TypeError, IndexError, NotImplementedError): differing += ('\nUnable to index element %d of first %s\n' % - (i, seq_type_name)) + (i, seq_type_name)) break try: item2 = seq2[i] except (TypeError, IndexError, NotImplementedError): differing += ('\nUnable to index element %d of second %s\n' % - (i, seq_type_name)) + (i, seq_type_name)) break if item1 != item2: differing += ('\nFirst differing element %d:\n%s\n%s\n' % - (i, item1, item2)) + (i, item1, item2)) break else: if (len1 == len2 and seq_type is None and - type(seq1) != type(seq2)): + not isinstance(seq1, type(seq2))): # The sequences are the same, but have differing types. return if len1 > len2: differing += ('\nFirst %s contains %d additional ' - 'elements.\n' % (seq_type_name, len1 - len2)) + 'elements.\n' % (seq_type_name, len1 - len2)) try: differing += ('First extra element %d:\n%s\n' % (len2, seq1[len2])) @@ -752,7 +789,7 @@ class TestCase(unittest.TestCase): 'of first %s\n' % (len2, seq_type_name)) elif len1 < len2: differing += ('\nSecond %s contains %d additional ' - 'elements.\n' % (seq_type_name, len2 - len1)) + 'elements.\n' % (seq_type_name, len2 - len1)) try: differing += ('First extra element %d:\n%s\n' % (len1, seq2[len1])) @@ -822,7 +859,9 @@ class TestCase(unittest.TestCase): except TypeError as e: self.fail('invalid type when attempting set difference: %s' % e) except AttributeError as e: - self.fail('second argument does not support set difference: %s' % e) + self.fail( + 'second argument does not support set difference: %s' % + e) if not (difference1 or difference2): return @@ -843,15 +882,15 @@ class TestCase(unittest.TestCase): def assertIn(self, member, container, msg=None): """Just like self.assertTrue(a in b), but with a nicer default message.""" if member not in container: - standardMsg = '%s not found in %s' % (safe_repr(member), - safe_repr(container)) + standardMsg = '%s not found in %s' % (safe_repr(member), + safe_repr(container)) self.fail(self._formatMessage(msg, standardMsg)) def assertNotIn(self, member, container, msg=None): """Just like self.assertTrue(a not in b), but with a nicer default message.""" if member in container: - standardMsg = '%s unexpectedly found in %s' % (safe_repr(member), - safe_repr(container)) + standardMsg = '%s unexpectedly found in %s' % ( + safe_repr(member), safe_repr(container)) self.fail(self._formatMessage(msg, standardMsg)) def assertIs(self, expr1, expr2, msg=None): @@ -867,11 +906,20 @@ class TestCase(unittest.TestCase): self.fail(self._formatMessage(msg, standardMsg)) def assertDictEqual(self, d1, d2, msg=None): - self.assert_(isinstance(d1, dict), 'First argument is not a dictionary') - self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary') + self.assert_( + isinstance( + d1, + dict), + 'First argument is not a dictionary') + self.assert_( + isinstance( + d2, + dict), + 'Second argument is not a dictionary') if d1 != d2: - standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True)) + standardMsg = '%s != %s' % ( + safe_repr(d1, True), safe_repr(d2, True)) diff = ('\n' + '\n'.join(difflib.ndiff( pprint.pformat(d1).splitlines(), pprint.pformat(d2).splitlines()))) @@ -887,7 +935,7 @@ class TestCase(unittest.TestCase): missing.append(key) elif value != actual[key]: mismatched.append('%s, expected: %s, actual: %s' % - (safe_repr(key), safe_repr(value), + (safe_repr(key), safe_repr(value), safe_repr(actual[key]))) if not (missing or mismatched): @@ -895,8 +943,8 @@ class TestCase(unittest.TestCase): standardMsg = '' if missing: - standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in - missing) + standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in + missing) if mismatched: if standardMsg: standardMsg += '; ' @@ -908,12 +956,12 @@ class TestCase(unittest.TestCase): """An unordered sequence specific comparison. It asserts that expected_seq and actual_seq contain the same elements. It is the equivalent of:: - + self.assertEqual(sorted(expected_seq), sorted(actual_seq)) Raises with an error message listing which elements of expected_seq are missing from actual_seq and vice versa if any. - + Asserts that each element has the same count in both sequences. Example: - [0, 1, 1] and [1, 0, 1] compare equal. @@ -934,11 +982,11 @@ class TestCase(unittest.TestCase): errors = [] if missing: - errors.append('Expected, but missing:\n %s' % - safe_repr(missing)) + errors.append('Expected, but missing:\n %s' % + safe_repr(missing)) if unexpected: - errors.append('Unexpected, but present:\n %s' % - safe_repr(unexpected)) + errors.append('Unexpected, but present:\n %s' % + safe_repr(unexpected)) if errors: standardMsg = '\n'.join(errors) self.fail(self._formatMessage(msg, standardMsg)) @@ -946,14 +994,15 @@ class TestCase(unittest.TestCase): def assertMultiLineEqual(self, first, second, msg=None): """Assert that two multi-line strings are equal.""" self.assert_(isinstance(first, six.string_types), ( - 'First argument is not a string')) + 'First argument is not a string')) self.assert_(isinstance(second, six.string_types), ( - 'Second argument is not a string')) + 'Second argument is not a string')) if first != second: - standardMsg = '%s != %s' % (safe_repr(first, True), safe_repr(second, True)) + standardMsg = '%s != %s' % ( + safe_repr(first, True), safe_repr(second, True)) diff = '\n' + ''.join(difflib.ndiff(first.splitlines(True), - second.splitlines(True))) + second.splitlines(True))) standardMsg = self._truncateMessage(standardMsg, diff) self.fail(self._formatMessage(msg, standardMsg)) @@ -966,19 +1015,22 @@ class TestCase(unittest.TestCase): def assertLessEqual(self, a, b, msg=None): """Just like self.assertTrue(a <= b), but with a nicer default message.""" if not a <= b: - standardMsg = '%s not less than or equal to %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not less than or equal to %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertGreater(self, a, b, msg=None): """Just like self.assertTrue(a > b), but with a nicer default message.""" if not a > b: - standardMsg = '%s not greater than %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not greater than %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertGreaterEqual(self, a, b, msg=None): """Just like self.assertTrue(a >= b), but with a nicer default message.""" if not a >= b: - standardMsg = '%s not greater than or equal to %s' % (safe_repr(a), safe_repr(b)) + standardMsg = '%s not greater than or equal to %s' % ( + safe_repr(a), safe_repr(b)) self.fail(self._formatMessage(msg, standardMsg)) def assertIsNone(self, obj, msg=None): @@ -1019,30 +1071,32 @@ class TestCase(unittest.TestCase): kwargs: Extra kwargs. """ if callable_obj is None: - return _AssertRaisesContext(expected_exception, self, expected_regexp) + return _AssertRaisesContext( + expected_exception, self, expected_regexp) try: callable_obj(*args, **kwargs) except expected_exception as exc_value: if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(str(exc_value)): - raise self.failureException('"%s" does not match "%s"' % - (expected_regexp.pattern, str(exc_value))) + raise self.failureException( + '"%s" does not match "%s"' % + (expected_regexp.pattern, str(exc_value))) else: - if hasattr(expected_exception, '__name__'): + if hasattr(expected_exception, '__name__'): excName = expected_exception.__name__ - else: + else: excName = str(expected_exception) raise self.failureException("%s not raised" % excName) - def assertRegexpMatches(self, text, expected_regexp, msg=None): """Fail the test unless the text matches the regular expression.""" if isinstance(expected_regexp, six.string_types): expected_regexp = re.compile(expected_regexp) if not expected_regexp.search(text): msg = msg or "Regexp didn't match" - msg = '%s: %r not found in %r' % (msg, expected_regexp.pattern, text) + msg = '%s: %r not found in %r' % ( + msg, expected_regexp.pattern, text) raise self.failureException(msg) def assertNotRegexpMatches(self, text, unexpected_regexp, msg=None): @@ -1058,6 +1112,7 @@ class TestCase(unittest.TestCase): text) raise self.failureException(msg) + class FunctionTestCase(TestCase): """A test case that wraps a test function. @@ -1093,9 +1148,9 @@ class FunctionTestCase(TestCase): return NotImplemented return self._setUpFunc == other._setUpFunc and \ - self._tearDownFunc == other._tearDownFunc and \ - self._testFunc == other._testFunc and \ - self._description == other._description + self._tearDownFunc == other._tearDownFunc and \ + self._testFunc == other._testFunc and \ + self._description == other._description def __ne__(self, other): return not self == other diff --git a/lldb/third_party/Python/module/unittest2/unittest2/collector.py b/lldb/third_party/Python/module/unittest2/unittest2/collector.py index 28ff3f89ce7d..b9013e888885 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/collector.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/collector.py @@ -2,6 +2,7 @@ import os import sys from unittest2.loader import defaultTestLoader + def collector(): # import __main__ triggers code re-execution __main__ = sys.modules['__main__'] diff --git a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py b/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py index b8f15dd14288..3adcdc4b35bd 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py @@ -12,6 +12,7 @@ except ImportError: __unittest = True + def _relpath_nt(path, start=os.path.curdir): """Return a relative version of a path""" @@ -24,10 +25,10 @@ def _relpath_nt(path, start=os.path.curdir): unc_start, rest = os.path.splitunc(start) if bool(unc_path) ^ bool(unc_start): raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)" - % (path, start)) + % (path, start)) else: raise ValueError("path is on drive %s, start on drive %s" - % (path_list[0], start_list[0])) + % (path_list[0], start_list[0])) # Work out how much of the filepath is shared by start and path. for i in range(min(len(start_list), len(path_list))): if start_list[i].lower() != path_list[i].lower(): @@ -35,25 +36,27 @@ def _relpath_nt(path, start=os.path.curdir): else: i += 1 - rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:] + rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:] if not rel_list: return os.path.curdir return os.path.join(*rel_list) # default to posixpath definition + + def _relpath_posix(path, start=os.path.curdir): """Return a relative version of a path""" if not path: raise ValueError("no path specified") - + start_list = os.path.abspath(start).split(os.path.sep) path_list = os.path.abspath(path).split(os.path.sep) # Work out how much of the filepath is shared by start and path. i = len(os.path.commonprefix([start_list, path_list])) - rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:] + rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:] if not rel_list: return os.path.curdir return os.path.join(*rel_list) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/loader.py b/lldb/third_party/Python/module/unittest2/unittest2/loader.py index fe86db1e475e..996dd7664757 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/loader.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/loader.py @@ -34,16 +34,18 @@ def _make_failed_import_test(name, suiteClass): return _make_failed_test('ModuleImportFailure', name, ImportError(message), suiteClass) + def _make_failed_load_tests(name, exception, suiteClass): return _make_failed_test('LoadTestsFailure', name, exception, suiteClass) + def _make_failed_test(classname, methodname, exception, suiteClass): def testFailure(self): raise exception attrs = {methodname: testFailure} TestClass = type(classname, (case.TestCase,), attrs) return suiteClass((TestClass(methodname),)) - + class TestLoader(unittest.TestLoader): """ @@ -149,7 +151,9 @@ class TestLoader(unittest.TestLoader): hasattr(getattr(testCaseClass, attrname), '__call__') testFnNames = list(filter(isTestMethod, dir(testCaseClass))) if self.sortTestMethodsUsing: - testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing)) + testFnNames.sort( + key=functools.cmp_to_key( + self.sortTestMethodsUsing)) return testFnNames def discover(self, start_dir, pattern='test*.py', top_level_dir=None): @@ -175,7 +179,8 @@ class TestLoader(unittest.TestLoader): """ set_implicit_top = False if top_level_dir is None and self._top_level_dir is not None: - # make top_level_dir optional if called from load_tests in a package + # make top_level_dir optional if called from load_tests in a + # package top_level_dir = self._top_level_dir elif top_level_dir is None: set_implicit_top = True @@ -183,7 +188,7 @@ class TestLoader(unittest.TestLoader): top_level_dir = os.path.abspath(top_level_dir) - if not top_level_dir in sys.path: + if top_level_dir not in sys.path: # all test modules must be importable from the top level directory # should we *unconditionally* put the start directory in first # in sys.path to minimise likelihood of conflicts between installed @@ -195,7 +200,8 @@ class TestLoader(unittest.TestLoader): if os.path.isdir(os.path.abspath(start_dir)): start_dir = os.path.abspath(start_dir) if start_dir != top_level_dir: - is_not_importable = not os.path.isfile(os.path.join(start_dir, '__init__.py')) + is_not_importable = not os.path.isfile( + os.path.join(start_dir, '__init__.py')) else: # support for discovery from dotted module names try: @@ -205,13 +211,17 @@ class TestLoader(unittest.TestLoader): else: the_module = sys.modules[start_dir] top_part = start_dir.split('.')[0] - start_dir = os.path.abspath(os.path.dirname((the_module.__file__))) + start_dir = os.path.abspath( + os.path.dirname((the_module.__file__))) if set_implicit_top: - self._top_level_dir = os.path.abspath(os.path.dirname(os.path.dirname(sys.modules[top_part].__file__))) + self._top_level_dir = os.path.abspath(os.path.dirname( + os.path.dirname(sys.modules[top_part].__file__))) sys.path.remove(top_level_dir) if is_not_importable: - raise ImportError('Start directory is not importable: %r' % start_dir) + raise ImportError( + 'Start directory is not importable: %r' % + start_dir) tests = list(self._find_tests(start_dir, pattern)) return self.suiteClass(tests) @@ -233,7 +243,7 @@ class TestLoader(unittest.TestLoader): def _match_path(self, path, full_path, pattern): # override this method to use alternative matching strategy return fnmatch(path, pattern) - + def _find_tests(self, start_dir, pattern): """Used by discovery. Yields test suites it loads.""" paths = os.listdir(start_dir) @@ -253,16 +263,20 @@ class TestLoader(unittest.TestLoader): except: yield _make_failed_import_test(name, self.suiteClass) else: - mod_file = os.path.abspath(getattr(module, '__file__', full_path)) + mod_file = os.path.abspath( + getattr(module, '__file__', full_path)) realpath = os.path.splitext(mod_file)[0] fullpath_noext = os.path.splitext(full_path)[0] if realpath.lower() != fullpath_noext.lower(): module_dir = os.path.dirname(realpath) - mod_name = os.path.splitext(os.path.basename(full_path))[0] + mod_name = os.path.splitext( + os.path.basename(full_path))[0] expected_dir = os.path.dirname(full_path) - msg = ("%r module incorrectly imported from %r. Expected %r. " - "Is this module globally installed?") - raise ImportError(msg % (mod_name, module_dir, expected_dir)) + msg = ( + "%r module incorrectly imported from %r. Expected %r. " + "Is this module globally installed?") + raise ImportError(msg % + (mod_name, module_dir, expected_dir)) yield self.loadTestsFromModule(module) elif os.path.isdir(full_path): if not os.path.isfile(os.path.join(full_path, '__init__.py')): @@ -271,11 +285,13 @@ class TestLoader(unittest.TestLoader): load_tests = None tests = None if fnmatch(path, pattern): - # only check load_tests if the package directory itself matches the filter + # only check load_tests if the package directory itself + # matches the filter name = self._get_name_from_path(full_path) package = self._get_module_from_name(name) load_tests = getattr(package, 'load_tests', None) - tests = self.loadTestsFromModule(package, use_load_tests=False) + tests = self.loadTestsFromModule( + package, use_load_tests=False) if load_tests is None: if tests is not None: @@ -302,13 +318,22 @@ def _makeLoader(prefix, sortUsing, suiteClass=None): loader.suiteClass = suiteClass return loader + def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp_): return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass) + def makeSuite(testCaseClass, prefix='test', sortUsing=cmp_, suiteClass=suite.TestSuite): - return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass) + return _makeLoader( + prefix, + sortUsing, + suiteClass).loadTestsFromTestCase(testCaseClass) + def findTestCases(module, prefix='test', sortUsing=cmp_, suiteClass=suite.TestSuite): - return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module) + return _makeLoader( + prefix, + sortUsing, + suiteClass).loadTestsFromModule(module) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/main.py b/lldb/third_party/Python/module/unittest2/unittest2/main.py index d74b01f9ac23..76e3e7323a85 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/main.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/main.py @@ -13,8 +13,8 @@ except ImportError: __unittest = True -FAILFAST = " -f, --failfast Stop on first failure\n" -CATCHBREAK = " -c, --catch Catch control-C and display results\n" +FAILFAST = " -f, --failfast Stop on first failure\n" +CATCHBREAK = " -c, --catch Catch control-C and display results\n" BUFFEROUTPUT = " -b, --buffer Buffer stdout and stderr during test runs\n" USAGE_AS_MAIN = """\ @@ -69,7 +69,7 @@ class TestProgram(object): for making test modules conveniently executable. """ USAGE = USAGE_FROM_MODULE - + # defaults for testing failfast = catchbreak = buffer = progName = None @@ -103,11 +103,11 @@ class TestProgram(object): print(msg) usage = {'progName': self.progName, 'catchbreak': '', 'failfast': '', 'buffer': ''} - if self.failfast != False: + if self.failfast: usage['failfast'] = FAILFAST - if self.catchbreak != False and installHandler is not None: + if self.catchbreak and installHandler is not None: usage['catchbreak'] = CATCHBREAK - if self.buffer != False: + if self.buffer: usage['buffer'] = BUFFEROUTPUT print(self.USAGE % usage) sys.exit(2) @@ -122,21 +122,21 @@ class TestProgram(object): try: options, args = getopt.getopt(argv[1:], 'hHvqfcb', long_opts) for opt, value in options: - if opt in ('-h','-H','--help'): + if opt in ('-h', '-H', '--help'): self.usageExit() - if opt in ('-q','--quiet'): + if opt in ('-q', '--quiet'): self.verbosity = 0 - if opt in ('-v','--verbose'): + if opt in ('-v', '--verbose'): self.verbosity = 2 - if opt in ('-f','--failfast'): + if opt in ('-f', '--failfast'): if self.failfast is None: self.failfast = True # Should this raise an exception if -f is not valid? - if opt in ('-c','--catch'): + if opt in ('-c', '--catch'): if self.catchbreak is None and installHandler is not None: self.catchbreak = True # Should this raise an exception if -c is not valid? - if opt in ('-b','--buffer'): + if opt in ('-b', '--buffer'): if self.buffer is None: self.buffer = True # Should this raise an exception if -b is not valid? @@ -169,24 +169,40 @@ class TestProgram(object): parser.prog = self.progName parser.add_option('-v', '--verbose', dest='verbose', default=False, help='Verbose output', action='store_true') - if self.failfast != False: - parser.add_option('-f', '--failfast', dest='failfast', default=False, - help='Stop on first fail or error', - action='store_true') - if self.catchbreak != False and installHandler is not None: - parser.add_option('-c', '--catch', dest='catchbreak', default=False, - help='Catch ctrl-C and display results so far', - action='store_true') - if self.buffer != False: + if self.failfast: + parser.add_option( + '-f', + '--failfast', + dest='failfast', + default=False, + help='Stop on first fail or error', + action='store_true') + if self.catchbreak and installHandler is not None: + parser.add_option( + '-c', + '--catch', + dest='catchbreak', + default=False, + help='Catch ctrl-C and display results so far', + action='store_true') + if self.buffer: parser.add_option('-b', '--buffer', dest='buffer', default=False, - help='Buffer stdout and stderr during tests', + help='Buffer stdout and stderr during tests', action='store_true') parser.add_option('-s', '--start-directory', dest='start', default='.', help="Directory to start discovery ('.' default)") - parser.add_option('-p', '--pattern', dest='pattern', default='test*.py', - help="Pattern to match tests ('test*.py' default)") - parser.add_option('-t', '--top-level-directory', dest='top', default=None, - help='Top level directory of project (defaults to start directory)') + parser.add_option( + '-p', + '--pattern', + dest='pattern', + default='test*.py', + help="Pattern to match tests ('test*.py' default)") + parser.add_option( + '-t', + '--top-level-directory', + dest='top', + default=None, + help='Top level directory of project (defaults to start directory)') options, args = parser.parse_args(argv) if len(args) > 3: @@ -194,7 +210,7 @@ class TestProgram(object): for name, value in zip(('start', 'pattern', 'top'), args): setattr(options, name, value) - + # only set options from the parsing here # if they weren't set explicitly in the constructor if self.failfast is None: @@ -203,7 +219,7 @@ class TestProgram(object): self.catchbreak = options.catchbreak if self.buffer is None: self.buffer = options.buffer - + if options.verbose: self.verbosity = 2 @@ -236,7 +252,7 @@ class TestProgram(object): main = TestProgram + def main_(): TestProgram.USAGE = USAGE_AS_MAIN main(module=None) - diff --git a/lldb/third_party/Python/module/unittest2/unittest2/result.py b/lldb/third_party/Python/module/unittest2/unittest2/result.py index 2e4994d1d825..9d76429fb4ad 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/result.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/result.py @@ -13,6 +13,7 @@ from unittest2.compatibility import wraps __unittest = True + def failfast(method): @wraps(method) def inner(self, *args, **kw): @@ -25,6 +26,7 @@ def failfast(method): STDOUT_LINE = '\nStdout:\n%s' STDERR_LINE = '\nStderr:\n%s' + class TestResult(unittest.TestResult): """Holder for test result information. @@ -38,7 +40,7 @@ class TestResult(unittest.TestResult): """ _previousTestClass = None _moduleSetUpFailed = False - + def __init__(self): self.failfast = False self.failures = [] @@ -56,7 +58,7 @@ class TestResult(unittest.TestResult): self._original_stdout = sys.stdout self._original_stderr = sys.stderr self._mirrorOutput = False - + def startTest(self, test): "Called when the given test is about to be run" self.testsRun += 1 @@ -88,7 +90,7 @@ class TestResult(unittest.TestResult): if not error.endswith('\n'): error += '\n' self._original_stderr.write(STDERR_LINE % error) - + sys.stdout = self._original_stdout sys.stderr = self._original_stderr self._stdout_buffer.seek(0) @@ -96,7 +98,6 @@ class TestResult(unittest.TestResult): self._stderr_buffer.seek(0) self._stderr_buffer.truncate() self._mirrorOutput = False - def stopTestRun(self): """Called once after all tests are executed. @@ -165,10 +166,10 @@ class TestResult(unittest.TestResult): msgLines = traceback.format_exception(exctype, value, tb, length) else: msgLines = traceback.format_exception(exctype, value, tb) - + if self.buffer: output = sys.stdout.getvalue() - error = sys.stderr.getvalue() + error = sys.stderr.getvalue() if output: if not output.endswith('\n'): output += '\n' diff --git a/lldb/third_party/Python/module/unittest2/unittest2/runner.py b/lldb/third_party/Python/module/unittest2/unittest2/runner.py index db0f89d26ec4..93fc104a5861 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/runner.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/runner.py @@ -12,24 +12,25 @@ try: except ImportError: def registerResult(_): pass - + __unittest = True class _WritelnDecorator(object): """Used to decorate file-like objects with a handy 'writeln' method""" - def __init__(self,stream): + + def __init__(self, stream): self.stream = stream def __getattr__(self, attr): if attr in ('stream', '__getstate__'): raise AttributeError(attr) - return getattr(self.stream,attr) + return getattr(self.stream, attr) def writeln(self, arg=None): if arg: self.write(arg) - self.write('\n') # text-mode streams translate to \r\n if needed + self.write('\n') # text-mode streams translate to \r\n if needed class TextTestResult(result.TestResult): @@ -49,8 +50,9 @@ class TextTestResult(result.TestResult): self.progressbar = None if self.dots: - self.stream.writeln(".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success"); - self.stream.writeln(""); + self.stream.writeln( + ".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success") + self.stream.writeln("") self.stream.flush() def getDescription(self, test): @@ -67,7 +69,7 @@ class TextTestResult(result.TestResult): self.stream.write(" ... ") self.stream.flush() - def newTestResult(self,test,result_short,result_long): + def newTestResult(self, test, result_short, result_long): if self.showAll: self.stream.writeln(result_long) elif self.progressbar: @@ -81,29 +83,29 @@ class TextTestResult(result.TestResult): def addSuccess(self, test): super(TextTestResult, self).addSuccess(test) if self.progressbar: - self.newTestResult(test,"ok","ok") + self.newTestResult(test, "ok", "ok") else: - self.newTestResult(test,".","ok") + self.newTestResult(test, ".", "ok") def addError(self, test, err): super(TextTestResult, self).addError(test, err) - self.newTestResult(test,"E","ERROR") + self.newTestResult(test, "E", "ERROR") def addFailure(self, test, err): super(TextTestResult, self).addFailure(test, err) - self.newTestResult(test,"F","FAILURE") + self.newTestResult(test, "F", "FAILURE") def addSkip(self, test, reason): super(TextTestResult, self).addSkip(test, reason) - self.newTestResult(test,"s","skipped %r" % (reason,)) + self.newTestResult(test, "s", "skipped %r" % (reason,)) def addExpectedFailure(self, test, err, bugnumber): super(TextTestResult, self).addExpectedFailure(test, err, bugnumber) - self.newTestResult(test,"x","expected failure") + self.newTestResult(test, "x", "expected failure") def addUnexpectedSuccess(self, test, bugnumber): super(TextTestResult, self).addUnexpectedSuccess(test, bugnumber) - self.newTestResult(test,"u","unexpected success") + self.newTestResult(test, "u", "unexpected success") def printErrors(self): if self.progressbar: @@ -117,7 +119,8 @@ class TextTestResult(result.TestResult): def printErrorList(self, flavour, errors): for test, err in errors: self.stream.writeln(self.separator1) - self.stream.writeln("%s: %s" % (flavour, self.getDescription(test))) + self.stream.writeln("%s: %s" % + (flavour, self.getDescription(test))) self.stream.writeln(self.separator2) self.stream.writeln("%s" % err) @@ -135,7 +138,7 @@ class TextTestRunner(unittest.TextTestRunner): resultclass = TextTestResult def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1, - failfast=False, buffer=False, resultclass=None): + failfast=False, buffer=False, resultclass=None): self.stream = _WritelnDecorator(stream) self.descriptions = descriptions self.verbosity = verbosity @@ -153,7 +156,7 @@ class TextTestRunner(unittest.TextTestRunner): result.failfast = self.failfast result.buffer = self.buffer registerResult(result) - + startTime = time.time() startTestRun = getattr(result, 'startTestRun', None) if startTestRun is not None: @@ -174,7 +177,7 @@ class TextTestRunner(unittest.TextTestRunner): self.stream.writeln("Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)) self.stream.writeln() - + expectedFails = unexpectedSuccesses = skipped = passed = failed = errored = 0 try: results = map(len, (result.expectedFailures, diff --git a/lldb/third_party/Python/module/unittest2/unittest2/signals.py b/lldb/third_party/Python/module/unittest2/unittest2/signals.py index e40328dea7a9..dc0dc3daf3bd 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/signals.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/signals.py @@ -7,6 +7,7 @@ __unittest = True class _InterruptHandler(object): + def __init__(self, default_handler): self.called = False self.default_handler = default_handler @@ -17,7 +18,7 @@ class _InterruptHandler(object): # if we aren't the installed handler, then delegate immediately # to the default handler self.default_handler(signum, frame) - + if self.called: self.default_handler(signum, frame) self.called = True @@ -25,13 +26,18 @@ class _InterruptHandler(object): result.stop() _results = weakref.WeakKeyDictionary() + + def registerResult(result): _results[result] = 1 + def removeResult(result): return bool(_results.pop(result, None)) _interrupt_handler = None + + def installHandler(): global _interrupt_handler if _interrupt_handler is None: diff --git a/lldb/third_party/Python/module/unittest2/unittest2/suite.py b/lldb/third_party/Python/module/unittest2/unittest2/suite.py index 9fda66aa09e5..6b50680ec098 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/suite.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/suite.py @@ -11,6 +11,7 @@ __unittest = True class BaseTestSuite(unittest.TestSuite): """A simple test suite that doesn't provide class or module shared fixtures. """ + def __init__(self, tests=()): self._tests = [] self.addTests(tests) @@ -79,7 +80,6 @@ class TestSuite(BaseTestSuite): in the order in which they were added, aggregating the results. When subclassing, do not forget to call the base class constructor. """ - def run(self, result): self._wrapped_run(result) @@ -100,24 +100,24 @@ class TestSuite(BaseTestSuite): for test in self: if result.shouldStop: break - + if _isnotsuite(test): self._tearDownPreviousClass(test, result) self._handleModuleFixture(test, result) self._handleClassSetUp(test, result) result._previousTestClass = test.__class__ - - if (getattr(test.__class__, '_classSetupFailed', False) or - getattr(result, '_moduleSetUpFailed', False)): + + if (getattr(test.__class__, '_classSetupFailed', False) or + getattr(result, '_moduleSetUpFailed', False)): continue - + if hasattr(test, '_wrapped_run'): test._wrapped_run(result, debug) elif not debug: test(result) else: test.debug() - + def _handleClassSetUp(self, test, result): previousClass = getattr(result, '_previousTestClass', None) currentClass = test.__class__ @@ -127,14 +127,14 @@ class TestSuite(BaseTestSuite): return if getattr(currentClass, "__unittest_skip__", False): return - + try: currentClass._classSetupFailed = False except TypeError: # test may actually be a function # so its class will be a builtin-type pass - + setUpClass = getattr(currentClass, 'setUpClass', None) if setUpClass is not None: try: @@ -146,24 +146,22 @@ class TestSuite(BaseTestSuite): className = util.strclass(currentClass) errorName = 'setUpClass (%s)' % className self._addClassOrModuleLevelException(result, e, errorName) - + def _get_previous_module(self, result): previousModule = None previousClass = getattr(result, '_previousTestClass', None) if previousClass is not None: previousModule = previousClass.__module__ return previousModule - - + def _handleModuleFixture(self, test, result): previousModule = self._get_previous_module(result) currentModule = test.__class__.__module__ if currentModule == previousModule: return - + self._handleModuleTearDown(result) - result._moduleSetUpFailed = False try: module = sys.modules[currentModule] @@ -187,14 +185,14 @@ class TestSuite(BaseTestSuite): addSkip(error, str(exception)) else: result.addError(error, sys.exc_info()) - + def _handleModuleTearDown(self, result): previousModule = self._get_previous_module(result) if previousModule is None: return if result._moduleSetUpFailed: return - + try: module = sys.modules[previousModule] except KeyError: @@ -209,7 +207,7 @@ class TestSuite(BaseTestSuite): raise errorName = 'tearDownModule (%s)' % previousModule self._addClassOrModuleLevelException(result, e, errorName) - + def _tearDownPreviousClass(self, test, result): previousClass = getattr(result, '_previousTestClass', None) currentClass = test.__class__ @@ -221,7 +219,7 @@ class TestSuite(BaseTestSuite): return if getattr(previousClass, "__unittest_skip__", False): return - + tearDownClass = getattr(previousClass, 'tearDownClass', None) if tearDownClass is not None: try: @@ -272,6 +270,7 @@ class _ErrorHolder(object): def countTestCases(self): return 0 + def _isnotsuite(test): "A crude way to tell apart testcases and suites with duck-typing" try: diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py index 4287ca861797..792d6005489e 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py @@ -1 +1 @@ -#
\ No newline at end of file +# diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py b/lldb/third_party/Python/module/unittest2/unittest2/test/support.py index eec6eec77907..5c9bcf274963 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/support.py @@ -7,6 +7,7 @@ import unittest2 def resultFactory(*_): return unittest2.TestResult() + class OldTestResult(object): """An object honouring TestResult before startTestRun/stopTestRun.""" @@ -37,7 +38,9 @@ class OldTestResult(object): def printErrors(self): pass + class LoggingResult(unittest2.TestResult): + def __init__(self, log): self._events = log super(LoggingResult, self).__init__() @@ -98,6 +101,7 @@ class EqualityMixin(object): self.assertNotEqual(obj_1, obj_2) self.assertNotEqual(obj_2, obj_1) + class HashingMixin(object): """Used as a mixin for TestCase""" @@ -123,24 +127,24 @@ class HashingMixin(object): self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e)) - # copied from Python 2.6 try: from warnings import catch_warnings except ImportError: class catch_warnings(object): + def __init__(self, record=False, module=None): self._record = record self._module = sys.modules['warnings'] self._entered = False - + def __repr__(self): args = [] if self._record: args.append("record=True") name = type(self).__name__ return "%s(%s)" % (name, ", ".join(args)) - + def __enter__(self): if self._entered: raise RuntimeError("Cannot enter %r twice" % self) @@ -150,28 +154,36 @@ except ImportError: self._showwarning = self._module.showwarning if self._record: log = [] + def showwarning(*args, **kwargs): log.append(WarningMessage(*args, **kwargs)) self._module.showwarning = showwarning return log else: return None - + def __exit__(self, *exc_info): if not self._entered: - raise RuntimeError("Cannot exit %r without entering first" % self) + raise RuntimeError( + "Cannot exit %r without entering first" % + self) self._module.filters = self._filters self._module.showwarning = self._showwarning class WarningMessage(object): - _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file", - "line") + _WARNING_DETAILS = ( + "message", + "category", + "filename", + "lineno", + "file", + "line") + def __init__(self, message, category, filename, lineno, file=None, - line=None): + line=None): local_values = locals() for attr in self._WARNING_DETAILS: setattr(self, attr, local_values[attr]) self._category_name = None if category.__name__: self._category_name = category.__name__ - diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py index d71326b218a9..c96aaafa082e 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py @@ -4,6 +4,7 @@ import unittest2 class Test_Assertions(unittest2.TestCase): + def test_AlmostEqual(self): self.assertAlmostEqual(1.00000001, 1.0) self.assertNotAlmostEqual(1.0000001, 1.0) @@ -16,12 +17,12 @@ class Test_Assertions(unittest2.TestCase): self.assertRaises(self.failureException, self.assertAlmostEqual, 1.1, 1.0, places=1) - self.assertAlmostEqual(0, .1+.1j, places=0) - self.assertNotAlmostEqual(0, .1+.1j, places=1) + self.assertAlmostEqual(0, .1 + .1j, places=0) + self.assertNotAlmostEqual(0, .1 + .1j, places=1) self.assertRaises(self.failureException, - self.assertAlmostEqual, 0, .1+.1j, places=1) + self.assertAlmostEqual, 0, .1 + .1j, places=1) self.assertRaises(self.failureException, - self.assertNotAlmostEqual, 0, .1+.1j, places=0) + self.assertNotAlmostEqual, 0, .1 + .1j, places=0) try: self.assertAlmostEqual(float('inf'), float('inf')) @@ -33,24 +34,23 @@ class Test_Assertions(unittest2.TestCase): self.assertAlmostEqual(x, x) self.assertRaises(self.failureException, self.assertNotAlmostEqual, x, x) - - + def test_AmostEqualWithDelta(self): self.assertAlmostEqual(1.1, 1.0, delta=0.5) self.assertAlmostEqual(1.0, 1.1, delta=0.5) self.assertNotAlmostEqual(1.1, 1.0, delta=0.05) self.assertNotAlmostEqual(1.0, 1.1, delta=0.05) - + self.assertRaises(self.failureException, self.assertAlmostEqual, 1.1, 1.0, delta=0.05) self.assertRaises(self.failureException, self.assertNotAlmostEqual, 1.1, 1.0, delta=0.5) - + self.assertRaises(TypeError, self.assertAlmostEqual, 1.1, 1.0, places=2, delta=2) self.assertRaises(TypeError, self.assertNotAlmostEqual, 1.1, 1.0, places=2, delta=2) - + first = datetime.datetime.now() second = first + datetime.timedelta(seconds=10) self.assertAlmostEqual(first, second, @@ -96,18 +96,24 @@ class TestLongMessage(unittest2.TestCase): self.assertTrue(unittest2.TestCase.longMessage) def test_formatMsg(self): - self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo") + self.assertEquals( + self.testableFalse._formatMessage( + None, "foo"), "foo") + self.assertEquals( + self.testableFalse._formatMessage( + "foo", "bar"), "foo") self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") - + self.assertEquals( + self.testableTrue._formatMessage( + "foo", "bar"), "bar : foo") + # This blows up if _formatMessage uses string concatenation self.testableTrue._formatMessage(object(), 'foo') def assertMessages(self, methodName, args, errors): def getMethod(i): - useTestableFalse = i < 2 + useTestableFalse = i < 2 if useTestableFalse: test = self.testableFalse else: @@ -124,7 +130,7 @@ class TestLongMessage(unittest2.TestCase): self.assertRaisesRegexp(self.failureException, expected_regexp, lambda: testMethod(*args, **kwargs)) - + def testAssertTrue(self): self.assertMessages('assertTrue', (False,), ["^False is not True$", "^oops$", "^False is not True$", @@ -141,18 +147,27 @@ class TestLongMessage(unittest2.TestCase): "^1 == 1 : oops$"]) def testAlmostEqual(self): - self.assertMessages('assertAlmostEqual', (1, 2), - ["^1 != 2 within 7 places$", "^oops$", - "^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"]) + self.assertMessages('assertAlmostEqual', + (1, + 2), + ["^1 != 2 within 7 places$", + "^oops$", + "^1 != 2 within 7 places$", + "^1 != 2 within 7 places : oops$"]) def testNotAlmostEqual(self): - self.assertMessages('assertNotAlmostEqual', (1, 1), - ["^1 == 1 within 7 places$", "^oops$", - "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"]) + self.assertMessages('assertNotAlmostEqual', + (1, + 1), + ["^1 == 1 within 7 places$", + "^oops$", + "^1 == 1 within 7 places$", + "^1 == 1 within 7 places : oops$"]) def test_baseAssertEqual(self): - self.assertMessages('_baseAssertEqual', (1, 2), - ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"]) + self.assertMessages( + '_baseAssertEqual', (1, 2), [ + "^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"]) def testAssertSequenceEqual(self): # Error messages are multiline so not testing on full message diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py index 1f7864b7a415..390718da22ce 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py @@ -13,33 +13,32 @@ import unittest2 class TestBreak(unittest2.TestCase): - + def setUp(self): self._default_handler = signal.getsignal(signal.SIGINT) - + def tearDown(self): signal.signal(signal.SIGINT, self._default_handler) unittest2.signals._results = weakref.WeakKeyDictionary() unittest2.signals._interrupt_handler = None - def testInstallHandler(self): default_handler = signal.getsignal(signal.SIGINT) unittest2.installHandler() self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + try: pid = os.getpid() os.kill(pid, signal.SIGINT) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") - + self.assertTrue(unittest2.signals._interrupt_handler.called) - + def testRegisterResult(self): result = unittest2.TestResult() unittest2.registerResult(result) - + for ref in unittest2.signals._results: if ref is result: break @@ -47,35 +46,33 @@ class TestBreak(unittest2.TestCase): self.fail("odd object in result set") else: self.fail("result not found") - - + def testInterruptCaught(self): default_handler = signal.getsignal(signal.SIGINT) - + result = unittest2.TestResult() unittest2.installHandler() unittest2.registerResult(result) - + self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) result.breakCaught = True self.assertTrue(result.shouldStop) - + try: test(result) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") self.assertTrue(result.breakCaught) - - + def testSecondInterrupt(self): result = unittest2.TestResult() unittest2.installHandler() unittest2.registerResult(result) - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) @@ -83,7 +80,7 @@ class TestBreak(unittest2.TestCase): self.assertTrue(result.shouldStop) os.kill(pid, signal.SIGINT) self.fail("Second KeyboardInterrupt not raised") - + try: test(result) except KeyboardInterrupt: @@ -92,45 +89,44 @@ class TestBreak(unittest2.TestCase): self.fail("Second KeyboardInterrupt not raised") self.assertTrue(result.breakCaught) - def testTwoResults(self): unittest2.installHandler() - + result = unittest2.TestResult() unittest2.registerResult(result) new_handler = signal.getsignal(signal.SIGINT) - + result2 = unittest2.TestResult() unittest2.registerResult(result2) self.assertEqual(signal.getsignal(signal.SIGINT), new_handler) - + result3 = unittest2.TestResult() - + def test(result): pid = os.getpid() os.kill(pid, signal.SIGINT) - + try: test(result) except KeyboardInterrupt: self.fail("KeyboardInterrupt not handled") - + self.assertTrue(result.shouldStop) self.assertTrue(result2.shouldStop) self.assertFalse(result3.shouldStop) - - + def testHandlerReplacedButCalled(self): # If our handler has been replaced (is no longer installed) but is # called by the *new* handler, then it isn't safe to delay the # SIGINT and we should immediately delegate to the default handler unittest2.installHandler() - + handler = signal.getsignal(signal.SIGINT) + def new_handler(frame, signum): handler(frame, signum) signal.signal(signal.SIGINT, new_handler) - + try: pid = os.getpid() os.kill(pid, signal.SIGINT) @@ -138,35 +134,35 @@ class TestBreak(unittest2.TestCase): pass else: self.fail("replaced but delegated handler doesn't raise interrupt") - + def testRunner(self): # Creating a TextTestRunner with the appropriate argument should # register the TextTestResult it creates runner = unittest2.TextTestRunner(stream=StringIO()) - + result = runner.run(unittest2.TestSuite()) self.assertIn(result, unittest2.signals._results) - + def testWeakReferences(self): # Calling registerResult on a result should not keep it alive result = unittest2.TestResult() unittest2.registerResult(result) - + ref = weakref.ref(result) del result - + # For non-reference counting implementations - gc.collect();gc.collect() + gc.collect() + gc.collect() self.assertIsNone(ref()) - - + def testRemoveResult(self): result = unittest2.TestResult() unittest2.registerResult(result) - + unittest2.installHandler() self.assertTrue(unittest2.removeResult(result)) - + # Should this raise an error instead? self.assertFalse(unittest2.removeResult(unittest2.TestResult())) @@ -175,9 +171,9 @@ class TestBreak(unittest2.TestCase): os.kill(pid, signal.SIGINT) except KeyboardInterrupt: pass - + self.assertFalse(result.shouldStop) - + def testMainInstallsHandler(self): failfast = object() test = object() @@ -188,14 +184,17 @@ class TestBreak(unittest2.TestCase): class FakeRunner(object): initArgs = [] runArgs = [] + def __init__(self, *args, **kwargs): self.initArgs.append((args, kwargs)) + def run(self, test): self.runArgs.append(test) return result - + class Program(unittest2.TestProgram): - def __init__(self, catchbreak): + + def __init__(self, catchbreak): self.exit = False self.verbosity = verbosity self.failfast = failfast @@ -203,31 +202,30 @@ class TestBreak(unittest2.TestCase): self.testRunner = FakeRunner self.test = test self.result = None - + p = Program(False) p.runTests() - - self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, - 'failfast': failfast, - 'buffer': None})]) + + self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, + 'failfast': failfast, + 'buffer': None})]) self.assertEqual(FakeRunner.runArgs, [test]) self.assertEqual(p.result, result) - + self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + FakeRunner.initArgs = [] FakeRunner.runArgs = [] p = Program(True) p.runTests() - - self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, - 'failfast': failfast, - 'buffer': None})]) + + self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity, + 'failfast': failfast, + 'buffer': None})]) self.assertEqual(FakeRunner.runArgs, [test]) self.assertEqual(p.result, result) - - self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) + self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) def testRemoveHandler(self): default_handler = signal.getsignal(signal.SIGINT) @@ -238,21 +236,21 @@ class TestBreak(unittest2.TestCase): # check that calling removeHandler multiple times has no ill-effect unittest2.removeHandler() self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + def testRemoveHandlerAsDecorator(self): default_handler = signal.getsignal(signal.SIGINT) unittest2.installHandler() - + @unittest2.removeHandler def test(): self.assertEqual(signal.getsignal(signal.SIGINT), default_handler) - + test() self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler) - + # Should also skip some tests on Jython -skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None, +skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None, "test uses os.kill(...) and the signal module") TestBreak = skipper(TestBreak) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py index 5f310ecb046e..acf7e4edc57b 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py @@ -20,10 +20,13 @@ class Test(object): "Keep these TestCase classes out of the main namespace" class Foo(unittest2.TestCase): + def runTest(self): pass + def test1(self): pass class Bar(Foo): + def test2(self): pass class LoggingTestCase(unittest2.TestCase): @@ -43,11 +46,11 @@ class Test(object): self.events.append('tearDown') - class TestCleanUp(unittest2.TestCase): def testCleanUp(self): class TestableTest(unittest2.TestCase): + def testNothing(self): pass @@ -65,22 +68,28 @@ class TestCleanUp(unittest2.TestCase): test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye') test.addCleanup(cleanup2) - self.assertEqual(test._cleanups, - [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')), - (cleanup2, (), {})]) + self.assertEqual( + test._cleanups, [ + (cleanup1, (1, 2, 3), dict( + four='hello', five='goodbye')), (cleanup2, (), {})]) result = test.doCleanups() self.assertTrue(result) - self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), dict(four='hello', five='goodbye'))]) + self.assertEqual( + cleanups, [ + (2, (), {}), (1, (1, 2, 3), dict( + four='hello', five='goodbye'))]) def testCleanUpWithErrors(self): class TestableTest(unittest2.TestCase): + def testNothing(self): pass class MockResult(object): errors = [] + def addError(self, test, exc_info): self.errors.append((test, exc_info)) @@ -90,6 +99,7 @@ class TestCleanUp(unittest2.TestCase): exc1 = Exception('foo') exc2 = Exception('bar') + def cleanup1(): raise exc1 @@ -101,7 +111,8 @@ class TestCleanUp(unittest2.TestCase): self.assertFalse(test.doCleanups()) - (test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors) + (test1, (Type1, instance1, _)), (test2, + (Type2, instance2, _)) = reversed(MockResult.errors) self.assertEqual((test1, Type1, instance1), (test, Exception, exc1)) self.assertEqual((test2, Type2, instance2), (test, Exception, exc2)) @@ -110,6 +121,7 @@ class TestCleanUp(unittest2.TestCase): ordering = [] class TestableTest(unittest2.TestCase): + def setUp(self): ordering.append('setUp') if blowUp: @@ -125,6 +137,7 @@ class TestCleanUp(unittest2.TestCase): def cleanup1(): ordering.append('cleanup1') + def cleanup2(): ordering.append('cleanup2') test.addCleanup(cleanup1) @@ -152,6 +165,7 @@ class TestCleanUp(unittest2.TestCase): ordering = [] class TestableTest(unittest2.TestCase): + def setUp(self): ordering.append('setUp') self.addCleanup(cleanup1) @@ -167,16 +181,19 @@ class TestCleanUp(unittest2.TestCase): def cleanup1(): ordering.append('cleanup1') test.addCleanup(cleanup2) + def cleanup2(): ordering.append('cleanup2') test.debug() - self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2']) + self.assertEqual( + ordering, [ + 'setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2']) class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): - ### Set up attributes used by inherited tests + # Set up attributes used by inherited tests ################################################################ # Used by HashingMixin.test_hash and EqualityMixin.test_eq @@ -188,8 +205,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): (Test.Foo('test1'), Test.Bar('test2'))] ################################################################ - ### /Set up attributes used by inherited tests - + # /Set up attributes used by inherited tests # "class TestCase([methodName])" # ... @@ -202,7 +218,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # thing. def test_init__no_test_name(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass self.assertEqual(Test().id()[-13:], '.Test.runTest') @@ -213,7 +231,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # method named methodName." def test_init__test_name__valid(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass self.assertEqual(Test('test').id()[-10:], '.Test.test') @@ -224,7 +244,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # method named methodName." def test_init__test_name__invalid(self): class Test(unittest2.TestCase): + def runTest(self): raise MyException() + def test(self): pass try: @@ -238,6 +260,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # TestCase instances, this will always be 1" def test_countTestCases(self): class Foo(unittest2.TestCase): + def test(self): pass self.assertEqual(Foo('test').countTestCases(), 1) @@ -248,6 +271,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # override this as necessary." def test_defaultTestResult(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -266,6 +290,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def setUp(self): super(Foo, self).setUp() raise RuntimeError('raised by Foo.setUp') @@ -279,6 +304,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) @@ -303,6 +329,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def test(self): super(Foo, self).test() raise RuntimeError('raised by Foo.test') @@ -318,6 +345,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) @@ -342,6 +370,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def test(self): super(Foo, self).test() self.fail('raised by Foo.test') @@ -355,8 +384,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order__failure_in_test_default_result(self): class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) + def test(self): super(Foo, self).test() self.fail('raised by Foo.test') @@ -379,6 +410,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(Test.LoggingTestCase): + def tearDown(self): super(Foo, self).tearDown() raise RuntimeError('raised by Foo.tearDown') @@ -392,8 +424,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order__error_in_tearDown_default_result(self): class Foo(Test.LoggingTestCase): + def defaultTestResult(self): return LoggingResult(self.events) + def tearDown(self): super(Foo, self).tearDown() raise RuntimeError('raised by Foo.tearDown') @@ -409,8 +443,10 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def test_run_call_order_default_result(self): class Foo(unittest2.TestCase): + def defaultTestResult(self): return OldTestResult() + def test(self): pass @@ -423,6 +459,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # attribute is AssertionError" def test_failureException__default(self): class Foo(unittest2.TestCase): + def test(self): pass @@ -439,6 +476,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(unittest2.TestCase): + def test(self): raise RuntimeError() @@ -446,7 +484,6 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertTrue(Foo('test').failureException is RuntimeError) - Foo('test').run(result) expected = ['startTest', 'addFailure', 'stopTest'] self.assertEqual(events, expected) @@ -462,6 +499,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): result = LoggingResult(events) class Foo(unittest2.TestCase): + def test(self): self.fail("foo") @@ -469,7 +507,6 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertTrue(Foo('test').failureException is RuntimeError) - Foo('test').run(result) expected = ['startTest', 'addFailure', 'stopTest'] self.assertEqual(events, expected) @@ -477,6 +514,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # "The default implementation does nothing." def test_setUp(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -486,6 +524,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # "The default implementation does nothing." def test_tearDown(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -500,6 +539,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): # just say "string") def test_id(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -513,6 +553,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): events = [] class Foo(unittest2.TestCase): + def test(self): events.append('test') @@ -523,7 +564,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): Foo('test').run() expected = ['startTestRun', 'startTest', 'test', 'addSuccess', - 'stopTest', 'stopTestRun'] + 'stopTest', 'stopTestRun'] self.assertEqual(events, expected) def testShortDescriptionWithoutDocstring(self): @@ -532,8 +573,8 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def testShortDescriptionWithOneLineDocstring(self): """Tests shortDescription() for a method with a docstring.""" self.assertEqual( - self.shortDescription(), - 'Tests shortDescription() for a method with a docstring.') + self.shortDescription(), + 'Tests shortDescription() for a method with a docstring.') def testShortDescriptionWithMultiLineDocstring(self): """Tests shortDescription() for a method with a longer docstring. @@ -543,15 +584,16 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): whole thing is. """ self.assertEqual( - self.shortDescription(), - 'Tests shortDescription() for a method with a longer ' - 'docstring.') + self.shortDescription(), + 'Tests shortDescription() for a method with a longer ' + 'docstring.') def testAddTypeEqualityFunc(self): class SadSnake(object): """Dummy class for test_addTypeEqualityFunc.""" s1, s2 = SadSnake(), SadSnake() self.assertNotEqual(s1, s2) + def AllSnakesCreatedEqual(a, b, msg=None): return type(a) is type(b) is SadSnake self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual) @@ -563,12 +605,20 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): def testAssertIs(self): thing = object() self.assertIs(thing, thing) - self.assertRaises(self.failureException, self.assertIs, thing, object()) + self.assertRaises( + self.failureException, + self.assertIs, + thing, + object()) def testAssertIsNot(self): thing = object() self.assertIsNot(thing, object()) - self.assertRaises(self.failureException, self.assertIsNot, thing, thing) + self.assertRaises( + self.failureException, + self.assertIsNot, + thing, + thing) def testAssertIsInstance(self): thing = [] @@ -599,7 +649,9 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): animals) self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc') - self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3]) + self.assertRaises( + self.failureException, self.assertNotIn, 1, [ + 1, 2, 3]) self.assertRaises(self.failureException, self.assertNotIn, 'cow', animals) @@ -625,17 +677,17 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertRaises(unittest2.TestCase.failureException, self.assertDictContainsSubset, {'a': 1, 'c': 1}, {'a': 1}, '.*Missing:.*Mismatched values:.*') - + self.assertRaises(self.failureException, self.assertDictContainsSubset, {1: "one"}, {}) def testAssertEqual(self): equal_pairs = [ - ((), ()), - ({}, {}), - ([], []), - (set(), set()), - (frozenset(), frozenset())] + ((), ()), + ({}, {}), + ([], []), + (set(), set()), + (frozenset(), frozenset())] for a, b in equal_pairs: # This mess of try excepts is to test the assertEqual behavior # itself. @@ -654,11 +706,11 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): (a, b)) unequal_pairs = [ - ((), []), - ({}, set()), - (set([4,1]), frozenset([4,2])), - (frozenset([4,5]), set([2,3])), - (set([3,4]), set([5,4]))] + ((), []), + ({}, set()), + (set([4, 1]), frozenset([4, 2])), + (frozenset([4, 5]), set([2, 3])), + (set([3, 4]), set([5, 4]))] for a, b in unequal_pairs: self.assertRaises(self.failureException, self.assertEqual, a, b) self.assertRaises(self.failureException, self.assertEqual, a, b, @@ -702,7 +754,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertDictEqual({}, {}) - c = { 'x': 1 } + c = {'x': 1} d = {} self.assertRaises(unittest2.TestCase.failureException, self.assertDictEqual, c, d) @@ -734,7 +786,7 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]) self.assertRaises(self.failureException, self.assertItemsEqual, [[1]], [[2]]) - + # Test unsortable objects self.assertItemsEqual([2j, None], [None, 2j]) self.assertRaises(self.failureException, self.assertItemsEqual, @@ -745,14 +797,26 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set2 = set() self.assertSetEqual(set1, set2) - self.assertRaises(self.failureException, self.assertSetEqual, None, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + None, + set2) self.assertRaises(self.failureException, self.assertSetEqual, [], set2) - self.assertRaises(self.failureException, self.assertSetEqual, set1, None) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + None) self.assertRaises(self.failureException, self.assertSetEqual, set1, []) set1 = set(['a']) set2 = set() - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a']) set2 = set(['a']) @@ -760,11 +824,19 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set1 = set(['a']) set2 = set(['a', 'b']) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a']) set2 = frozenset(['a', 'b']) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) set1 = set(['a', 'b']) set2 = frozenset(['a', 'b']) @@ -772,13 +844,25 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): set1 = set() set2 = "foo" - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) - self.assertRaises(self.failureException, self.assertSetEqual, set2, set1) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set2, + set1) # make sure any string formatting is tuple-safe set1 = set([(0, 1), (2, 3)]) set2 = set([(4, 5)]) - self.assertRaises(self.failureException, self.assertSetEqual, set1, set2) + self.assertRaises( + self.failureException, + self.assertSetEqual, + set1, + set2) def testInequality(self): # Try ints @@ -804,10 +888,18 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLessEqual(1.0, 1.0) self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1) self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0) - self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1) + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 1.0, + 1.1) self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0) self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0) - self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0) + self.assertRaises( + self.failureException, + self.assertLessEqual, + 1.1, + 1.0) # Try Strings self.assertGreater('bug', 'ant') @@ -816,12 +908,28 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLess('ant', 'bug') self.assertLessEqual('ant', 'bug') self.assertLessEqual('ant', 'ant') - self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug') - self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 'ant', + 'bug') self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant') self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant') - self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + 'bug', + 'ant') # Try Unicode self.assertGreater(u'bug', u'ant') @@ -830,13 +938,36 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLess(u'ant', u'bug') self.assertLessEqual(u'ant', u'bug') self.assertLessEqual(u'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreater, u'ant', u'bug') - self.assertRaises(self.failureException, self.assertGreater, u'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', - u'bug') - self.assertRaises(self.failureException, self.assertLess, u'bug', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'ant', u'ant') - self.assertRaises(self.failureException, self.assertLessEqual, u'bug', u'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + u'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertLess, + u'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + u'bug', + u'ant') # Try Mixed String/Unicode self.assertGreater('bug', u'ant') @@ -851,20 +982,66 @@ class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin): self.assertLessEqual(u'ant', 'bug') self.assertLessEqual('ant', u'ant') self.assertLessEqual(u'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreater, 'ant', u'bug') - self.assertRaises(self.failureException, self.assertGreater, u'ant', 'bug') - self.assertRaises(self.failureException, self.assertGreater, 'ant', u'ant') - self.assertRaises(self.failureException, self.assertGreater, u'ant', 'ant') - self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', - u'bug') - self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant', - 'bug') - self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant') - self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant') - self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant') - self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'ant') - self.assertRaises(self.failureException, self.assertLessEqual, u'bug', 'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertGreater, + 'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertGreater, + u'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + 'ant', + u'bug') + self.assertRaises( + self.failureException, + self.assertGreaterEqual, + u'ant', + 'bug') + self.assertRaises( + self.failureException, + self.assertLess, + 'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'bug', + 'ant') + self.assertRaises( + self.failureException, + self.assertLess, + 'ant', + u'ant') + self.assertRaises( + self.failureException, + self.assertLess, + u'ant', + 'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + 'bug', + u'ant') + self.assertRaises( + self.failureException, + self.assertLessEqual, + u'bug', + 'ant') def testAssertMultiLineEqual(self): sample_text = """\ @@ -903,7 +1080,7 @@ test case self.assertTrue(sample_text_error == error) def testAssertSequenceEqualMaxDiff(self): - self.assertEqual(self.maxDiff, 80*8) + self.assertEqual(self.maxDiff, 80 * 8) seq1 = 'a' + 'x' * 80**2 seq2 = 'b' + 'x' * 80**2 diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(), @@ -911,7 +1088,7 @@ test case # the +1 is the leading \n added by assertSequenceEqual omitted = unittest2.case.DIFF_OMITTED % (len(diff) + 1,) - self.maxDiff = len(diff)//2 + self.maxDiff = len(diff) // 2 try: self.assertSequenceEqual(seq1, seq2) except self.failureException as e: @@ -957,6 +1134,7 @@ test case def testAssertDictEqualTruncates(self): test = unittest2.TestCase('assertEqual') + def truncate(msg, diff): return 'foo' test._truncateMessage = truncate @@ -969,6 +1147,7 @@ test case def testAssertMultiLineEqualTruncates(self): test = unittest2.TestCase('assertEqual') + def truncate(msg, diff): return 'foo' test._truncateMessage = truncate @@ -1003,38 +1182,37 @@ test case def testAssertNotRaisesRegexp(self): self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, re.compile('x'), - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, re.compile('x'), + lambda: None) self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, 'x', - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, 'x', + lambda: None) self.assertRaisesRegexp( - self.failureException, '^Exception not raised$', - self.assertRaisesRegexp, Exception, u'x', - lambda: None) + self.failureException, '^Exception not raised$', + self.assertRaisesRegexp, Exception, u'x', + lambda: None) def testAssertRaisesRegexpMismatch(self): def Stub(): raise Exception('Unexpected') self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, '^Expected$', - Stub) + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, '^Expected$', + Stub) self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, u'^Expected$', - Stub) + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, u'^Expected$', + Stub) self.assertRaisesRegexp( - self.failureException, - r'"\^Expected\$" does not match "Unexpected"', - self.assertRaisesRegexp, Exception, - re.compile('^Expected$'), Stub) - + self.failureException, + r'"\^Expected\$" does not match "Unexpected"', + self.assertRaisesRegexp, Exception, + re.compile('^Expected$'), Stub) def testSynonymAssertMethodNames(self): """Test undocumented method name synonyms. @@ -1053,6 +1231,7 @@ test case def testDeepcopy(self): # Issue: 5660 class TestableTest(unittest2.TestCase): + def testNothing(self): pass diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py index f78c4d826b8d..70bc588e5ac5 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py @@ -27,12 +27,15 @@ class TestDiscovery(unittest2.TestCase): loader = unittest2.TestLoader() original_listdir = os.listdir + def restore_listdir(): os.listdir = original_listdir original_isfile = os.path.isfile + def restore_isfile(): os.path.isfile = original_isfile original_isdir = os.path.isdir + def restore_isdir(): os.path.isdir = original_isdir @@ -63,19 +66,22 @@ class TestDiscovery(unittest2.TestCase): expected = [name + ' module tests' for name in ('test1', 'test2')] expected.extend([('test_dir.%s' % name) + ' module tests' for name in - ('test3', 'test4')]) + ('test3', 'test4')]) self.assertEqual(suite, expected) def test_find_tests_with_package(self): loader = unittest2.TestLoader() original_listdir = os.listdir + def restore_listdir(): os.listdir = original_listdir original_isfile = os.path.isfile + def restore_isfile(): os.path.isfile = original_isfile original_isdir = os.path.isdir + def restore_isdir(): os.path.isdir = original_isdir @@ -110,9 +116,11 @@ class TestDiscovery(unittest2.TestCase): __hash__ = None loader._get_module_from_name = lambda name: Module(name) + def loadTestsFromModule(module, use_load_tests): if use_load_tests: - raise self.failureException('use_load_tests should be False for packages') + raise self.failureException( + 'use_load_tests should be False for packages') return module.path + ' module tests' loader.loadTestsFromModule = loadTestsFromModule @@ -127,15 +135,18 @@ class TestDiscovery(unittest2.TestCase): ['load_tests', 'test_directory2' + ' module tests']) self.assertEqual(Module.paths, ['test_directory', 'test_directory2']) - # load_tests should have been called once with loader, tests and pattern - self.assertEqual(Module.load_tests_args, - [(loader, 'test_directory' + ' module tests', 'test*')]) + # load_tests should have been called once with loader, tests and + # pattern + self.assertEqual( + Module.load_tests_args, [ + (loader, 'test_directory' + ' module tests', 'test*')]) def test_discover(self): loader = unittest2.TestLoader() original_isfile = os.path.isfile original_isdir = os.path.isdir + def restore_isfile(): os.path.isfile = original_isfile @@ -143,6 +154,7 @@ class TestDiscovery(unittest2.TestCase): self.addCleanup(restore_isfile) orig_sys_path = sys.path[:] + def restore_path(): sys.path[:] = orig_sys_path self.addCleanup(restore_path) @@ -163,6 +175,7 @@ class TestDiscovery(unittest2.TestCase): self.addCleanup(restore_isdir) _find_tests_args = [] + def _find_tests(start_dir, pattern): _find_tests_args.append((start_dir, pattern)) return ['tests'] @@ -186,6 +199,7 @@ class TestDiscovery(unittest2.TestCase): isfile = os.path.isfile os.path.isfile = lambda _: True orig_sys_path = sys.path[:] + def restore(): os.path.isfile = isfile os.listdir = listdir @@ -195,16 +209,17 @@ class TestDiscovery(unittest2.TestCase): suite = loader.discover('.') self.assertIn(os.getcwd(), sys.path) self.assertEqual(suite.countTestCases(), 1) - test = list(list(suite)[0])[0] # extract test from suite + test = list(list(suite)[0])[0] # extract test from suite self.assertRaises(ImportError, - lambda: test.test_this_does_not_exist()) + lambda: test.test_this_does_not_exist()) def test_command_line_handling_parseArgs(self): # Haha - take that uninstantiable class program = object.__new__(unittest2.TestProgram) args = [] + def do_discovery(argv): args.extend(argv) program._do_discovery = do_discovery @@ -217,6 +232,7 @@ class TestDiscovery(unittest2.TestCase): def test_command_line_handling_do_discovery_too_many_arguments(self): class Stop(Exception): pass + def usageExit(): raise Stop @@ -224,15 +240,15 @@ class TestDiscovery(unittest2.TestCase): program.usageExit = usageExit self.assertRaises(Stop, - # too many args - lambda: program._do_discovery(['one', 'two', 'three', 'four'])) - + # too many args + lambda: program._do_discovery(['one', 'two', 'three', 'four'])) def test_command_line_handling_do_discovery_calls_loader(self): program = object.__new__(unittest2.TestProgram) class Loader(object): args = [] + def discover(self, start_dir, pattern, top_level_dir): self.args.append((start_dir, pattern, top_level_dir)) return 'tests' @@ -317,7 +333,7 @@ class TestDiscovery(unittest2.TestCase): original_listdir = os.listdir original_isfile = os.path.isfile original_isdir = os.path.isdir - + def cleanup(): os.listdir = original_listdir os.path.isfile = original_isfile @@ -326,37 +342,42 @@ class TestDiscovery(unittest2.TestCase): if full_path in sys.path: sys.path.remove(full_path) self.addCleanup(cleanup) - + def listdir(_): return ['foo.py'] + def isfile(_): return True + def isdir(_): return True os.listdir = listdir os.path.isfile = isfile os.path.isdir = isdir - + loader = unittest2.TestLoader() - + mod_dir = os.path.abspath('bar') expected_dir = os.path.abspath('foo') - msg = re.escape(r"'foo' module incorrectly imported from %r. Expected %r. " - "Is this module globally installed?" % (mod_dir, expected_dir)) + msg = re.escape( + r"'foo' module incorrectly imported from %r. Expected %r. " + "Is this module globally installed?" % + (mod_dir, expected_dir)) self.assertRaisesRegexp( ImportError, '^%s$' % msg, loader.discover, start_dir='foo', pattern='foo.py' ) self.assertEqual(sys.path[0], full_path) - def test_discovery_from_dotted_path(self): loader = unittest2.TestLoader() - + tests = [self] - expectedPath = os.path.abspath(os.path.dirname(unittest2.test.__file__)) + expectedPath = os.path.abspath( + os.path.dirname(unittest2.test.__file__)) self.wasRun = False + def _find_tests(start_dir, pattern): self.wasRun = True self.assertEqual(start_dir, expectedPath) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py index 263aed5a9bf6..ccfadc97d364 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py @@ -145,6 +145,5 @@ class Test_FunctionTestCase(unittest2.TestCase): self.assertEqual(test.shortDescription(), "this tests foo") - if __name__ == '__main__': unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py index 3a61f33e3191..45fea56aad02 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py @@ -6,15 +6,18 @@ import unittest2 class Test_TestLoader(unittest2.TestCase): - ### Tests for TestLoader.loadTestsFromTestCase + # Tests for TestLoader.loadTestsFromTestCase ################################################################ # "Return a suite of all tests cases contained in the TestCase-derived # class testCaseClass" def test_loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests = unittest2.TestSuite([Foo('test_1'), Foo('test_2')]) @@ -28,6 +31,7 @@ class Test_TestLoader(unittest2.TestCase): # Make sure it does the right thing even if no tests were found def test_loadTestsFromTestCase__no_matches(self): class Foo(unittest2.TestCase): + def foo_bar(self): pass empty_suite = unittest2.TestSuite() @@ -64,6 +68,7 @@ class Test_TestLoader(unittest2.TestCase): # not match the default TestLoader.testMethodPrefix string def test_loadTestsFromTestCase__default_method_name(self): class Foo(unittest2.TestCase): + def runTest(self): pass @@ -76,15 +81,17 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(list(suite), [Foo('runTest')]) ################################################################ - ### /Tests for TestLoader.loadTestsFromTestCase + # /Tests for TestLoader.loadTestsFromTestCase - ### Tests for TestLoader.loadTestsFromModule + # Tests for TestLoader.loadTestsFromModule ################################################################ # "This method searches `module` for classes derived from TestCase" def test_loadTestsFromModule__TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -112,6 +119,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens if no tests are found (TestCases instances, but no tests)? def test_loadTestsFromModule__no_TestCase_tests(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): pass m.testcase_1 = MyTestCase @@ -134,6 +142,7 @@ class Test_TestLoader(unittest2.TestCase): # XXX Certain people are using this behaviour. We'll add a test for it def test_loadTestsFromModule__not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -146,17 +155,19 @@ class Test_TestLoader(unittest2.TestCase): reference = [unittest2.TestSuite([MyTestCase('test')])] self.assertEqual(list(suite), reference) - # Check that loadTestsFromModule honors (or not) a module # with a load_tests function. def test_loadTestsFromModule__load_tests(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase load_tests_args = [] + def load_tests(loader, tests, pattern): self.assertIsInstance(tests, unittest2.TestSuite) load_tests_args.extend((loader, tests, pattern)) @@ -184,14 +195,13 @@ class Test_TestLoader(unittest2.TestCase): self.assertIsInstance(suite, unittest2.TestSuite) self.assertEqual(suite.countTestCases(), 1) test = list(suite)[0] - + self.assertRaisesRegexp(TypeError, "some failure", test.m) - ################################################################ - ### /Tests for TestLoader.loadTestsFromModule() + # /Tests for TestLoader.loadTestsFromModule() - ### Tests for TestLoader.loadTestsFromName() + # Tests for TestLoader.loadTestsFromName() ################################################################ # "The specifier name is a ``dotted name'' that may resolve either to @@ -255,9 +265,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('unittest2.sdasfasfasdf') except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -272,9 +284,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('sdasfasfasdf', unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -330,6 +344,7 @@ class Test_TestLoader(unittest2.TestCase): # XXX Some people are relying on this, so keep it for now def test_loadTestsFromName__relative_not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -365,7 +380,9 @@ class Test_TestLoader(unittest2.TestCase): # resolve either to ... a test case class" def test_loadTestsFromName__relative_TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -381,7 +398,9 @@ class Test_TestLoader(unittest2.TestCase): # TestCase or TestSuite instance." def test_loadTestsFromName__relative_TestSuite(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testsuite = unittest2.TestSuite([MyTestCase('test')]) @@ -396,7 +415,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a test method within a test case class" def test_loadTestsFromName__relative_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -417,7 +438,9 @@ class Test_TestLoader(unittest2.TestCase): # for the given name (relative to a provided module)? def test_loadTestsFromName__relative_invalid_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -426,7 +449,8 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromName('testcase_1.testfoo', m) except AttributeError as e: - self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + self.assertEqual( + str(e), "type object 'MyTestCase' has no attribute 'testfoo'") else: self.fail("Failed to raise AttributeError") @@ -436,6 +460,7 @@ class Test_TestLoader(unittest2.TestCase): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) testcase_2 = unittest2.FunctionTestCase(lambda: None) + def return_TestSuite(): return unittest2.TestSuite([testcase_1, testcase_2]) m.return_TestSuite = return_TestSuite @@ -450,6 +475,7 @@ class Test_TestLoader(unittest2.TestCase): def test_loadTestsFromName__callable__TestCase_instance(self): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -462,13 +488,15 @@ class Test_TestLoader(unittest2.TestCase): # "The specifier name is a ``dotted name'' that may resolve ... to # ... a callable object which returns a TestCase ... instance" #***************************************************************** - #Override the suiteClass attribute to ensure that the suiteClass + # Override the suiteClass attribute to ensure that the suiteClass #attribute is used - def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(self): + def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass( + self): class SubTestSuite(unittest2.TestSuite): pass m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -482,19 +510,21 @@ class Test_TestLoader(unittest2.TestCase): # "The specifier name is a ``dotted name'' that may resolve ... to # ... a test method within a test case class" #***************************************************************** - #Override the suiteClass attribute to ensure that the suiteClass + # Override the suiteClass attribute to ensure that the suiteClass #attribute is used def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self): class SubTestSuite(unittest2.TestSuite): pass m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase loader = unittest2.TestLoader() - loader.suiteClass=SubTestSuite + loader.suiteClass = SubTestSuite suite = loader.loadTestsFromName('testcase_1.test', m) self.assertIsInstance(suite, loader.suiteClass) @@ -506,6 +536,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens if the callable returns something else? def test_loadTestsFromName__callable__wrong_type(self): m = types.ModuleType('m') + def return_wrong(): return 6 m.return_wrong = return_wrong @@ -541,9 +572,9 @@ class Test_TestLoader(unittest2.TestCase): del sys.modules[module_name] ################################################################ - ### Tests for TestLoader.loadTestsFromName() + # Tests for TestLoader.loadTestsFromName() - ### Tests for TestLoader.loadTestsFromNames() + # Tests for TestLoader.loadTestsFromNames() ################################################################ # "Similar to loadTestsFromName(), but takes a sequence of names rather @@ -635,9 +666,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['unittest2.sdasfasfasdf', 'unittest2']) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromNames failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromNames failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -654,9 +687,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['sdasfasfasdf'], unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -673,9 +708,11 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest2) except AttributeError as e: - self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'") + self.assertEqual( + str(e), "'module' object has no attribute 'sdasfasfasdf'") else: - self.fail("TestLoader.loadTestsFromName failed to raise AttributeError") + self.fail( + "TestLoader.loadTestsFromName failed to raise AttributeError") # "The specifier name is a ``dotted name'' that may resolve either to # a module, a test case class, a TestSuite instance, a test method @@ -728,6 +765,7 @@ class Test_TestLoader(unittest2.TestCase): # either be documented or a TypeError should be raised. def test_loadTestsFromNames__relative_not_a_module(self): class MyTestCase(unittest2.TestCase): + def test(self): pass @@ -763,7 +801,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a test case class" def test_loadTestsFromNames__relative_TestCase_subclass(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -779,7 +819,9 @@ class Test_TestLoader(unittest2.TestCase): # ... a TestSuite instance" def test_loadTestsFromNames__relative_TestSuite(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testsuite = unittest2.TestSuite([MyTestCase('test')]) @@ -794,7 +836,9 @@ class Test_TestLoader(unittest2.TestCase): # test method within a test case class" def test_loadTestsFromNames__relative_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -813,7 +857,9 @@ class Test_TestLoader(unittest2.TestCase): # resolve to "a test method within a test case class" but don't? def test_loadTestsFromNames__relative_invalid_testmethod(self): m = types.ModuleType('m') + class MyTestCase(unittest2.TestCase): + def test(self): pass m.testcase_1 = MyTestCase @@ -822,7 +868,8 @@ class Test_TestLoader(unittest2.TestCase): try: loader.loadTestsFromNames(['testcase_1.testfoo'], m) except AttributeError as e: - self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'") + self.assertEqual( + str(e), "type object 'MyTestCase' has no attribute 'testfoo'") else: self.fail("Failed to raise AttributeError") @@ -832,6 +879,7 @@ class Test_TestLoader(unittest2.TestCase): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) testcase_2 = unittest2.FunctionTestCase(lambda: None) + def return_TestSuite(): return unittest2.TestSuite([testcase_1, testcase_2]) m.return_TestSuite = return_TestSuite @@ -848,6 +896,7 @@ class Test_TestLoader(unittest2.TestCase): def test_loadTestsFromNames__callable__TestCase_instance(self): m = types.ModuleType('m') testcase_1 = unittest2.FunctionTestCase(lambda: None) + def return_TestCase(): return testcase_1 m.return_TestCase = return_TestCase @@ -865,12 +914,16 @@ class Test_TestLoader(unittest2.TestCase): # Are staticmethods handled correctly? def test_loadTestsFromNames__callable__call_staticmethod(self): m = types.ModuleType('m') + class Test1(unittest2.TestCase): + def test(self): pass testcase_1 = Test1('test') + class Foo(unittest2.TestCase): + @staticmethod def foo(): return testcase_1 @@ -889,6 +942,7 @@ class Test_TestLoader(unittest2.TestCase): # What happens when the callable returns something else? def test_loadTestsFromNames__callable__wrong_type(self): m = types.ModuleType('m') + def return_wrong(): return 6 m.return_wrong = return_wrong @@ -924,9 +978,9 @@ class Test_TestLoader(unittest2.TestCase): del sys.modules[module_name] ################################################################ - ### /Tests for TestLoader.loadTestsFromNames() + # /Tests for TestLoader.loadTestsFromNames() - ### Tests for TestLoader.getTestCaseNames() + # Tests for TestLoader.getTestCaseNames() ################################################################ # "Return a sorted sequence of method names found within testCaseClass" @@ -935,8 +989,11 @@ class Test_TestLoader(unittest2.TestCase): # loader.testMethodPrefix def test_getTestCaseNames(self): class Test(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foobar(self): pass loader = unittest2.TestLoader() @@ -948,6 +1005,7 @@ class Test_TestLoader(unittest2.TestCase): # Does getTestCaseNames() behave appropriately if no tests are found? def test_getTestCaseNames__no_tests(self): class Test(unittest2.TestCase): + def foobar(self): pass loader = unittest2.TestLoader() @@ -964,6 +1022,7 @@ class Test_TestLoader(unittest2.TestCase): # probably be revisited for 2.6 def test_getTestCaseNames__not_a_TestCase(self): class BadCase(int): + def test_foo(self): pass @@ -980,12 +1039,17 @@ class Test_TestLoader(unittest2.TestCase): # loader.testMethodPrefix def test_getTestCaseNames__inheritance(self): class TestP(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foobar(self): pass class TestC(TestP): + def test_1(self): pass + def test_3(self): pass loader = unittest2.TestLoader() @@ -994,9 +1058,9 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(loader.getTestCaseNames(TestC), names) ################################################################ - ### /Tests for TestLoader.getTestCaseNames() + # /Tests for TestLoader.getTestCaseNames() - ### Tests for TestLoader.testMethodPrefix + # Tests for TestLoader.testMethodPrefix ################################################################ # "String giving the prefix of method names which will be interpreted as @@ -1006,8 +1070,11 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests_1 = unittest2.TestSuite([Foo('foo_bar')]) @@ -1027,9 +1094,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1050,9 +1121,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1073,9 +1148,13 @@ class Test_TestLoader(unittest2.TestCase): # all loadTestsFrom* methods. def test_testMethodPrefix__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1096,16 +1175,18 @@ class Test_TestLoader(unittest2.TestCase): self.assertTrue(loader.testMethodPrefix == 'test') ################################################################ - ### /Tests for TestLoader.testMethodPrefix + # /Tests for TestLoader.testMethodPrefix - ### Tests for TestLoader.sortTestMethodsUsing + # Tests for TestLoader.sortTestMethodsUsing ################################################################ # "Function to be used to compare method names when sorting them in # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1118,8 +1199,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1133,8 +1217,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1148,8 +1235,11 @@ class Test_TestLoader(unittest2.TestCase): # getTestCaseNames() and all the loadTestsFromX() methods" def test_sortTestMethodsUsing__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass m.Foo = Foo @@ -1165,7 +1255,9 @@ class Test_TestLoader(unittest2.TestCase): # Does it actually affect getTestCaseNames()? def test_sortTestMethodsUsing__getTestCaseNames(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1185,7 +1277,9 @@ class Test_TestLoader(unittest2.TestCase): # in a random order or something? This behaviour should die def test_sortTestMethodsUsing__None(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass loader = unittest2.TestLoader() @@ -1195,16 +1289,19 @@ class Test_TestLoader(unittest2.TestCase): self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names)) ################################################################ - ### /Tests for TestLoader.sortTestMethodsUsing + # /Tests for TestLoader.sortTestMethodsUsing - ### Tests for TestLoader.suiteClass + # Tests for TestLoader.suiteClass ################################################################ # "Callable object that constructs a test suite from a list of tests." def test_suiteClass__loadTestsFromTestCase(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass tests = [Foo('test_1'), Foo('test_2')] @@ -1217,9 +1314,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromModule(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1233,9 +1334,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromName(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo @@ -1249,9 +1354,13 @@ class Test_TestLoader(unittest2.TestCase): # all TestLoader.loadTestsFrom* methods respect it. Let's make sure def test_suiteClass__loadTestsFromNames(self): m = types.ModuleType('m') + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def foo_bar(self): pass m.Foo = Foo diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py index cc96bcb6a058..0b456c08927f 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py @@ -7,40 +7,46 @@ from unittest2.test.support import resultFactory class TestUnittest(unittest2.TestCase): - + def assertIsSubclass(self, actual, klass): self.assertTrue(issubclass(actual, klass), "Not a subclass.") - + def testInheritance(self): self.assertIsSubclass(unittest2.TestCase, unittest.TestCase) self.assertIsSubclass(unittest2.TestResult, unittest.TestResult) self.assertIsSubclass(unittest2.TestSuite, unittest.TestSuite) - self.assertIsSubclass(unittest2.TextTestRunner, unittest.TextTestRunner) + self.assertIsSubclass( + unittest2.TextTestRunner, + unittest.TextTestRunner) self.assertIsSubclass(unittest2.TestLoader, unittest.TestLoader) self.assertIsSubclass(unittest2.TextTestResult, unittest.TestResult) - + def test_new_runner_old_case(self): runner = unittest2.TextTestRunner(resultclass=resultFactory, stream=StringIO()) + class Test(unittest.TestCase): + def testOne(self): pass suite = unittest2.TestSuite((Test('testOne'),)) result = runner.run(suite) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) - + def test_old_runner_new_case(self): runner = unittest.TextTestRunner(stream=StringIO()) + class Test(unittest2.TestCase): + def testOne(self): self.assertDictEqual({}, {}) - + suite = unittest.TestSuite((Test('testOne'),)) result = runner.run(suite) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) - - + + if __name__ == '__main__': - unittest2.main()
\ No newline at end of file + unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py index 56077a6bb3a7..eb864871e16f 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py @@ -5,6 +5,7 @@ import unittest2 hasInstallHandler = hasattr(unittest2, 'installHandler') + class Test_TestProgram(unittest2.TestCase): # Horrible white box test @@ -13,6 +14,7 @@ class Test_TestProgram(unittest2.TestCase): test = object() class FakeRunner(object): + def run(self, test): self.test = test return result @@ -20,6 +22,7 @@ class Test_TestProgram(unittest2.TestCase): runner = FakeRunner() oldParseArgs = unittest2.TestProgram.parseArgs + def restoreParseArgs(): unittest2.TestProgram.parseArgs = oldParseArgs unittest2.TestProgram.parseArgs = lambda *args: None @@ -30,33 +33,37 @@ class Test_TestProgram(unittest2.TestCase): unittest2.TestProgram.test = test self.addCleanup(removeTest) - program = unittest2.TestProgram(testRunner=runner, exit=False, verbosity=2) + program = unittest2.TestProgram( + testRunner=runner, exit=False, verbosity=2) self.assertEqual(program.result, result) self.assertEqual(runner.test, test) self.assertEqual(program.verbosity, 2) class FooBar(unittest2.TestCase): + def testPass(self): assert True + def testFail(self): assert False class FooBarLoader(unittest2.TestLoader): """Test loader that returns a suite containing FooBar.""" + def loadTestsFromModule(self, module): return self.suiteClass( [self.loadTestsFromTestCase(Test_TestProgram.FooBar)]) - def test_NonExit(self): - program = unittest2.main(exit=False, - argv=["foobar"], - testRunner=unittest2.TextTestRunner(stream=StringIO()), - testLoader=self.FooBarLoader()) + program = unittest2.main( + exit=False, + argv=["foobar"], + testRunner=unittest2.TextTestRunner( + stream=StringIO()), + testLoader=self.FooBarLoader()) self.assertTrue(hasattr(program, 'result')) - def test_Exit(self): self.assertRaises( SystemExit, @@ -66,7 +73,6 @@ class Test_TestProgram(unittest2.TestCase): exit=True, testLoader=self.FooBarLoader()) - def test_ExitAsDefault(self): self.assertRaises( SystemExit, @@ -85,11 +91,13 @@ class InitialisableProgram(unittest2.TestProgram): testLoader = unittest2.defaultTestLoader progName = 'test' test = 'test' + def __init__(self, *args): pass RESULT = object() + class FakeRunner(object): initArgs = None test = None @@ -105,35 +113,37 @@ class FakeRunner(object): FakeRunner.test = test return RESULT + class TestCommandLineArgs(unittest2.TestCase): - + def setUp(self): self.program = InitialisableProgram() self.program.createTests = lambda: None FakeRunner.initArgs = None FakeRunner.test = None FakeRunner.raiseError = False - + def testHelpAndUnknown(self): program = self.program + def usageExit(msg=None): program.msg = msg program.exit = True program.usageExit = usageExit - + for opt in '-h', '-H', '--help': program.exit = False program.parseArgs([None, opt]) self.assertTrue(program.exit) self.assertIsNone(program.msg) - + program.parseArgs([None, '-$']) self.assertTrue(program.exit) self.assertIsNotNone(program.msg) - + def testVerbosity(self): program = self.program - + for opt in '-q', '--quiet': program.verbosity = 1 program.parseArgs([None, opt]) @@ -147,90 +157,92 @@ class TestCommandLineArgs(unittest2.TestCase): def testBufferCatchFailfast(self): program = self.program for arg, attr in (('buffer', 'buffer'), ('failfast', 'failfast'), - ('catch', 'catchbreak')): + ('catch', 'catchbreak')): if attr == 'catch' and not hasInstallHandler: continue - + short_opt = '-%s' % arg[0] long_opt = '--%s' % arg for opt in short_opt, long_opt: setattr(program, attr, None) - + program.parseArgs([None, opt]) self.assertTrue(getattr(program, attr)) for opt in short_opt, long_opt: not_none = object() setattr(program, attr, not_none) - + program.parseArgs([None, opt]) self.assertEqual(getattr(program, attr), not_none) def testRunTestsRunnerClass(self): program = self.program - + program.testRunner = FakeRunner program.verbosity = 'verbosity' program.failfast = 'failfast' program.buffer = 'buffer' - + program.runTests() - - self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity', - 'failfast': 'failfast', - 'buffer': 'buffer'}) + + self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity', + 'failfast': 'failfast', + 'buffer': 'buffer'}) self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) def testRunTestsRunnerInstance(self): program = self.program - + program.testRunner = FakeRunner() FakeRunner.initArgs = None - + program.runTests() # A new FakeRunner should not have been instantiated self.assertIsNone(FakeRunner.initArgs) - + self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) def testRunTestsOldRunnerClass(self): program = self.program - + FakeRunner.raiseError = True program.testRunner = FakeRunner program.verbosity = 'verbosity' program.failfast = 'failfast' program.buffer = 'buffer' program.test = 'test' - + program.runTests() - + # If initialising raises a type error it should be retried # without the new keyword arguments self.assertEqual(FakeRunner.initArgs, {}) self.assertEqual(FakeRunner.test, 'test') self.assertIs(program.result, RESULT) - + def testCatchBreakInstallsHandler(self): module = sys.modules['unittest2.main'] original = module.installHandler + def restore(): module.installHandler = original self.addCleanup(restore) self.installed = False + def fakeInstallHandler(): self.installed = True module.installHandler = fakeInstallHandler - + program = self.program program.catchbreak = True - + program.testRunner = FakeRunner - + program.runTests() self.assertTrue(self.installed) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py index 69b31d542eae..e4e26bd51feb 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py @@ -42,6 +42,7 @@ class Test_TestResult(unittest2.TestCase): # implementation simply increments the instance's testsRun counter." def test_startTest(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -63,6 +64,7 @@ class Test_TestResult(unittest2.TestCase): # the outcome. The default implementation does nothing." def test_stopTest(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -114,6 +116,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addSuccess(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -153,6 +156,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addFailure(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -201,6 +205,7 @@ class Test_TestResult(unittest2.TestCase): # of sys.exc_info() results." def test_addError(self): class Foo(unittest2.TestCase): + def test_1(self): pass @@ -229,18 +234,18 @@ class Test_TestResult(unittest2.TestCase): def testGetDescriptionWithoutDocstring(self): result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - 'testGetDescriptionWithoutDocstring (' + __name__ + - '.Test_TestResult)') + result.getDescription(self), + 'testGetDescriptionWithoutDocstring (' + __name__ + + '.Test_TestResult)') def testGetDescriptionWithOneLineDocstring(self): """Tests getDescription() for a method with a docstring.""" result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - ('testGetDescriptionWithOneLineDocstring ' - '(' + __name__ + '.Test_TestResult)\n' - 'Tests getDescription() for a method with a docstring.')) + result.getDescription(self), + ('testGetDescriptionWithOneLineDocstring ' + '(' + __name__ + '.Test_TestResult)\n' + 'Tests getDescription() for a method with a docstring.')) def testGetDescriptionWithMultiLineDocstring(self): """Tests getDescription() for a method with a longer docstring. @@ -248,19 +253,20 @@ class Test_TestResult(unittest2.TestCase): """ result = unittest2.TextTestResult(None, True, 1) self.assertEqual( - result.getDescription(self), - ('testGetDescriptionWithMultiLineDocstring ' - '(' + __name__ + '.Test_TestResult)\n' - 'Tests getDescription() for a method with a longer ' - 'docstring.')) + result.getDescription(self), + ('testGetDescriptionWithMultiLineDocstring ' + '(' + __name__ + '.Test_TestResult)\n' + 'Tests getDescription() for a method with a longer ' + 'docstring.')) def testStackFrameTrimming(self): class Frame(object): + class tb_frame(object): f_globals = {} result = unittest2.TestResult() self.assertFalse(result._is_relevant_tb_level(Frame)) - + Frame.tb_frame.f_globals['__unittest'] = True self.assertTrue(result._is_relevant_tb_level(Frame)) @@ -286,6 +292,7 @@ class Test_TestResult(unittest2.TestCase): def testFailFastSetByRunner(self): runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True) self.testRan = False + def test(result): self.testRan = True self.assertTrue(result.failfast) @@ -306,65 +313,64 @@ class TestOutputBuffering(unittest2.TestCase): def testBufferOutputOff(self): real_out = self._real_out real_err = self._real_err - + result = unittest2.TestResult() self.assertFalse(result.buffer) - + self.assertIs(real_out, sys.stdout) self.assertIs(real_err, sys.stderr) - + result.startTest(self) - + self.assertIs(real_out, sys.stdout) self.assertIs(real_err, sys.stderr) def testBufferOutputStartTestAddSuccess(self): real_out = self._real_out real_err = self._real_err - + result = unittest2.TestResult() self.assertFalse(result.buffer) - + result.buffer = True - + self.assertIs(real_out, sys.stdout) self.assertIs(real_err, sys.stderr) - + result.startTest(self) - + self.assertIsNot(real_out, sys.stdout) self.assertIsNot(real_err, sys.stderr) self.assertIsInstance(sys.stdout, StringIO) self.assertIsInstance(sys.stderr, StringIO) self.assertIsNot(sys.stdout, sys.stderr) - + out_stream = sys.stdout err_stream = sys.stderr - + result._original_stdout = StringIO() result._original_stderr = StringIO() - + print('foo') print('bar', file=sys.stderr) - + self.assertEqual(out_stream.getvalue(), 'foo\n') self.assertEqual(err_stream.getvalue(), 'bar\n') - + self.assertEqual(result._original_stdout.getvalue(), '') self.assertEqual(result._original_stderr.getvalue(), '') - + result.addSuccess(self) result.stopTest(self) - + self.assertIs(sys.stdout, result._original_stdout) self.assertIs(sys.stderr, result._original_stderr) - + self.assertEqual(result._original_stdout.getvalue(), '') self.assertEqual(result._original_stderr.getvalue(), '') - + self.assertEqual(out_stream.getvalue(), '') self.assertEqual(err_stream.getvalue(), '') - def getStartedResult(self): result = unittest2.TestResult() @@ -374,26 +380,26 @@ class TestOutputBuffering(unittest2.TestCase): def testBufferOutputAddErrorOrFailure(self): for message_attr, add_attr, include_error in [ - ('errors', 'addError', True), + ('errors', 'addError', True), ('failures', 'addFailure', False), - ('errors', 'addError', True), + ('errors', 'addError', True), ('failures', 'addFailure', False) ]: result = self.getStartedResult() result._original_stderr = StringIO() result._original_stdout = StringIO() - + print('foo') if include_error: print('bar', file=sys.stderr) - + addFunction = getattr(result, add_attr) addFunction(self, (None, None, None)) result.stopTest(self) - + result_list = getattr(result, message_attr) self.assertEqual(len(result_list), 1) - + test, message = result_list[0] expectedOutMessage = textwrap.dedent(""" Stdout: @@ -405,14 +411,18 @@ class TestOutputBuffering(unittest2.TestCase): Stderr: bar """) - expectedFullMessage = 'None\n%s%s' % (expectedOutMessage, expectedErrMessage) + expectedFullMessage = 'None\n%s%s' % ( + expectedOutMessage, expectedErrMessage) self.assertIs(test, self) - self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage) - self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage) + self.assertEqual( + result._original_stdout.getvalue(), + expectedOutMessage) + self.assertEqual( + result._original_stderr.getvalue(), + expectedErrMessage) self.assertMultiLineEqual(message, expectedFullMessage) - - + if __name__ == '__main__': unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py index 38b39efb0069..cfdf1326fa39 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py @@ -17,63 +17,70 @@ class Test_TextTestRunner(unittest2.TestCase): self.assertTrue(runner.descriptions) self.assertEqual(runner.resultclass, unittest2.TextTestResult) - def testBufferAndFailfast(self): class Test(unittest2.TestCase): + def testFoo(self): pass result = unittest2.TestResult() runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True, - buffer=True) + buffer=True) # Use our result object runner._makeResult = lambda: result runner.run(Test('testFoo')) - + self.assertTrue(result.failfast) self.assertTrue(result.buffer) def testRunnerRegistersResult(self): class Test(unittest2.TestCase): + def testFoo(self): pass originalRegisterResult = unittest2.runner.registerResult + def cleanup(): unittest2.runner.registerResult = originalRegisterResult self.addCleanup(cleanup) - + result = unittest2.TestResult() runner = unittest2.TextTestRunner(stream=StringIO()) # Use our result object runner._makeResult = lambda: result - + self.wasRegistered = 0 + def fakeRegisterResult(thisResult): self.wasRegistered += 1 self.assertEqual(thisResult, result) unittest2.runner.registerResult = fakeRegisterResult - + runner.run(unittest2.TestSuite()) self.assertEqual(self.wasRegistered, 1) - + def test_works_with_result_without_startTestRun_stopTestRun(self): class OldTextResult(OldTestResult): + def __init__(self, *_): super(OldTextResult, self).__init__() separator2 = '' + def printErrors(self): pass - runner = unittest2.TextTestRunner(stream=StringIO(), + runner = unittest2.TextTestRunner(stream=StringIO(), resultclass=OldTextResult) runner.run(unittest2.TestSuite()) def test_startTestRun_stopTestRun_called(self): class LoggingTextResult(LoggingResult): separator2 = '' + def printErrors(self): pass class LoggingRunner(unittest2.TextTestRunner): + def __init__(self, events): super(LoggingRunner, self).__init__(StringIO()) self._events = events @@ -107,15 +114,15 @@ class Test_TextTestRunner(unittest2.TestCase): DESCRIPTIONS = object() VERBOSITY = object() runner = unittest2.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, - resultclass=MockResultClass) + resultclass=MockResultClass) self.assertEqual(runner.resultclass, MockResultClass) expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) self.assertEqual(runner._makeResult(), expectedresult) - def test_oldresult(self): class Test(unittest2.TestCase): + def testFoo(self): pass runner = unittest2.TextTestRunner(resultclass=OldTestResult, @@ -126,4 +133,4 @@ class Test_TextTestRunner(unittest2.TestCase): if __name__ == '__main__': - unittest2.main()
\ No newline at end of file + unittest2.main() diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py index 55c7f578df10..73526894aaae 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py @@ -7,18 +7,19 @@ from unittest2.test.support import resultFactory class TestSetups(unittest2.TestCase): - + def getRunner(self): return unittest2.TextTestRunner(resultclass=resultFactory, - stream=StringIO()) + stream=StringIO()) + def runTests(self, *cases): suite = unittest2.TestSuite() for case in cases: tests = unittest2.defaultTestLoader.loadTestsFromTestCase(case) suite.addTests(tests) - + runner = self.getRunner() - + # creating a nested suite exposes some potential bugs realSuite = unittest2.TestSuite() realSuite.addTest(suite) @@ -26,21 +27,24 @@ class TestSetups(unittest2.TestCase): suite.addTest(unittest2.TestSuite()) realSuite.addTest(unittest2.TestSuite()) return runner.run(realSuite) - + def test_setup_class(self): class Test(unittest2.TestCase): setUpCalled = 0 + @classmethod def setUpClass(cls): Test.setUpCalled += 1 unittest2.TestCase.setUpClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test) - + self.assertEqual(Test.setUpCalled, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) @@ -48,46 +52,55 @@ class TestSetups(unittest2.TestCase): def test_teardown_class(self): class Test(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test) - + self.assertEqual(Test.tearDownCalled, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) - + def test_teardown_class_two_classes(self): class Test(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): tearDownCalled = 0 + @classmethod def tearDownClass(cls): Test2.tearDownCalled += 1 unittest2.TestCase.tearDownClass() + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test, Test2) - + self.assertEqual(Test.tearDownCalled, 1) self.assertEqual(Test2.tearDownCalled, 1) self.assertEqual(result.testsRun, 4) @@ -95,81 +108,96 @@ class TestSetups(unittest2.TestCase): def test_error_in_setupclass(self): class BrokenTest(unittest2.TestCase): + @classmethod def setUpClass(cls): raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(BrokenTest) - + self.assertEqual(result.testsRun, 0) self.assertEqual(len(result.errors), 1) error, _ = result.errors[0] - self.assertEqual(str(error), - 'setUpClass (%s.BrokenTest)' % __name__) + self.assertEqual(str(error), + 'setUpClass (%s.BrokenTest)' % __name__) def test_error_in_teardown_class(self): class Test(unittest2.TestCase): tornDown = 0 + @classmethod def tearDownClass(cls): Test.tornDown += 1 raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): tornDown = 0 + @classmethod def tearDownClass(cls): Test2.tornDown += 1 raise TypeError('foo') + def test_one(self): pass + def test_two(self): pass - + result = self.runTests(Test, Test2) self.assertEqual(result.testsRun, 4) self.assertEqual(len(result.errors), 2) self.assertEqual(Test.tornDown, 1) self.assertEqual(Test2.tornDown, 1) - + error, _ = result.errors[0] - self.assertEqual(str(error), - 'tearDownClass (%s.Test)' % __name__) + self.assertEqual(str(error), + 'tearDownClass (%s.Test)' % __name__) def test_class_not_torndown_when_setup_fails(self): class Test(unittest2.TestCase): tornDown = False + @classmethod def setUpClass(cls): raise TypeError + @classmethod def tearDownClass(cls): Test.tornDown = True raise TypeError('foo') + def test_one(self): pass self.runTests(Test) self.assertFalse(Test.tornDown) - + def test_class_not_setup_or_torndown_when_skipped(self): class Test(unittest2.TestCase): classSetUp = False tornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.tornDown = True + def test_one(self): pass @@ -180,141 +208,169 @@ class TestSetups(unittest2.TestCase): def test_setup_teardown_order_with_pathological_suite(self): results = [] - + class Module1(object): + @staticmethod def setUpModule(): results.append('Module1.setUpModule') + @staticmethod def tearDownModule(): results.append('Module1.tearDownModule') - + class Module2(object): + @staticmethod def setUpModule(): results.append('Module2.setUpModule') + @staticmethod def tearDownModule(): results.append('Module2.tearDownModule') - + class Test1(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 1') + @classmethod def tearDownClass(cls): results.append('teardown 1') + def testOne(self): results.append('Test1.testOne') + def testTwo(self): results.append('Test1.testTwo') - + class Test2(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 2') + @classmethod def tearDownClass(cls): results.append('teardown 2') + def testOne(self): results.append('Test2.testOne') + def testTwo(self): results.append('Test2.testTwo') - + class Test3(unittest2.TestCase): + @classmethod def setUpClass(cls): results.append('setup 3') + @classmethod def tearDownClass(cls): results.append('teardown 3') + def testOne(self): results.append('Test3.testOne') + def testTwo(self): results.append('Test3.testTwo') - + Test1.__module__ = Test2.__module__ = 'Module' Test3.__module__ = 'Module2' sys.modules['Module'] = Module1 sys.modules['Module2'] = Module2 - + first = unittest2.TestSuite((Test1('testOne'),)) second = unittest2.TestSuite((Test1('testTwo'),)) third = unittest2.TestSuite((Test2('testOne'),)) fourth = unittest2.TestSuite((Test2('testTwo'),)) fifth = unittest2.TestSuite((Test3('testOne'),)) sixth = unittest2.TestSuite((Test3('testTwo'),)) - suite = unittest2.TestSuite((first, second, third, fourth, fifth, sixth)) - + suite = unittest2.TestSuite( + (first, second, third, fourth, fifth, sixth)) + runner = self.getRunner() result = runner.run(suite) self.assertEqual(result.testsRun, 6) self.assertEqual(len(result.errors), 0) self.assertEqual(results, - ['Module1.setUpModule', 'setup 1', + ['Module1.setUpModule', 'setup 1', 'Test1.testOne', 'Test1.testTwo', 'teardown 1', - 'setup 2', 'Test2.testOne', 'Test2.testTwo', + 'setup 2', 'Test2.testOne', 'Test2.testTwo', 'teardown 2', 'Module1.tearDownModule', 'Module2.setUpModule', 'setup 3', - 'Test3.testOne', 'Test3.testTwo', + 'Test3.testOne', 'Test3.testTwo', 'teardown 3', 'Module2.tearDownModule']) - + def test_setup_module(self): class Module(object): moduleSetup = 0 + @staticmethod def setUpModule(): Module.moduleSetup += 1 - + class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test) self.assertEqual(Module.moduleSetup, 1) self.assertEqual(result.testsRun, 2) self.assertEqual(len(result.errors), 0) - + def test_error_in_setup_module(self): class Module(object): moduleSetup = 0 moduleTornDown = 0 + @staticmethod def setUpModule(): Module.moduleSetup += 1 raise TypeError('foo') + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 - + class Test(unittest2.TestCase): classSetUp = False classTornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.classTornDown = True + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' Test2.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test, Test2) self.assertEqual(Module.moduleSetup, 1) self.assertEqual(Module.moduleTornDown, 0) @@ -324,34 +380,39 @@ class TestSetups(unittest2.TestCase): self.assertEqual(len(result.errors), 1) error, _ = result.errors[0] self.assertEqual(str(error), 'setUpModule (Module)') - + def test_testcase_with_missing_module(self): class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules.pop('Module', None) - + result = self.runTests(Test) self.assertEqual(result.testsRun, 2) def test_teardown_module(self): class Module(object): moduleTornDown = 0 + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 - + class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test) self.assertEqual(Module.moduleTornDown, 1) self.assertEqual(result.testsRun, 2) @@ -360,34 +421,41 @@ class TestSetups(unittest2.TestCase): def test_error_in_teardown_module(self): class Module(object): moduleTornDown = 0 + @staticmethod def tearDownModule(): Module.moduleTornDown += 1 raise TypeError('foo') - + class Test(unittest2.TestCase): classSetUp = False classTornDown = False + @classmethod def setUpClass(cls): Test.classSetUp = True + @classmethod def tearDownClass(cls): Test.classTornDown = True + def test_one(self): pass + def test_two(self): pass - + class Test2(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass Test.__module__ = 'Module' Test2.__module__ = 'Module' sys.modules['Module'] = Module - + result = self.runTests(Test, Test2) self.assertEqual(Module.moduleTornDown, 1) self.assertEqual(result.testsRun, 4) @@ -399,11 +467,14 @@ class TestSetups(unittest2.TestCase): def test_skiptest_in_setupclass(self): class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): raise unittest2.SkipTest('foo') + def test_one(self): pass + def test_two(self): pass @@ -416,12 +487,15 @@ class TestSetups(unittest2.TestCase): def test_skiptest_in_setupmodule(self): class Test(unittest2.TestCase): + def test_one(self): pass + def test_two(self): pass class Module(object): + @staticmethod def setUpModule(): raise unittest2.SkipTest('foo') @@ -440,20 +514,25 @@ class TestSetups(unittest2.TestCase): ordering = [] class Module(object): + @staticmethod def setUpModule(): ordering.append('setUpModule') + @staticmethod def tearDownModule(): ordering.append('tearDownModule') class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): ordering.append('setUpClass') + @classmethod def tearDownClass(cls): ordering.append('tearDownClass') + def test_something(self): ordering.append('test_something') @@ -462,29 +541,39 @@ class TestSetups(unittest2.TestCase): suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test) suite.debug() - expectedOrder = ['setUpModule', 'setUpClass', 'test_something', 'tearDownClass', 'tearDownModule'] + expectedOrder = [ + 'setUpModule', + 'setUpClass', + 'test_something', + 'tearDownClass', + 'tearDownModule'] self.assertEqual(ordering, expectedOrder) def test_suite_debug_propagates_exceptions(self): class Module(object): + @staticmethod def setUpModule(): if phase == 0: raise Exception('setUpModule') + @staticmethod def tearDownModule(): if phase == 1: raise Exception('tearDownModule') class Test(unittest2.TestCase): + @classmethod def setUpClass(cls): if phase == 2: raise Exception('setUpClass') + @classmethod def tearDownClass(cls): if phase == 3: raise Exception('tearDownClass') + def test_something(self): if phase == 4: raise Exception('test_something') @@ -494,9 +583,14 @@ class TestSetups(unittest2.TestCase): _suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test) suite = unittest2.TestSuite() - + # nesting a suite again exposes a bug in the initial implementation suite.addTest(_suite) - messages = ('setUpModule', 'tearDownModule', 'setUpClass', 'tearDownClass', 'test_something') + messages = ( + 'setUpModule', + 'tearDownModule', + 'setUpClass', + 'tearDownClass', + 'test_something') for phase, msg in enumerate(messages): self.assertRaisesRegexp(Exception, msg, suite.debug) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py index 9555b9ff7700..6ad12e988cb4 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py @@ -7,6 +7,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_skipping(self): class Foo(unittest2.TestCase): + def test_skip_me(self): self.skipTest("skip") events = [] @@ -18,8 +19,10 @@ class Test_TestSkipping(unittest2.TestCase): # Try letting setUp skip the test now. class Foo(unittest2.TestCase): + def setUp(self): self.skipTest("testing") + def test_nothing(self): pass events = [] result = LoggingResult(events) @@ -34,14 +37,15 @@ class Test_TestSkipping(unittest2.TestCase): (unittest2.skipIf, True, False)) for deco, do_skip, dont_skip in op_table: class Foo(unittest2.TestCase): + @deco(do_skip, "testing") - def test_skip(self): + def test_skip(self): pass @deco(dont_skip, "testing") - def test_dont_skip(self): + def test_dont_skip(self): pass - + test_do_skip = Foo("test_skip") test_dont_skip = Foo("test_dont_skip") suite = unittest2.TestSuite([test_do_skip, test_dont_skip]) @@ -55,12 +59,13 @@ class Test_TestSkipping(unittest2.TestCase): self.assertEqual(result.testsRun, 2) self.assertEqual(result.skipped, [(test_do_skip, "testing")]) self.assertTrue(result.wasSuccessful()) - + def test_skip_class(self): class Foo(unittest2.TestCase): + def test_1(self): record.append(1) - + # was originally a class decorator... Foo = unittest2.skip("testing")(Foo) record = [] @@ -73,6 +78,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_expected_failure(self): class Foo(unittest2.TestCase): + @unittest2.expectedFailure def test_die(self): self.fail("help me!") @@ -87,6 +93,7 @@ class Test_TestSkipping(unittest2.TestCase): def test_unexpected_success(self): class Foo(unittest2.TestCase): + @unittest2.expectedFailure def test_die(self): pass @@ -104,14 +111,17 @@ class Test_TestSkipping(unittest2.TestCase): class Foo(unittest2.TestCase): wasSetUp = False wasTornDown = False + def setUp(self): Foo.wasSetUp = True + def tornDown(self): Foo.wasTornDown = True + @unittest2.skip('testing') def test_1(self): pass - + result = unittest2.TestResult() test = Foo("test_1") suite = unittest2.TestSuite([test]) @@ -119,19 +129,20 @@ class Test_TestSkipping(unittest2.TestCase): self.assertEqual(result.skipped, [(test, "testing")]) self.assertFalse(Foo.wasSetUp) self.assertFalse(Foo.wasTornDown) - + def test_decorated_skip(self): def decorator(func): def inner(*a): return func(*a) return inner - + class Foo(unittest2.TestCase): + @decorator @unittest2.skip('testing') def test_1(self): pass - + result = unittest2.TestResult() test = Foo("test_1") suite = unittest2.TestSuite([test]) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py index 64a72bbdf147..570a9c6b17a6 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py @@ -3,20 +3,27 @@ from unittest2.test.support import EqualityMixin, LoggingResult import sys import unittest2 + class Test(object): + class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass + def test_3(self): pass + def runTest(self): pass + def _mk_TestSuite(*names): return unittest2.TestSuite(Test.Foo(n) for n in names) class Test_TestSuite(unittest2.TestCase, EqualityMixin): - ### Set up attributes needed by inherited tests + # Set up attributes needed by inherited tests ################################################################ # Used by EqualityMixin.test_eq @@ -31,9 +38,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): (_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))] ################################################################ - ### /Set up attributes needed by inherited tests + # /Set up attributes needed by inherited tests - ### Tests for TestSuite.__init__ + # Tests for TestSuite.__init__ ################################################################ # "class TestSuite([tests])" @@ -93,7 +100,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): self.assertEqual(suite.countTestCases(), 2) ################################################################ - ### /Tests for TestSuite.__init__ + # /Tests for TestSuite.__init__ # Container types should support the iter protocol def test_iter(self): @@ -121,6 +128,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # TestSuite instances) returns 0? def test_countTestCases_zero_nested(self): class Test1(unittest2.TestCase): + def test(self): pass @@ -145,7 +153,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # Make sure this holds for nested TestSuite instances, too def test_countTestCases_nested(self): class Test1(unittest2.TestCase): + def test1(self): pass + def test2(self): pass test2 = unittest2.FunctionTestCase(lambda: None) @@ -188,10 +198,12 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): result = LoggingResult(events) class LoggingCase(unittest2.TestCase): + def run(self, result): events.append('run %s' % self._testMethodName) def test1(self): pass + def test2(self): pass tests = [LoggingCase('test1'), LoggingCase('test2')] @@ -203,6 +215,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # "Add a TestCase ... to the suite" def test_addTest__TestCase(self): class Foo(unittest2.TestCase): + def test(self): pass test = Foo('test') @@ -216,6 +229,7 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # "Add a ... TestSuite to the suite" def test_addTest__TestSuite(self): class Foo(unittest2.TestCase): + def test(self): pass suite_2 = unittest2.TestSuite([Foo('test')]) @@ -233,7 +247,9 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # each element" def test_addTests(self): class Foo(unittest2.TestCase): + def test_1(self): pass + def test_2(self): pass test_1 = Foo('test_1') @@ -294,35 +310,41 @@ class Test_TestSuite(unittest2.TestCase, EqualityMixin): # when the bug is fixed this line will not crash suite.run(unittest2.TestResult()) - def test_basetestsuite(self): class Test(unittest2.TestCase): wasSetUp = False wasTornDown = False + @classmethod def setUpClass(cls): cls.wasSetUp = True + @classmethod def tearDownClass(cls): cls.wasTornDown = True + def testPass(self): pass + def testFail(self): fail + class Module(object): wasSetUp = False wasTornDown = False + @staticmethod def setUpModule(): Module.wasSetUp = True + @staticmethod def tearDownModule(): Module.wasTornDown = True - + Test.__module__ = 'Module' sys.modules['Module'] = Module self.addCleanup(sys.modules.pop, 'Module') - + suite = unittest2.BaseTestSuite() suite.addTests([Test('testPass'), Test('testFail')]) self.assertEqual(suite.countTestCases(), 2) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py index ddb88ace82ae..6ebf6ce9c04f 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py @@ -7,6 +7,7 @@ import warnings # needed to enable the deprecation warnings warnings.simplefilter('default') + class TestWith(unittest2.TestCase): """Tests that use the with statement live in this module so that all other tests can be run with Python 2.4. @@ -27,7 +28,6 @@ class TestWith(unittest2.TestCase): self.assertIsInstance(e, ExceptionMock) self.assertEqual(e.args[0], v) - def test_assertRaises(self): def _raise(e): raise e @@ -73,7 +73,8 @@ class TestWith(unittest2.TestCase): with catch_warnings(record=True): # This causes a UnicodeWarning due to its craziness one = ''.join(chr(i) for i in range(255)) - # this used to cause a UnicodeDecodeError constructing the failure msg + # this used to cause a UnicodeDecodeError constructing the failure + # msg with self.assertRaises(self.failureException): self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'}) @@ -83,7 +84,7 @@ class TestWith(unittest2.TestCase): one = ''.join(chr(i) for i in range(255)) # this used to cause a UnicodeDecodeError constructing msg self._formatMessage(one, u'\uFFFD') - + def assertOldResultWarning(self, test, failures): with catch_warnings(record=True) as log: result = OldTestResult() @@ -94,31 +95,37 @@ class TestWith(unittest2.TestCase): def test_old_testresult(self): class Test(unittest2.TestCase): + def testSkip(self): self.skipTest('foobar') + @unittest2.expectedFailure def testExpectedFail(self): raise TypeError + @unittest2.expectedFailure def testUnexpectedSuccess(self): pass - - for test_name, should_pass in (('testSkip', True), - ('testExpectedFail', True), + + for test_name, should_pass in (('testSkip', True), + ('testExpectedFail', True), ('testUnexpectedSuccess', False)): test = Test(test_name) self.assertOldResultWarning(test, int(not should_pass)) - + def test_old_testresult_setup(self): class Test(unittest2.TestCase): + def setUp(self): self.skipTest('no reason') + def testFoo(self): pass self.assertOldResultWarning(Test('testFoo'), 0) - + def test_old_testresult_class(self): class Test(unittest2.TestCase): + def testFoo(self): pass Test = unittest2.skip('no reason')(Test) diff --git a/lldb/third_party/Python/module/unittest2/unittest2/util.py b/lldb/third_party/Python/module/unittest2/unittest2/util.py index c45d008cc886..d059861600ae 100644 --- a/lldb/third_party/Python/module/unittest2/unittest2/util.py +++ b/lldb/third_party/Python/module/unittest2/unittest2/util.py @@ -4,6 +4,8 @@ __unittest = True _MAX_LENGTH = 80 + + def safe_repr(obj, short=False): try: result = repr(obj) @@ -13,15 +15,18 @@ def safe_repr(obj, short=False): return result return result[:_MAX_LENGTH] + ' [truncated]...' + def safe_str(obj): try: return str(obj) except Exception: return object.__str__(obj) + def strclass(cls): return "%s.%s" % (cls.__module__, cls.__name__) + def sorted_list_difference(expected, actual): """Finds elements in only one or the other of two, sorted input lists. @@ -62,6 +67,7 @@ def sorted_list_difference(expected, actual): break return missing, unexpected + def unorderable_list_difference(expected, actual, ignore_duplicate=False): """Same behavior as sorted_list_difference but for lists of unorderable items (like dicts). |