diff -r 000000000000 -r 2e8eeb919028 configurationengine/source/testautomation/testautomation/base_testcase.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/configurationengine/source/testautomation/testautomation/base_testcase.py	Thu Mar 11 17:04:37 2010 +0200
@@ -0,0 +1,363 @@
+#
+# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description: 
+#
+
+import sys, os, re, unittest, shutil, zipfile, filecmp, subprocess
+
+class BaseTestCase(unittest.TestCase):
+    def set_modification_reference_time(self, path):
+        """
+        Set modification reference time for a subsequent call to assert_modified()
+        or assert_not_modified().
+        @param path: The path to use, can be a file or a directory.
+        """
+        if not hasattr(self, '_mod_refs'):
+            self._mod_refs = {}
+        
+        if os.path.isdir(path):
+            self._mod_refs[path] = self._get_dir_modtime_dict(path)
+        elif os.path.isfile(path):
+            self._mod_refs[path] = os.stat(path).st_mtime
+        else:
+            self.fail("'%s' does not exist" % path)
+    
+    def assert_modified(self, path):
+        """
+        Assert that a given file or directory has been modified since the last
+        call to set_modification_reference_time() with the same path.
+        """
+        self._assert_modification(path, assert_not_modified=False)
+    
+    def assert_not_modified(self, path):
+        """
+        Assert that a given file or directory has NOT been modified since the last
+        call to set_modification_reference_time() with the same path.
+        """
+        self._assert_modification(path, assert_not_modified=True)
+    
+    def remove_if_exists(self, path_or_paths):
+        """Remove files or directories if they exist.
+        @param path_or_paths: The path to remove. Can also be a list of paths."""
+        if isinstance(path_or_paths, list):
+            paths = path_or_paths
+        else:
+            paths = [path_or_paths]
+        
+        for path in paths:
+            if os.path.isdir(path):
+                shutil.rmtree(path)
+            elif os.path.isfile(path):
+                os.remove(path)
+    
+    def create_dir(self, path):
+        """Create the given directory if it doesn't exist."""
+        if not os.path.exists(path):
+            os.makedirs(path)
+    
+    def recreate_dir(self, path):
+        """Remove the given directory if it exists, and recreate it."""
+        if os.path.exists(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
+    
+    def create_dir_for_file_path(self, path):
+        """Create the directories for the given file"""
+        dir = os.path.dirname(path)
+        if dir != '' and not os.path.exists(dir):
+            os.makedirs(dir)
+    
+    def assert_exists_and_contains_something(self, path):
+        """
+        Assert that the given path is a file or a directory and contains some data.
+        """
+        if os.path.isdir(path):
+            if len(os.listdir(path)) == 0:
+                self.fail("Path '%s' exists (is a directory) but does not contain anything)" % path)
+        elif os.path.isfile(path):
+            if os.stat(path).st_size == 0:
+                self.fail("Path '%s' exists (is a file) but does not contain anything)" % path)
+        else:
+            self.fail("Path '%s' does not exist" % path)
+    
+    def assert_dir_contents_equal(self, dir1, dir2, ignore=[], custom_comparison_functions={}, current_root_dir=''):
+        """
+        Assert recursively that the contents of two directories are equal.
+        @param ignore: List containing names that should be ignored in the comparison (e.g. '.svn').
+            The entries can either be relative, e.g. 'file.txt', which would ignore 'file.txt'
+            in any directory, or they can be absolute, e.g. '/some/dir/file.txt', which would
+            ignore 'file.txt' only under 'some/dir/', relative to the comparison root.
+        @param custom_comparison_functions: Dictionary containing custom comparison functions
+            for files. Each entry in the dict should contain the following contents:
+                Key: The relative path of the file under the directories, e.g.
+                    'some/path/file.txt'
+                Value: The function used to compare the file contents. The function should
+                    take as parameters the raw binary data of the files, and should return
+                    True if the contents are equal.
+        @param current_root_dir: For internal use.
+        """
+        msg = "Directory contents are not equal ('%s' vs. '%s')\n" % (dir1, dir2)
+        
+        ignore_list = []
+        for entry in ignore:
+            if entry.startswith('/'):
+                dirname, entryname = entry.rsplit('/', 1)
+                dirname = dirname.lstrip('/')
+                #print "dirname = %r" % dirname
+                #print "entryname = %r" % entryname
+                #print "current_root_dir = %r" % current_root_dir
+                if dirname == current_root_dir.rstrip('/'):
+                    ignore_list.append(entryname)
+            else:
+                ignore_list.append(entry)
+
+        # Compare files with the custom comparison functions if necessary
+        for path, func in custom_comparison_functions.iteritems():
+            dirname  = os.path.dirname(path).replace('\\', '/')
+            filename = os.path.basename(path)
+            
+            filepath1 = os.path.join(dir1, filename)
+            filepath2 = os.path.join(dir2, filename)
+            
+            # Compare if the file is in the current path and they both exist
+            if dirname == current_root_dir and \
+                os.path.isfile(filepath1) and \
+                os.path.isfile(filepath2):
+                comp_result = func(
+                    self.read_data_from_file(filepath1),
+                    self.read_data_from_file(filepath2))
+                if not comp_result:
+                    # The files are not equal -> fail
+                    self.fail(msg + "File '%s' differs" % filename)
+                else:
+                    # The files are equal -> ignore from dircmp comparison
+                    ignore_list.append(filename)
+        
+        dcmp = filecmp.dircmp(dir1, dir2, ignore=ignore_list)
+        self.assertEquals(0, len(dcmp.left_only), msg + "Files only on left: %s" % dcmp.left_only)
+        self.assertEquals(0, len(dcmp.right_only), msg + "Files only on right: %s" % dcmp.right_only)
+        self.assertEquals(0, len(dcmp.diff_files), msg + "Differing files: %s" % dcmp.diff_files)
+        self.assertEquals(0, len(dcmp.funny_files), msg + "Funny files: %s" % dcmp.funny_files)
+        # Recurse into sub-directories
+        for d in dcmp.common_dirs:
+            if current_root_dir:    cr = current_root_dir + '/' + d
+            else:                   cr = d
+            self.assert_dir_contents_equal(
+                os.path.join(dir1, d), os.path.join(dir2, d),
+                ignore, custom_comparison_functions, cr)
+    
+    def assert_file_contents_equal(self, file1, file2, ignore_patterns=[]):
+        """
+        Assert the the given two files exist and their contents are equal.
+        @param ignore_patterns: List of regular expressions for portions of the
+            file content to ignore in the comparison. The ignored parts are
+            deleted from the files before actual comparison.
+        """
+        self.assertTrue(os.path.exists(file1), "File '%s' does not exist!" % file1)
+        self.assertTrue(os.path.exists(file2), "File '%s' does not exist!" % file2)
+        
+        data1 = self.read_data_from_file(file1)
+        data2 = self.read_data_from_file(file2)
+        
+        def remove_ignored(data, pattern_list):
+            for i, pattern in enumerate(pattern_list):
+                data = re.sub(pattern, '{{{ignore_%d}}}' % i, data)
+            return data
+        data1 = remove_ignored(data1, ignore_patterns)
+        data2 = remove_ignored(data2, ignore_patterns)
+        
+        if data1 != data2:
+            if len(ignore_patterns) > 0:
+                self.write_data_to_file(file1 + '.comparetemp', data1)
+                self.write_data_to_file(file2 + '.comparetemp', data2)
+                self.fail("Data of the files '%s' and '%s' are not equal\nSee *.comparetemp files for the actual data that was compared." % (file1, file2))
+            else:
+                self.fail("Data of the files '%s' and '%s' are not equal" % (file1, file2))
+    
+    def assert_file_content_equals(self, filepath, expected_data):
+        """
+        Assert that the content of the given file is equals to the given expected data.
+        """
+        self.assertTrue(os.path.exists(filepath), "'%s' does not exist!" % filepath)
+        self.assertTrue(os.path.isfile(filepath), "'%s' is not a file!" % filepath)
+        
+        f = open(filepath, "rb")
+        try:        filedata = f.read()
+        finally:    f.close()
+        
+        if filedata != expected_data:
+            msg = ("The content of the file '%s' is not what was expected!\n" % filepath) +\
+                  ("Expected: %r\nActual: %r" % (expected_data, filedata))
+            self.fail(msg)
+    
+    def assert_file_contains(self, filepath, data, encoding=None):
+        """
+        Assert that the given file contains the given text somewhere in its contents.
+        @param filepath: Path to the file to check.
+        @param data: The data the file is expected to contain.
+        @param encoding: Encoding used to decode the contents of the file.
+            If None, noe decoding is done.
+        """
+        self.assertTrue(os.path.exists(filepath), "'%s' does not exist!" % filepath)
+        self.assertTrue(os.path.isfile(filepath), "'%s' is not a file!" % filepath)
+        
+        f = open(filepath, "rb")
+        try:        filedata = f.read()
+        finally:    f.close()
+        
+        if encoding is not None:
+            filedata = filedata.decode(encoding)
+        
+        if not isinstance(data, list):
+            data = [data]
+        
+        for entry in data:
+            if not filedata.find(entry) != -1:
+                self.fail("The file '%s' does not contain the data '%s'" % (filepath, entry))
+
+    def assert_file_does_not_contain(self, filepath, data, encoding=None):
+        """
+        Assert that the given file doesn't contain the given text somewhere in its contents.
+        @param filepath: Path to the file to check.
+        @param data: The data the file is expected to not contain.
+        @param encoding: Encoding used to decode the contents of the file.
+            If None, noe decoding is done.
+        """
+        self.assertTrue(os.path.exists(filepath), "'%s' does not exist!" % filepath)
+        self.assertTrue(os.path.isfile(filepath), "'%s' is not a file!" % filepath)
+        
+        f = open(filepath, "rb")
+        try:        filedata = f.read()
+        finally:    f.close()
+        
+        if encoding is not None:
+            filedata = filedata.decode(encoding)
+        
+        if not isinstance(data, list):
+            data = [data]
+        
+        for entry in data:
+            if not filedata.find(entry) == -1:
+                self.fail("The file '%s' contains the data '%s'" % (filepath, entry))
+    
+    def read_data_from_file(self, path):
+        """Read the raw binary data from the given file."""
+        f = open(path, "rb")
+        try:        return f.read()
+        finally:    f.close()
+    
+    def read_data_from_zip_file(self, path, entry):
+        """Read the raw binary data from the given ZIP file with the given ZIP entry."""
+        zf = zipfile.ZipFile(path, "r")
+        try:        return zf.read(entry)
+        finally:    zf.close()
+    
+    def write_data_to_file(self, path, data):
+        """Write raw binary data into the given file."""
+        f = open(path, "wb")
+        try:        f.write(data)
+        finally:    f.close()
+    
+    def run_command(self, command, expected_return_code=0):
+        """
+        Run the given command, asserting that it returns the expected value.
+        @param command: The command to run.
+        @param expected_return_code: The expected return code. Can be None if the return
+            code doesn't matter.
+        @return: The command output.
+        """
+        # Using shell=True on windows uses
+        #    cmd.exe /c <command>
+        # to run the actual command, and if cmd.exe sees that the first
+        # character in the command is ", it strips that and a trailing ".
+        # For this reason we add quotes to the command to prevent e.g.
+        #   "C:\some\command.cmd" --some-arg "xyz"
+        # from becoming
+        #   C:\some\command.cmd" --some-arg "xyz
+        if sys.platform == 'win32' and command.startswith('"'):
+            command = '"' + command + '"'
+        
+        p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
+        out, err = p.communicate()
+        if expected_return_code is not None:
+            self.assertTrue(p.returncode == expected_return_code,
+                            "Could not execute command (%s)\n"\
+                            "Return code is not what was expected (expected %d, got %d)\n"\
+                            "Output: \n%s" % (command, expected_return_code, p.returncode, out))
+        return out
+    
+    # =====================================================
+    # Private helper methods
+    # =====================================================
+    
+    def _get_dir_modtime_dict(self, dir_path):
+        """
+        Return a dictionary of all files and directories and their last
+        modification times in a given directory.
+        """
+        refdict = {}
+        for root, dirs, files in os.walk(dir_path):
+            for f in files:
+                path = os.path.join(root, f)
+                refdict[path] = os.stat(path).st_mtime
+            for d in dirs:
+                path = os.path.join(root, d)
+                refdict[path] = os.stat(path).st_mtime
+        return refdict
+    
+    def _assert_modification(self, path, assert_not_modified=True):
+        if os.path.isdir(path):
+            if assert_not_modified:
+                self._assert_dir_not_modified(path)
+            else:
+                self.assert_dir_modified(path)
+        elif os.path.isfile(path):
+            if assert_not_modified:
+                self._assert_file_not_modified(path)
+            else:
+                self._assert_file_modified(path)
+        else:
+            self.fail("'%s' does not exist" % path)
+    
+    def _assert_dir_not_modified(self, dir_path):
+        refdict = self._mod_refs[dir_path]
+        curdict = self._get_dir_modtime_dict(dir_path)
+        
+        # If the keys of the dicts are not the same, the contents of the
+        # dir have been modified (added or removed files/subdirs)
+        self.assertEquals(curdict.keys(), refdict.keys())
+        
+        # Compare manually so that assertion error output shows the specific file/dir
+        for path in curdict.iterkeys():
+            self.assertEquals(curdict[path], refdict[path], "File or dir '%s' modified" % path)
+    
+    def assert_dir_modified(self, dir_path):
+        refdict = self._mod_refs[dir_path]
+        curdict = self._get_dir_modtime_dict(dir_path)
+        
+        self.assertNotEqual(curdict, refdict, "Directory '%s' has not been modified when it was expected to be" % dir_path)
+    
+    def _assert_file_not_modified(self, file_path):
+        time1 = self._mod_refs[file_path]
+        time2 = os.stat(file_path).st_mtime
+        self.assertEquals(time1, time2,
+            ("File '%s' was modified when it should not have been "+\
+            "(mod time %f vs. %f)") % (file_path, time1, time2))
+    
+    def _assert_file_modified(self, file_path):
+        time1 = self._mod_refs[file_path]
+        time2 = os.stat(file_path).st_mtime
+        self.assertNotEqual(time1, time2,
+            ("File '%s' was modified not when it should have been "+\
+            "(mod time %f vs. %f)") % (file_path, time1, time2))