Naive implementation of merge sort

gistfile1.sh

$ g++ -Wall -Wextra -std=c++0x -o mergesort mergesort.cpp

mergesort.cpp

//
// Naive implementation of merge sort
//
#include <cassert>
#include <iostream>
#include <vector>

template <typename T>
std::vector<T> merge_vectors(const std::vector<T>& v1, const std::vector<T>& v2)
{
    std::vector<T> result;
    auto it1 = v1.begin(), it2 = v2.begin();
    while (it1 != v1.end() && it2 != v2.end()) {
        if (*it1 < *it2) {
            result.push_back(*it1);
            ++it1;
        } else {
            result.push_back(*it2);
            ++it2;
        }
    }
    result.insert(result.end(), it1, v1.end());
    result.insert(result.end(), it2, v2.end());
    return result;
}

template <typename T>
std::vector<T> merge_sort(const std::vector<T>& v)
{
    if (v.size() <= 1)
        return v;
    size_t half = v.size() / 2;
    auto v1 = merge_sort(std::vector<T>(v.begin(), v.begin() + half));
    auto v2 = merge_sort(std::vector<T>(v.begin() + half, v.end()));
    return merge_vectors(v1, v2);
}

template <typename T>
std::ostream& operator<<(std::ostream& stream, const std::vector<T>& v)
{
    for (auto it = v.begin(); it != v.end(); ++it) {
        if (it != v.begin())
            stream << ", ";
        stream << *it;
    }
    return stream;
}

bool test_merge_sort(const std::vector<int>& input, const std::vector<int>& expected)
{
    auto output = merge_sort(input);
    if (output == expected) {
        return false;
    } else {
        std::cout << "Error" << std::endl;
        std::cout << "   Input: " << input << std::endl;
        std::cout << "  Output: " << output << std::endl;
        std::cout << "Expected: " << expected << std::endl;
        std::cout << std::endl;
        return true;
    }
}

int main()
{
    int num_errors = 0;
    num_errors += test_merge_sort({}, {});
    num_errors += test_merge_sort({ 1 }, { 1 });
    num_errors += test_merge_sort({ 1, 2, 3, 4 }, { 1, 2, 3, 4 });
    num_errors += test_merge_sort({ 4, 1, 3, 2 }, { 1, 2, 3, 4 });
    num_errors += test_merge_sort({ 10, 5, 1, -1, 0 }, { -1, 0, 1, 5, 10 });
    num_errors += test_merge_sort({ 3, 1, 3, 1, 3, 1 }, { 1, 1, 1, 3, 3, 3 });
    num_errors += test_merge_sort({ 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1 });
    std::cout << num_errors << " error(s) detected." << std::endl;
    return 0;
}