6 files changed, 186 insertions, 0 deletions
diff --git a/15_tests_subseq/README b/15_tests_subseq/README
new file mode 100644
index 0000000..9c98da7
--- /dev/null
+++ b/15_tests_subseq/README
@@ -0,0 +1,24 @@
+For this assignment, you will be writing testcases for
+your next assignment (as usual, the instructions for that assignment
+can be found in next-README).
+
+As usual, one correct and many broken implementations can be found
+in /usr/local/l2p/subseq.
+
+As with power, these are provided as compiled object files, and you
+should write a C program (in test-subseq.c) whose main function tests
+the maxSeq function. As before, it should exit with EXIT_SUCCESS if all
+tests pass, and EXIT_FAILURE if any test fails.  Note that you will
+need to write the prototype for maxSeq:
+
+ size_t maxSeq(int * array, size_t n);
+
+in your test-subseq.c file, so that the compiler knows about the
+maxSeq function.  The correct place to put it is after you #include
+any .h files you need, but before any other code you write.
+
+We have provided run_all.sh to help you run your test cases against
+all implementations.
+
+HINT: Think about how can you can vary not just the values in your array
+but the size as well. What about how the values change over time?
diff --git a/15_tests_subseq/grade.txt b/15_tests_subseq/grade.txt
new file mode 100644
index 0000000..37c5f52
--- /dev/null
+++ b/15_tests_subseq/grade.txt
@@ -0,0 +1,52 @@
+Grading at Thu 14 Oct 2021 02:32:07 AM UTC
+**Testing broken implementation 10 **
+-------------------------------------
+
+
+**Testing broken implementation 11 **
+-------------------------------------
+
+
+**Testing broken implementation 1 **
+-------------------------------------
+
+
+**Testing broken implementation 2 **
+-------------------------------------
+
+
+**Testing broken implementation 3 **
+-------------------------------------
+
+
+**Testing broken implementation 4 **
+-------------------------------------
+
+
+**Testing broken implementation 5 **
+-------------------------------------
+
+
+**Testing broken implementation 6 **
+-------------------------------------
+
+
+**Testing broken implementation 7 **
+-------------------------------------
+
+
+**Testing broken implementation 8 **
+-------------------------------------
+
+
+**Testing broken implementation 9 **
+-------------------------------------
+
+
+**Testing correct implementation **
+-------------------------------------
+
+
+All test programs were handled correctly
+
+Overall Grade: PASSED
diff --git a/15_tests_subseq/next-README b/15_tests_subseq/next-README
new file mode 100644
index 0000000..73a18f8
--- /dev/null
+++ b/15_tests_subseq/next-README
@@ -0,0 +1,31 @@
+
+ 1. Create a file called maxSeq.c and write the function:
+       size_t maxSeq(int * array, size_t n);
+
+    which returns the length of the maximum increasing contiguous
+    subsequence in the array.  The parameter n specifies the length
+    of the array For example, if the array passed in were
+   
+     { 1, 2, 1, 3, 5, 7, 2, 4, 6, 9}
+  
+    this function would return 4 because the longest sequence
+    of (strictly) increasing numbers in that array is 1, 3, 5, 7
+    which has length 4.  Note that 1,3,5,7,9 is an increasing
+    subsequence, but is not contiguous (finding discontiguous 
+    ones efficiently takes techniques we haven't learned yet).
+
+    Note that the subseqence does not need to increase at a
+    constant rate (or follow any other pattern besides being strictly
+    increasing).  2, 4, 67, 93, 94, 102 would be a valid increasing
+    sequence of length 6.
+
+
+2. Compile and test your code using the test-subseq.c you wrote
+   previously.  (as before, compile the .c files separately, and link
+   them together).
+
+3. Submit your code for maxSeq.c
+     
+
+Hint:
+  Can you abstract a complex step out into a simple function?
+\ No newline at end of file
diff --git a/15_tests_subseq/run_all.sh b/15_tests_subseq/run_all.sh
new file mode 100755
index 0000000..33e763d
--- /dev/null
+++ b/15_tests_subseq/run_all.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+for i in /usr/local/l2p/subseq/subseq*.o
+do
+    test=`basename $i | sed 's/subseq//' | sed 's/.o//'`
+    if [ "$test"  == "" ]
+    then
+	echo "**Testing correct implementation **"
+    else
+	echo "**Testing broken implementation ${test} **"
+    fi
+    echo "-------------------------------------"
+    echo ""
+
+    gcc -o test-subseq test-subseq.c $i
+    if [ "$?" != "0" ]
+    then
+	echo "Could not compile test-subseq.c with $i" > /dev/stderr
+	exit 1
+    fi
+    ./test-subseq
+    if [ "$?" != 0 ]
+    then
+	if [ "$test" == "" ]
+	then
+	    echo "Your test program falsely failed the correct implementation!" > /dev/stderr
+	    exit 1
+	fi
+    else
+	if [ "$test" != "" ]
+	then
+	    echo "Your test program did not identify $i as broken!" > /dev/stderr
+	    exit 1
+	fi
+    fi
+    echo ""
+done
diff --git a/15_tests_subseq/test-subseq b/15_tests_subseq/test-subseq
new file mode 100755
index 0000000..c1cc872
--- /dev/null
+++ b/15_tests_subseq/test-subseq
diff --git a/15_tests_subseq/test-subseq.c b/15_tests_subseq/test-subseq.c
new file mode 100644
index 0000000..b239cc9
--- /dev/null
+++ b/15_tests_subseq/test-subseq.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+size_t maxSeq(int * array, size_t n);
+
+int main(void) {
+  if (maxSeq(NULL, 0)) {
+    return EXIT_FAILURE;
+  }
+
+  int array1[] = {1, 2, 3, 2};
+  int array2[] = {2, -3, 5, 6, 8};
+  int array3[] = {5};
+  int array4[] = {2, 4, 3, 6, 10, 15, -1, 7, 8, 2};
+  int array5[] = {-2};
+  int array6[] = {2,2,2,3};
+
+  if (maxSeq(array1, 0)) {
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array1, 4) != 3) {    
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array2, 5) != 4) {
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array3, 1) != 1) {
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array4, 10) != 4) {
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array5, 1) != 1) {
+    return EXIT_FAILURE;
+  }
+  if (maxSeq(array6, 4) != 2) {
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}