Commit 951ade42 authored by Ari Trachtenberg's avatar Ari Trachtenberg
Browse files

3a has different length reads for different students - disabled for now.

parent b062daa5

tests/testSequenceA.cpp

+133 −127
Original line number Diff line number Diff line
@@ -5,9 +5,12 @@ 
#include <vector>

#include <array>

#include <string>

#include <type_traits>



using namespace std;



string sequence(const vector<array<char,5>>& reads);

string sequence(const vector<array<char,6>>& reads);

string sequence(const vector<array<char,7>>& reads);



// helper
@@ -17,6 +20,7 @@ bool failExample(const char* testName, const string& msg, string expected, strin 
         << ", got " << got << "\n";

    return false;

}



// helper function: consistent warning printing

bool warnExample(const char* testName,

                 const std::string& msg,
@@ -27,133 +31,135 @@ bool warnExample(const char* testName, 
    return false;

}



template <size_t N, typename = void>

struct has_sequence : std::false_type {};



template <size_t N>

struct has_sequence<N, std::void_t<

    decltype(sequence(std::declval<const std::vector<std::array<char,N>>&>()))

>> : std::true_type {};



bool test_0_5() {

  const char* T = "sequence 3a";



  {

    vector<array<char,7>> reads = {{

      {'A','B','C','D','E'}

    }};



    string got = sequence(reads);

    string expected = "ABCDE";



    if (got != expected)

      warnExample(T, "single read", expected, got);

  }



  {

    vector<array<char,7>> read7 = {{

      {'A','B','C','D','E'},

      {'B','C','D','E','F'},

      {'C','D','E','F','G'}

    }};



    string got = sequence(read7);

    string expected = "ABCDEFG";



    if (got != expected)

      return failExample(T, "simple overlap chain", expected, got);

  }



  return true;

}

bool test_0_6() {

  const char* T = "sequence 3a";



  {

    vector<array<char,6>> reads = {{

      {'A','B','C','D','E','F'}

    }};



    string got = sequence(reads);

    string expected = "ABCDEF";



    if (got != expected)

      warnExample(T, "single read", expected, got);

  }



  {

    vector<array<char,7>> read7 = {{

      {'A','B','C','D','E','F'},

      {'B','C','D','E','F','G'},

      {'C','D','E','F','G','H'}

    }};



    string got = sequence(read7);

    string expected = "ABCDEFGH";



    if (got != expected)

      return failExample(T, "simple overlap chain", expected, got);

  }



  return true;

}



bool test_0_7() {

    const char* T = "sequence 3a";



    {

        vector<array<char,7>> reads = {{

            {'A','B','C','D','E','F','G'}

        }};



        string got = sequence(reads);

        string expected = "ABCDEFG";



        if (got != expected)

            warnExample(T, "single read", expected, got);

    }



    {

        vector<array<char,7>> read7 = {{

            {'A','B','C','D','E','F','G'},

            {'B','C','D','E','F','G','H'},

            {'C','D','E','F','G','H','I'}

        }};



        string got = sequence(read7);

        string expected = "ABCDEFGHI";



        if (got != expected)

            return failExample(T, "simple overlap chain", expected, got);

    }



    return true;

}



auto results_maker() {

  if constexpr (has_sequence<5>::value) {

    return std::array<bool,1>{ test_0_5() };

  } else if constexpr (has_sequence<6>::value) {

    return std::array<bool,1>{ test_0_6() };

  } else if constexpr (has_sequence<7>::value) {

    return std::array<bool,1>{ test_0_7() };

  } else {

    static_assert(has_sequence<5>::value || has_sequence<6>::value || has_sequence<7>::value,

                  "No supported sequence() overload found");

  }

}

// template <size_t N, typename = void>

// struct has_sequence : std::false_type {};

//

// template <size_t N>

// struct has_sequence<N, std::void_t<

//     decltype(sequence(std::declval<const std::vector<std::array<char,N>>&>()))

// >> : std::true_type {};

//

// bool test_0_5() {

//     const char* T = "sequence 3a";

//

//     {

//         vector<array<char,5>> reads = {{

//             {'A','B','C','D','E'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDE";

//

//         if (got != expected)

//             warnExample(T, "single read", expected, got);

//     }

//

//     {

//         vector<array<char,5>> reads = {{

//             {'A','B','C','D','E'},

//             {'B','C','D','E','F'},

//             {'C','D','E','F','G'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDEFG";

//

//         if (got != expected)

//             return failExample(T, "simple overlap chain", expected, got);

//     }

//

//     return true;

// }

//

// bool test_0_6() {

//     const char* T = "sequence 3a";

//

//     {

//         vector<array<char,6>> reads = {{

//             {'A','B','C','D','E','F'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDEF";

//

//         if (got != expected)

//             warnExample(T, "single read", expected, got);

//     }

//

//     {

//         vector<array<char,6>> reads = {{

//             {'A','B','C','D','E','F'},

//             {'B','C','D','E','F','G'},

//             {'C','D','E','F','G','H'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDEFGH";

//

//         if (got != expected)

//             return failExample(T, "simple overlap chain", expected, got);

//     }

//

//     return true;

// }

//

// bool test_0_7() {

//     const char* T = "sequence 3a";

//

//     {

//         vector<array<char,7>> reads = {{

//             {'A','B','C','D','E','F','G'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDEFG";

//

//         if (got != expected)

//             warnExample(T, "single read", expected, got);

//     }

//

//     {

//         vector<array<char,7>> reads = {{

//             {'A','B','C','D','E','F','G'},

//             {'B','C','D','E','F','G','H'},

//             {'C','D','E','F','G','H','I'}

//         }};

//

//         string got = sequence(reads);

//         string expected = "ABCDEFGHI";

//

//         if (got != expected)

//             return failExample(T, "simple overlap chain", expected, got);

//     }

//

//     return true;

// }

//

// auto results_maker() {

//     if constexpr (has_sequence<5>::value) {

//         return std::array<bool,1>{ test_0_5() };

//     } else if constexpr (has_sequence<6>::value) {

//         return std::array<bool,1>{ test_0_6() };

//     } else if constexpr (has_sequence<7>::value) {

//         return std::array<bool,1>{ test_0_7() };

//     } else {

//         static_assert(has_sequence<5>::value || has_sequence<6>::value || has_sequence<7>::value,

//                       "No supported sequence() overload found");

//     }

// }



int main() {

    //auto results = results_maker();



    bool results[] = results_maker();

    // bool allPassed = true;

    // for (size_t i = 0; i < std::size(results); i++) {

    //     cout << "Test of problem " << to_string(i) << ": "

    //          << (results[i] ? "passed" : "failed") << endl;

    //     allPassed &= results[i];

    // }



    bool allPassed = true;

    for (size_t i = 0; i < std::size(results); i++) {

        cout << "Test of problem " << to_string(i) << ": "

             << (results[i] ? "passed" : "failed") << endl;

        allPassed &= results[i];

    }

    // if (allPassed) exit(0);

    // else exit(-1);



    if (allPassed) exit(0);

    else exit(-1);

  warnExample("NO TESTS","Tests will be done manually.","","");

}
 
 No newline at end of file

tests/testSequenceB.cpp

+1 −1
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ 


using namespace std;



string sequence(vector<string> reads);

string sequence(const vector<string>& reads);



// helper

bool failExample(const char* testName, const string& msg, string expected, string got) {