From 49a706090a2a5db1ae9534c37dda66a6c04fda68 Mon Sep 17 00:00:00 2001 From: jljusten Date: Fri, 11 Apr 2008 05:17:59 +0000 Subject: [PATCH] BaseTools/GNUmakefile: BaseTools/Tests/*: Initial support for BaseTools unit tests. Only TianoCompress has any test cases implemented initially. git-svn-id: https://buildtools.tianocore.org/svn/buildtools/trunk/BaseTools@1142 7335b38e-4728-0410-8992-fb3ffe349368 --- GNUmakefile | 3 + Tests/CToolsTests.py | 35 ++++++++ Tests/GNUmakefile | 6 ++ Tests/PythonToolsTests.py | 29 +++++++ Tests/RunTests.py | 40 +++++++++ Tests/TestTools.py | 167 ++++++++++++++++++++++++++++++++++++++ Tests/TianoCompress.py | 74 +++++++++++++++++ 7 files changed, 354 insertions(+) create mode 100644 Tests/CToolsTests.py create mode 100644 Tests/GNUmakefile create mode 100644 Tests/PythonToolsTests.py create mode 100644 Tests/RunTests.py create mode 100644 Tests/TestTools.py create mode 100644 Tests/TianoCompress.py diff --git a/GNUmakefile b/GNUmakefile index cbe71dd..733bea7 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -17,3 +17,6 @@ $(CLEAN_SUBDIRS): clean: $(CLEAN_SUBDIRS) +test: + @$(MAKE) -C Tests + diff --git a/Tests/CToolsTests.py b/Tests/CToolsTests.py new file mode 100644 index 0000000..22179b9 --- /dev/null +++ b/Tests/CToolsTests.py @@ -0,0 +1,35 @@ +## @file +# Unit tests for C based BaseTools +# +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import sys +import unittest + +import TianoCompress +modules = ( + TianoCompress, + ) + + +def TheTestSuite(): + suites = map(lambda module: module.TheTestSuite(), modules) + return unittest.TestSuite(suites) + +if __name__ == '__main__': + allTests = TheTestSuite() + unittest.TextTestRunner().run(allTests) + diff --git a/Tests/GNUmakefile b/Tests/GNUmakefile new file mode 100644 index 0000000..8789314 --- /dev/null +++ b/Tests/GNUmakefile @@ -0,0 +1,6 @@ + +all: test + +test: + @python RunTests.py + diff --git a/Tests/PythonToolsTests.py b/Tests/PythonToolsTests.py new file mode 100644 index 0000000..de19591 --- /dev/null +++ b/Tests/PythonToolsTests.py @@ -0,0 +1,29 @@ +## @file +# Unit tests for Python based BaseTools +# +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import sys +import unittest + + +def TheTestSuite(): + return unittest.TestSuite() + +if __name__ == '__main__': + allTests = TheTestSuite() + unittest.TextTestRunner().run(allTests) + diff --git a/Tests/RunTests.py b/Tests/RunTests.py new file mode 100644 index 0000000..60ea96b --- /dev/null +++ b/Tests/RunTests.py @@ -0,0 +1,40 @@ +## @file +# Unit tests for BaseTools utilities +# +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import sys +import unittest + +import TestTools + +sys.path.append(TestTools.PythonSource) + +def GetCTestSuite(): + import CToolsTests + return CToolsTests.TheTestSuite() + +def GetPythonTestSuite(): + import PythonToolsTests + return PythonToolsTests.TheTestSuite() + +def GetAllTestsSuite(): + return unittest.TestSuite([GetCTestSuite(), GetPythonTestSuite()]) + +if __name__ == '__main__': + allTests = GetAllTestsSuite() + unittest.TextTestRunner(verbosity=2).run(allTests) + diff --git a/Tests/TestTools.py b/Tests/TestTools.py new file mode 100644 index 0000000..fc8766f --- /dev/null +++ b/Tests/TestTools.py @@ -0,0 +1,167 @@ +## @file +# Utility functions and classes for BaseTools unit tests +# +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import base64 +import os +import os.path +import random +import shutil +import subprocess +import sys +import types +import unittest + +TestsDir = os.path.realpath(os.path.split(sys.argv[0])[0]) +BaseToolsDir = os.path.realpath(os.path.join(TestsDir, '..')) +CSource = os.path.join(BaseToolsDir, 'Source', 'C') +PythonSource = os.path.join(BaseToolsDir, 'Source', 'Python') +TestTempDir = os.path.join(TestsDir, 'TestTempDir') + +def MakeTheTestSuite(localItems): + tests = [] + for name, item in localItems.iteritems(): + if isinstance(item, types.TypeType): + if issubclass(item, unittest.TestCase): + tests.append(unittest.TestLoader().loadTestsFromTestCase(item)) + elif issubclass(item, unittest.TestSuite): + tests.append(item()) + return lambda: unittest.TestSuite(tests) + +def GetBaseToolsPath(): + if sys.platform in ('win32', 'win64'): + return os.path.join(BaseToolsDir, 'Bin', sys.platform.title()) + else: + uname = os.popen('uname -sm').read().strip() + for char in (' ', '/'): + uname = uname.replace(char, '-') + return os.path.join(BaseToolsDir, 'BinWrappers', uname) + +BaseToolsBinPath = GetBaseToolsPath() + +class BaseToolsTest(unittest.TestCase): + + def cleanOutDir(self, dir): + for dirItem in os.listdir(dir): + if dirItem in ('.', '..'): continue + dirItem = os.path.join(dir, dirItem) + self.RemoveFileOrDir(dirItem) + + def CleanUpTmpDir(self): + if os.path.exists(self.testDir): + self.cleanOutDir(self.testDir) + + def HandleTreeDeleteError(self, function, path, excinfo): + os.chmod(path, stat.S_IWRITE) + function(path) + + def RemoveDir(self, dir): + shutil.rmtree(dir, False, self.HandleTreeDeleteError) + + def RemoveFileOrDir(self, path): + if not os.path.exists(path): + return + elif os.path.isdir(path): + self.RemoveDir(path) + else: + os.remove(path) + + def DisplayBinaryData(self, description, data): + print description, '(base64 encoded):' + b64data = base64.b64encode(data) + print b64data + + def DisplayFile(self, fileName): + sys.stdout.write(self.ReadTmpFile(fileName)) + sys.stdout.flush() + + def RunTool(self, *args, **kwd): + if 'toolName' in kwd: toolName = kwd['toolName'] + else: toolName = None + if 'logFile' in kwd: logFile = kwd['logFile'] + else: logFile = None + + if toolName is None: toolName = self.toolName + bin = os.path.join(self.baseToolsBins, toolName) + if logFile is not None: + logFile = open(os.path.join(self.testDir, logFile), 'w') + popenOut = logFile + else: + popenOut = subprocess.PIPE + + args = [toolName] + list(args) + + Proc = subprocess.Popen( + args, executable=bin, + stdout=popenOut, stderr=subprocess.STDOUT + ) + + if logFile is None: + Proc.stdout.read() + + return Proc.wait() + + def GetTmpFilePath(self, fileName): + return os.path.join(self.testDir, fileName) + + def OpenTmpFile(self, fileName, mode = 'r'): + return open(os.path.join(self.testDir, fileName), mode) + + def ReadTmpFile(self, fileName): + f = open(self.GetTmpFilePath(fileName), 'r') + data = f.read() + f.close() + return data + + def WriteTmpFile(self, fileName, data): + f = open(self.GetTmpFilePath(fileName), 'w') + f.write(data) + f.close() + + def GenRandomFileData(self, fileName, minlen = None, maxlen = None): + if maxlen is None: maxlen = minlen + f = self.OpenTmpFile(fileName, 'w') + f.write(self.GetRandomString(minlen, maxlen)) + f.close() + + def GetRandomString(self, minlen = None, maxlen = None): + if minlen is None: minlen = 1024 + if maxlen is None: maxlen = minlen + return ''.join( + [chr(random.randint(0,255)) + for x in xrange(random.randint(minlen, maxlen)) + ]) + + def setUp(self): + self.savedEnvPath = os.environ['PATH'] + self.savedSysPath = sys.path[:] + + self.baseToolsBins = BaseToolsBinPath + os.environ['PATH'] = \ + os.path.pathsep.join((os.environ['PATH'], self.baseToolsBins)) + + self.testDir = TestTempDir + if not os.path.exists(self.testDir): + os.mkdir(self.testDir) + else: + self.cleanOutDir(self.testDir) + + def tearDown(self): + self.RemoveFileOrDir(self.testDir) + + os.environ['PATH'] = self.savedEnvPath + sys.path = self.savedSysPath + diff --git a/Tests/TianoCompress.py b/Tests/TianoCompress.py new file mode 100644 index 0000000..dd2cdfb --- /dev/null +++ b/Tests/TianoCompress.py @@ -0,0 +1,74 @@ +## @file +# Unit tests for TianoCompress utility +# +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import random +import sys +import unittest + +import TestTools + +class Tests(TestTools.BaseToolsTest): + + def setUp(self): + TestTools.BaseToolsTest.setUp(self) + self.toolName = 'TianoCompress' + + def testHelp(self): + result = self.RunTool('--help', logFile='help') + #self.DisplayFile('help') + self.assertTrue(result == 0) + + def compressionTestCycle(self, data): + path = self.GetTmpFilePath('input') + self.WriteTmpFile('input', data) + result = self.RunTool( + '-e', + '-o', self.GetTmpFilePath('output1'), + self.GetTmpFilePath('input') + ) + self.assertTrue(result == 0) + result = self.RunTool( + '-d', + '-o', self.GetTmpFilePath('output2'), + self.GetTmpFilePath('output1') + ) + self.assertTrue(result == 0) + start = self.ReadTmpFile('input') + finish = self.ReadTmpFile('output2') + startEqualsFinish = start == finish + if not startEqualsFinish: + print + print 'Original data did not match decompress(compress(data))' + self.DisplayBinaryData('original data', start) + self.DisplayBinaryData('after compression', self.ReadTmpFile('output1')) + self.DisplayBinaryData('after decomression', finish) + self.assertTrue(startEqualsFinish) + + def testRandomDataCycles(self): + for i in range(8): + data = self.GetRandomString(1024, 2048) + self.compressionTestCycle(data) + self.CleanUpTmpDir() + +TheTestSuite = TestTools.MakeTheTestSuite(locals()) + +if __name__ == '__main__': + allTests = TheTestSuite() + unittest.TextTestRunner().run(allTests) + + -- 2.17.1