Merge pull request #24 from BenjaminSchubert/master

updated test and fixed part of #23

Author: travitch

.gitignore

@@ -1 +1,2 @@
 *.pyc
+.idea

driver/as

@@ -11,11 +11,17 @@
 # compiler).  We'll link this together at a later stage.
 
 from __future__ import absolute_import
+import sys
+import os
 
-from .utils import *
+sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+
+from driver.utils import *
 from subprocess import *
-from .popenwrapper import Popen
+from driver.popenwrapper import Popen
 
+import logging
+logging.basicConfig()
 
 class BCFilter(ArgumentListFilter):
     def __init__(self, arglist):

test/Makefile

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# -*- Coding: UTF-8 -*-
+
+__author__ = 'Benjamin Schubert, ben.c.schubert@gmail.com'
+
+from abc import abstractproperty
+import os
+import shutil
+import subprocess
+import unittest
+
+
+test_output_directory = "/tmp/test-wllvm"
+test_files_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "test_files")
+root_directory = os.path.join(os.path.dirname(os.path.dirname(__file__)))
+
+
+class BaseDriverTest(unittest.TestCase):
+    """
+    This is a BaseDriverTest class. Can be used to generically test that every driver works correctly with different
+    code examples without any problem. This class is meant to be overridden
+    """
+    @classmethod
+    def setUpClass(cls):
+        """
+        This is a base class that should not be run in tests, skip it
+        :return:
+        """
+        if cls is BaseDriverTest:
+            raise unittest.SkipTest("Skip BaseDriverTest, it's a base class")
+
+    @abstractproperty
+    def env(self):
+        """
+        Defines all necessary environment variables to allow the driver to be tested, assembly seen in "Usage" in the README
+        """
+        return None
+
+    def setUp(self):
+        """
+        Creates the test directory in /tmp
+        :return:
+        """
+        if not os.path.exists(test_output_directory):
+            os.makedirs(test_output_directory)
+
+    def tearDown(self):
+        """
+        remove all temporary test files
+        :return:
+        """
+        shutil.rmtree(test_output_directory)
+
+    def launch_proc(self, cmd):
+        """
+        Launches cmd with environment and in test_output_directory
+        :param cmd: command to launch
+        :return: the subprocess instance
+        """
+        return subprocess.Popen(cmd, shell=True, env=self.env, cwd=test_output_directory)
+
+    def create_objects(self):
+        """
+        Creates some objects used by tests
+        :return:
+        """
+        for f in ["foo.c", "bar.c", "baz.c", "main.c"]:
+            self.assertEqual(self.launch_proc("${{CC}} {dir}/{f} -c".format(dir=test_files_directory, f=f)).wait(), 0)
+
+    def create_archive(self):
+        """
+        creates the libfoo.a archive
+        :return:
+        """
+        proc1 = self.launch_proc("ar cr libfoo.a foo.o bar.o baz.o")
+        self.assertEqual(proc1.wait(), 0)
+
+    def test_can_compile_simple_file(self):
+        """
+        Checks that it is possible to compile a single simple file
+        :return:
+        """
+        proc = self.launch_proc("${{CXX}} -o hello {}/hello.cc".format(test_files_directory))
+        self.assertEqual(proc.wait(), 0)
+
+    def test_can_compile_multiple_file_in_one_object(self):
+        """
+        Checks that is is possible to compile multiple files into one executable
+        :return:
+        """
+        proc = self.launch_proc(
+            "${{CC}} {dir}/foo.c {dir}/bar.c {dir}/baz.c {dir}/main.c -o main".format(dir=test_files_directory)
+        )
+        self.assertEqual(proc.wait(), 0)
+
+    def test_can_compile_and_link_multiple_object(self):
+        """
+        Checks that is is possible to compile first then link the compiled objects together
+        :return:
+        """
+        proc1 = self.launch_proc(
+            "${{CC}} {dir}/foo.c {dir}/bar.c {dir}/baz.c {dir}/main.c -c".format(dir=test_files_directory)
+        )
+        self.assertEqual(proc1.wait(), 0)
+
+        proc2 = self.launch_proc("${CC} foo.o bar.o baz.o main.o -o main")
+        self.assertEqual(proc2.wait(), 0)
+
+    def test_can_compile_and_link_object_and_source_object(self):
+        """
+        Checks that is is possible to compile some objects first, then link them while compiling others
+        :return:
+        """
+        proc1 = self.launch_proc("${{CC}} {dir}/foo.c {dir}/bar.c -c".format(dir=test_files_directory))
+        self.assertEqual(proc1.wait(), 0)
+
+        proc2 = self.launch_proc("${{CC}} foo.o bar.o {dir}/baz.c {dir}/main.c -o main".format(dir=test_files_directory))
+        self.assertEqual(proc2.wait(), 0)
+
+    def test_can_link_multiple_objects_together(self):
+        """
+        Checks that it is possible to link multiple objects together
+        :return:
+        """
+        self.create_objects()
+        proc = self.launch_proc("${CC} foo.o bar.o baz.o main.o -o main")
+        self.assertEqual(proc.wait(), 0)
+
+    def test_can_create_archive_from_object_created(self):
+        """
+        Checks that it is possible to create a valid archive from the created objects
+        :return:
+        """
+        self.create_objects()
+        self.create_archive()
+
+        proc2 = self.launch_proc("ranlib libfoo.a")
+        self.assertEqual(proc2.wait(), 0)
+
+    def test_can_create_dynamic_library_from_objects(self):
+        """
+        Checks that is is possible to create a dynamic library from the objects
+        :return:
+        """
+        self.create_objects()
+        proc = self.launch_proc("${CC} -dynamiclib foo.o bar.o baz.o main.o -o libfoo.dylib")
+        self.assertEqual(proc.wait(), 0)
+
+    def test_can_deadstrip_dynamic_library(self):
+        """
+        Checks that is is possible to create a deadstripped dynamic library from the objects
+        :return:
+        """
+        self.create_objects()
+        proc = self.launch_proc("${CC} -dynamiclib -Wl,-dead_strip foo.o bar.o baz.o main.o -o libfoo.dylib")
+        self.assertEqual(proc.wait(), 0)
+
+    def test_can_link_with_archive(self):
+        """
+        Checks that is is possible to link with a created archive
+        :return:
+        """
+        self.create_objects()
+        self.create_archive()
+
+        proc = self.launch_proc("${CC} main.o libfoo.a -o main.arch")
+        self.assertEqual(proc.wait(), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

test/test_base_driver.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- Coding: UTF-8 -*-
+import os
+from test_base_driver import root_directory, BaseDriverTest
+
+__author__ = 'Benjamin Schubert, ben.c.schubert@gmail.com'
+
+
+
+class ClangDriverTest(BaseDriverTest):
+    """
+    Clang driver tester
+    """
+    @property
+    def env(self):
+        """
+        The different environment variables used by subprocess to compile with clang and wllvm
+        :return:
+        """
+        env = os.environ.copy()
+        env["CC"] = "wllvm"
+        env["CXX"] = "wllvm++"
+        env["LLVM_COMPILER"] = "clang"
+        env["PATH"] = "{}:{}".format(root_directory, os.environ["PATH"])
+        return env

test/test_clang_driver.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- Coding: UTF-8 -*-
+import os
+from test_base_driver import root_directory, BaseDriverTest
+
+__author__ = 'Benjamin Schubert, ben.c.schubert@gmail.com'
+
+
+class DragonEggDriverTest(BaseDriverTest):
+    """
+    Dragonegg driver tester
+    """
+    @property
+    def env(self):
+        """
+        The different environment variables used by subprocess to compile with dragonegg and wllvm
+        :return:
+        """
+        env = os.environ.copy()
+        env["CC"] = "wllvm"
+        env["CXX"] = "wllvm++"
+        env["LLVM_COMPILER"] = "dragonegg"
+        env["PATH"] = "{}:{}".format(root_directory, os.environ["PATH"])
+        # FIXME find dragonegg path generically
+        env["LLVM_DRAGONEGG_PLUGIN"] = "/usr/lib/gcc/x86_64-linux-gnu/4.7/plugin/dragonegg.so"
+        env["LLVM_GCC_PREFIX"] = "llvm-"
+        return env