test/functionalities/completion/TestCompletion.py

"""
Test the lldb command line completion mechanism.
"""

import os
import unittest2
import lldb
import pexpect
from lldbtest import *

class CommandLineCompletionTestCase(TestBase):

    mydir = os.path.join("functionalities", "completion")

    @classmethod
    def classCleanup(cls):
        """Cleanup the test byproducts."""
        system(["/bin/sh", "-c", "rm -f child_send.txt"])
        system(["/bin/sh", "-c", "rm -f child_read.txt"])

    def test_frame_variable_dash_w(self):
        """Test that 'frame variable -w' completes to 'frame variable -w '."""
        self.complete_from_to('frame variable -w', 'frame variable -w ')

    def test_frame_variable_dash_w_space(self):
        """Test that 'frame variable -w ' completes to ['Available completions:', 'read', 'write', 'read_write']."""
        self.complete_from_to('frame variable -w ', ['Available completions:', 'read', 'write', 'read_write'])

    def test_watchpoint_set_dash_x(self):
        """Test that 'watchpoint set -x' completes to 'watchpoint set -x '."""
        self.complete_from_to('watchpoint set -x', 'watchpoint set -x ')

    def test_watchpoint_set_dash_w_read_underbar(self):
        """Test that 'watchpoint set -w read_' completes to 'watchpoint set -w read_write'."""
        self.complete_from_to('watchpoint set -w read_', 'watchpoint set -w read_write')

    def test_help_fi(self):
        """Test that 'help fi' completes to ['Available completions:', 'file', 'finish']."""
        self.complete_from_to('help fi', ['Available completions:', 'file', 'finish'])

    def test_help_watchpoint_s(self):
        """Test that 'help watchpoint s' completes to 'help watchpoint set '."""
        self.complete_from_to('help watchpoint s', 'help watchpoint set ')

    def test_settings_append_target_er(self):
        """Test that 'settings append target.er' completes to 'settings append target.error-path'."""
        self.complete_from_to('settings append target.er', 'settings append target.error-path')

    def test_settings_insert_after_target_en(self):
        """Test that 'settings insert-after target.en' completes to 'settings insert-after target.env-vars'."""
        self.complete_from_to('settings insert-after target.en', 'settings insert-after target.env-vars')

    def test_settings_insert_before_target_en(self):
        """Test that 'settings insert-before target.en' completes to 'settings insert-before target.env-vars'."""
        self.complete_from_to('settings insert-before target.en', 'settings insert-before target.env-vars')

    def test_settings_replace_target_ru(self):
        """Test that 'settings replace target.ru' completes to 'settings replace target.run-args'."""
        self.complete_from_to('settings replace target.ru', 'settings replace target.run-args')

    def test_settings_s(self):
        """Test that 'settings s' completes to ['Available completions:', 'set', 'show']."""
        self.complete_from_to('settings s', ['Available completions:', 'set', 'show'])

    def test_settings_set_th(self):
        """Test that 'settings set th' completes to 'settings set thread-format'."""
        self.complete_from_to('settings set th', 'settings set thread-format')

    def test_settings_s_dash(self):
        """Test that 'settings set -' completes to ['Available completions:', '-n', '-r']."""
        self.complete_from_to('settings set -', ['Available completions:', '-n', '-r'])

    def test_settings_set_dash_r_th(self):
        """Test that 'settings set -r th' completes to 'settings set -r thread-format'."""
        self.complete_from_to('settings set -r th', 'settings set -r thread-format')

    def test_settings_set_ta(self):
        """Test that 'settings set ta' completes to 'settings set target.'."""
        self.complete_from_to('settings set ta', 'settings set target.')

    def test_settings_set_target_pr(self):
        """Test that 'settings set target.pr' completes to ['Available completions:',
        'target.prefer-dynamic-value', 'target.process.']."""
        self.complete_from_to('settings set target.pr',
                              ['Available completions:',
                               'target.prefer-dynamic-value',
                               'target.process.'])

    def test_settings_set_target_process(self):
        """Test that 'settings set target.process' completes to 'settings set target.process.'."""
        self.complete_from_to('settings set target.process', 'settings set target.process.')

    def test_settings_set_target_process_dot(self):
        """Test that 'settings set target.process.' completes to 'settings set target.process.thread.'."""
        self.complete_from_to('settings set target.process.', 'settings set target.process.thread.')

    def test_settings_set_target_process_thread_dot(self):
        """Test that 'settings set target.process.thread.' completes to ['Available completions:',
        'target.process.thread.step-avoid-regexp', 'target.process.thread.trace-thread']."""
        self.complete_from_to('settings set target.process.thread.',
                              ['Available completions:',
                               'target.process.thread.step-avoid-regexp',
                               'target.process.thread.trace-thread'])

    def complete_from_to(self, str_input, patterns):
        """Test that the completion mechanism completes str_input to patterns,
        where patterns could be a pattern-string or a list of pattern-strings"""
        # Patterns should not be None in order to proceed.
        self.assertFalse(patterns is None)
        # And should be either a string or list of strings.  Check for list type
        # below, if not, make a list out of the singleton string.  If patterns
        # is not a string or not a list of strings, there'll be runtime errors
        # later on.
        if not isinstance(patterns, list):
            patterns = [patterns]
        
        # The default lldb prompt.
        prompt = "(lldb) "

        # So that the child gets torn down after the test.
        self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
        child = self.child
        # Turn on logging for input/output to/from the child.
        with open('child_send.txt', 'w') as f_send:
            with open('child_read.txt', 'w') as f_read:
                child.logfile_send = f_send
                child.logfile_read = f_read

                child.expect_exact(prompt)
                child.setecho(True)
                # Sends str_input and a Tab to invoke the completion machinery.
                child.send("%s\t" % str_input)
                child.sendline('')
                child.expect_exact(prompt)

        # Now that the necessary logging is done, restore logfile to None to
        # stop further logging.
        child.logfile_send = None
        child.logfile_read = None
        
        with open('child_send.txt', 'r') as fs:
            if self.TraceOn():
                print "\n\nContents of child_send.txt:"
                print fs.read()
        with open('child_read.txt', 'r') as fr:
            from_child = fr.read()
            if self.TraceOn():
                print "\n\nContents of child_read.txt:"
                print from_child

            # Test that str_input completes to our patterns.
            # If each pattern matches from_child, the completion mechanism works!
            for p in patterns:
                self.expect(from_child, msg=COMPLETIOND_MSG(str_input, p), exe=False,
                    patterns = [p])


if __name__ == '__main__':
    import atexit
    lldb.SBDebugger.Initialize()
    atexit.register(lambda: lldb.SBDebugger.Terminate())
    unittest2.main()