Add new tests for QmakePlugin

Rename test cases for QmakeStudentFilePolicy

Add test for QmakePlugin

Author: Kimmo Linnavuo

tmc-langs-qmake/src/test/java/fi/helsinki/cs/tmc/langs/qmake/QmakePluginTest.java

@@ -6,6 +6,7 @@
 
 import fi.helsinki.cs.tmc.langs.domain.ExerciseDesc;
 import fi.helsinki.cs.tmc.langs.domain.RunResult;
+import fi.helsinki.cs.tmc.langs.domain.TestDesc;
 import fi.helsinki.cs.tmc.langs.utils.TestUtils;
 
 import com.google.common.base.Optional;
@@ -14,7 +15,6 @@
 
 import java.nio.file.Path;
 
-
 public class QmakePluginTest {
 
     private final QmakePlugin qmakePlugin;
@@ -29,39 +29,104 @@ public void testGetLanguageName() {
     }
 
     @Test
-    public void testQtBuildFailingWithNoLib() {
-        assertEquals(RunResult.Status.PASSED, runTests("passing_nolib"));
+    public void testQtTestsPassingWithNoLib() {
+        assertEquals("Tests passing with no library",
+                RunResult.Status.PASSED,
+                runTests("passing_nolib"));
+    }
+
+    @Test
+    public void testQtTestsPassingWithNoLibSamePoints() {
+        assertEquals("Tests passing with no library and same points",
+                RunResult.Status.PASSED,
+                runTests("passing_nolib_same_point"));
+    }
+
+    @Test
+    public void testQtTestsPassingWithMultipleLib() {
+        assertEquals("Tests passing with multiple libraries",
+                RunResult.Status.PASSED,
+                runTests("passing_multiple_lib"));
     }
 
     @Test
     public void testQtBuildFailingWithSingleLib() {
-        assertEquals("Failing compile with single lib",
+        assertEquals("Student source not compiling with compiling single lib",
                 RunResult.Status.COMPILE_FAILED,
                 runTests("failing_compile_single_lib_compiling"));
     }
 
+    @Test
+    public void testQtFailingSingleLib() {
+        assertEquals("Tests failing with single library",
+                RunResult.Status.TESTS_FAILED,
+                runTests("failing_single_lib"));
+    }
+
     @Test
     public void testQtLibBuildFailing() {
-        assertEquals(RunResult.Status.COMPILE_FAILED, runTests("failing_single_lib_not_compiling"));
+        assertEquals("Student source compiling with library not compiling ",
+                RunResult.Status.COMPILE_FAILED,
+                runTests("failing_single_lib_not_compiling"));
     }
 
     @Test
     public void testQTestsFailingNoLib() {
-        assertEquals(RunResult.Status.TESTS_FAILED, runTests("failing_nolib"));
+        assertEquals("Tests fail with no library",
+                RunResult.Status.TESTS_FAILED,
+                runTests("failing_nolib"));
     }
 
     @Test
     public void testQtTestsPassingSingleLib() {
-        assertEquals(RunResult.Status.PASSED, runTests("passing_single_lib"));
+        assertEquals("Tests pass with single library",
+                RunResult.Status.PASSED,
+                runTests("passing_single_lib"));
     }
 
     @Test
     public void testQtTestsFailingNoLibSamePoints() {
-        assertEquals("Failing no library",
+        assertEquals("Failing suite test with no library",
                 RunResult.Status.TESTS_FAILED,
                 runTests("failing_nolib_same_point"));
     }
 
+    @Test
+    public void testQtTestsInvalidProFile() {
+        assertEquals("Invalid .pro file does not compile",
+                RunResult.Status.COMPILE_FAILED,
+                runTests("invalid_pro_file"));
+    }
+
+    @Test
+    public void testScanInvalidMakefileExercise() {
+        Optional<ExerciseDesc> optional = scanExercise("makefile");
+        assertFalse(optional.isPresent());
+    }
+
+    @Test
+    public void testScanExerciseWithPassingSamePoints() {
+        Optional<ExerciseDesc> optional = scanExercise("passing_single_lib");
+        assertTrue(optional.isPresent());
+
+        ExerciseDesc desc = optional.get();
+
+        assertEquals("passing_single_lib", desc.name);
+
+        assertEquals(2, desc.tests.size());
+        TestDesc test1 = desc.tests.get(1);
+        TestDesc test2 = desc.tests.get(0);
+
+        assertEquals("test_function_one_here", test1.name);
+        assertEquals("test_function_two_here", test2.name);
+
+        assertEquals(1, test1.points.size());
+        assertEquals("1", test1.points.get(0));
+
+        assertEquals(1, test2.points.size());
+        assertEquals("2", test2.points.get(0));
+    }
+
     @Test
     public void testScanExerciseWithFailingSamePoints() {
         Optional<ExerciseDesc> optional = scanExercise("failing_single_lib_same_point");
@@ -72,10 +137,21 @@ public void testScanExerciseWithFailingSamePoints() {
         assertEquals("failing_single_lib_same_point", desc.name);
 
         assertEquals(3, desc.tests.size());
-        assertEquals("test_function_two_here", desc.tests.get(0).name);
+        TestDesc test2 = desc.tests.get(0);
+        TestDesc test21 = desc.tests.get(1);
+        TestDesc test1 = desc.tests.get(2);
+
+        assertEquals("test_function_one_here", test1.name);
+        assertEquals("test_function_two_here", test2.name);
+        assertEquals("test_function_two_here_2", test21.name);
 
-        assertEquals(1, desc.tests.get(0).points.size());
-        assertEquals("2", desc.tests.get(0).points.get(0));
+        assertEquals(1, test1.points.size());
+        assertEquals(1, test2.points.size());
+        assertEquals(1, test21.points.size());
+
+        assertEquals("1", test1.points.get(0));
+        assertEquals("2", test2.points.get(0));
+        assertEquals("1", test21.points.get(0));
     }
 
     @Test
@@ -88,12 +164,12 @@ public void testIsExerciseTypeCorrect() {
         assertTrue(isExerciseTypeCorrect("passing_multiple_lib"));
         assertTrue(isExerciseTypeCorrect("passing_multiple_lib_same_point"));
 
-        assertTrue(isExerciseTypeCorrect("failing_single_lib_not_compiling"));
         assertTrue(isExerciseTypeCorrect("failing_nolib"));
         assertTrue(isExerciseTypeCorrect("failing_nolib_same_point"));
         assertTrue(isExerciseTypeCorrect("failing_single_lib"));
         assertTrue(isExerciseTypeCorrect("failing_single_lib_not_compiling"));
         assertTrue(isExerciseTypeCorrect("failing_single_lib_same_point"));
+        assertFalse(isExerciseTypeCorrect("makefile"));
         assertFalse(isExerciseTypeCorrect(""));
     }
 

tmc-langs-qmake/src/test/java/fi/helsinki/cs/tmc/langs/qmake/QmakeStudentFilePolicyTest.java

@@ -0,0 +1,69 @@
+package fi.helsinki.cs.tmc.langs.qmake;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import fi.helsinki.cs.tmc.langs.utils.TestUtils;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+public class QmakeStudentFilePolicyTest {
+
+    private Path singleLib;
+    private QmakeStudentFilePolicy qmakeStudentFilePolicy;
+
+    private final String srcDir = "src" + File.separatorChar;
+    private final String testDir = "test_case_test_runner" + File.separatorChar;
+    private final String libDir = "test_case_lib" + File.separatorChar;
+
+    @Before
+    public void setUp() {
+        singleLib = TestUtils.getPath(getClass(), "passing_single_lib");
+        qmakeStudentFilePolicy = new QmakeStudentFilePolicy(singleLib);
+    }
+
+    @Test
+    public void testMovesFilesInSrc() throws IOException {
+        final List<String> toBeMoved = new ArrayList<>();
+
+        TestUtils.collectPaths(singleLib, toBeMoved, qmakeStudentFilePolicy);
+        assertEquals(2, toBeMoved.size());
+
+        assertTrue(toBeMoved.contains(srcDir + "src.pro"));
+        assertTrue(toBeMoved.contains(srcDir + "main.cpp"));
+    }
+
+    @Test
+    public void testDoesNotMoveFilesInTest() throws IOException {
+        final List<String> toBeMoved = new ArrayList<>();
+
+        TestUtils.collectPaths(singleLib, toBeMoved, qmakeStudentFilePolicy);
+
+        assertEquals(2, toBeMoved.size());
+
+        assertFalse(toBeMoved.contains(testDir + "test_case_test_runner.pro"));
+        assertFalse(toBeMoved.contains(testDir + "test_case_test_runner.cpp"));
+        assertFalse(toBeMoved.contains(testDir + "test_case_test_runner.h"));
+        assertFalse(toBeMoved.contains(testDir + "main.cpp"));
+    }
+
+    @Test
+    public void testDoesNotMoveFilesInLibrary() throws IOException {
+        final List<String> toBeMoved = new ArrayList<>();
+
+        TestUtils.collectPaths(singleLib, toBeMoved, qmakeStudentFilePolicy);
+
+        assertEquals(2, toBeMoved.size());
+        assertFalse(toBeMoved.contains(libDir + "test_case_lib.cpp"));
+        assertFalse(toBeMoved.contains(libDir + "test_case_lib.h"));
+        assertFalse(toBeMoved.contains(libDir + "test_case_lib.pro"));
+    }
+}

tmc-langs-qmake/src/test/resources/failing_compile_single_lib_compiling/test_case_app/main.cpp renamed to tmc-langs-qmake/src/test/resources/failing_compile_single_lib_compiling/src/main.cpp

@@ -1,4 +1,4 @@
 TEMPLATE = subdirs
 SUBDIRS += \
-	test_case_app \
+	src \
 	test_case_test_runner 

tmc-langs-qmake/src/test/resources/failing_compile_single_lib_compiling/test_case_app/test_case_app.pro renamed to tmc-langs-qmake/src/test/resources/failing_compile_single_lib_compiling/src/test_case_app.pro

@@ -12,11 +12,11 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 SOURCES += main.cpp \
         test_case_test_runner.cpp \
-        $$PWD/../test_case_app/test_case_app.cpp
+        $$PWD/../src/test_case_app.cpp
 
 HEADERS += \
 	test_case_test_runner.h
 
-INCLUDEPATH += $$PWD/../test_case_app
+INCLUDEPATH += $$PWD/../src