К>void go_around_zero(int n) { for(int i = -n*10; i <= n*10; ++i) { do_smth(); } }
К>// TODO отрефакторить, чтобы покрыть тестами
К>

template <class F>
void go_around_zero_v2(int n, F func) { for(int i = -n*10; i <= n*10; ++i) { func(); } }


TEST(go_around_zero_v2, testNegativeN)
{
    int n = 10;
    unsigned int expected = n*10*2+1;    // Ну или 100500 от балды, чтобы просто отловить бесконечный цикл
    unsigned int actual = 0;
    go_around_zero(-10, [&]() {
        ASSERT_LT(expected, actual++) << "Possible infinite loop";    // Враг не пройдет
        });
    ASSERT_EQ(expected, actual);        // Исходный код до этого момента не дойдет
}

template <class F>
void go_around_zero_v2(int n, F func) { 
    if (math::abs(n) > MAX_UINT/20 -1)
    {
        throw std::runtime_error("Loop will go bananas!");
    }
    for(int i = -n*10; i <= n*10; ++i) { 
        func(); 
    } 
}

void go_around_zero(int n)
{
    go_around_zero_v2(n, do_smth);
}

[] -> [] // если упадет этот тест, то у вас не проверяются, понятно, пустные данные

1 -> 1  // если этот тест - выход за пределы матрицы при итерировании по ней

12 -> 1 // тут - ошибка в коде изменения размера матрицы или забыли итерироваться по столбцам
      2

12 -> 13 // если ошибка тут - то та самая ошибка с индексами или забыли итерироваться по строкам
34    24

void go_around_zero(int n) { for(int i = -n*10; i <= n*10; ++i) { do_smth(); } }
// TODO отрефакторить, чтобы покрыть тестами

int ten_times(int x) { return x*10; }
// TODO покрыть тестами умножение на 10

void go_around_zero(int n) { for(int i = ten_times(-n), e = ten_times(n); i <= e; ++i) { do_smth(); } }
// TODO тесты для go_around_zero

// названия макросов тестов вымышлены, по мотивам GTest.
TEST(TenTimes, ZeroIsZero)         { EXPECT_EQ(  0, ten_times( 0); }
TEST(TenTimes, PositiveIsPositive) { EXPECT_EQ(+10, ten_times(+1); }
TEST(TenTimes, NegativeIsNegative) { EXPECT_EQ(-10, ten_times(-1); }

int ten_times(int x) {
  assert(abs(x) <= std::limits<int>::max() / 10; }
  return x*10;
}
TEST(TenTimes, PositiveOk)       { ASSERT_PASS(ten_times(+INT_MAX/10)); }
TEST(TenTimes, NegativeOk)       { ASSERT_PASS(ten_times(-INT_MAX/10)); }
TEST(TenTimes, PositiveOverflow) { ASSERT_FAIL(ten_times(+INT_MAX/10 + 1)); }
TEST(TenTimes, NegativeOverflow) { ASSERT_FAIL(ten_times(-INT_MAX/10 - 1)); }

void transposeInPlace(Matrix& mtx);

TEST(transposeMatrix, inPlace)
{
    Matrix mtx = 
        {1 2 3
        4 5 6
        7 8 9};    // Псевдокод, вестимо
    Matrix expected = 
        {1 4 7
        2 5 8
        3 6 9}; // Транспонировали вручную, на клочке бумажки
    transposeInPlace(mtx);
    ASSERT_EQ(expected, mtx);  // Глупая ошибка не пройдет

Matrix transpose(const Matrix& original);

TEST(transposeMatrix, testThatShouldNotExist)
{
    Matrix mtx = ...; // Тут инициализация квадратной матрицы
    Matrix expected = ...; // Вручную инициализированная транспонированная матрица
    mtx = transpose(mtx);
    ASSERT_EQ(expected, mtx);

L>TEST(transposeMatrix, testThatShouldNotExist)
L>{
L>    Matrix mtx = ...; // Тут инициализация квадратной матрицы
L>    Matrix expected = ...; // Вручную инициализированная транспонированная матрица
L>    mtx = transpose(mtx);
L>    ASSERT_EQ(expected, mtx);
L>

SVZ>Не всегда просто и нифига не быстро.
Если не просто и не быстро, то вы либо не понимаете свой собственный код, либо алгоритм, либо предметную область. Значит, нужно заполнять пробелы.
SVZ>В моей практике это сложно и геморройно. И еще объемно.
Хороший индиактор того, что тестируемый код пора дробить на части.

-spec(group_pc_repr(list({any(),list()})) -> list({any(),list()})).
group_pc_repr(List) ->
    rec_group_pc_repr([], List).

-spec(rec_group_pc_repr(list(), list({any(),list()})) -> list({any(),list()})).
rec_group_pc_repr(Out, []) ->
    Out;
rec_group_pc_repr(Out, [{Tag, List1}, {Tag, List2} | Rest]) ->
    rec_group_pc_repr(Out, [{Tag, List1 ++ List2} | Rest]);
rec_group_pc_repr(Out, [{Tag, List} | Rest]) ->
    rec_group_pc_repr(Out ++ [{Tag, List}], Rest).

rec_group_pc_repr_test_() ->
    [
        {"rec_group_pc_repr() trivial",
            ?_assertMatch([], ?M:rec_group_pc_repr([], []))},
        {"rec_group_pc_repr() no change",
            ?_assertMatch([1,2], ?M:rec_group_pc_repr([1,2], []))},
        {"rec_group_pc_repr() no merge 1",
            ?_assertMatch(
                [{k1,[a]},{k2,[b]},{k1,[c]}],
                ?M:rec_group_pc_repr([], [{k1,[a]},{k2,[b]},{k1,[c]}]))},
        {"rec_group_pc_repr() merge 1",
            ?_assertMatch(
                [{k1,[a,b,c]}],
                ?M:rec_group_pc_repr([], [{k1,[a]},{k1,[b]},{k1,[c]}]))},
        {"rec_group_pc_repr() merge 2",
            ?_assertMatch(
                [{k1,[a,b]},{k2,[c]}],
                ?M:rec_group_pc_repr([], [{k1,[a]},{k1,[b]},{k2,[c]}]))},
        {"rec_group_pc_repr() merge 3",
            ?_assertMatch(
                [{k1,[a,b]},{k2,[c,d]}],
                ?M:rec_group_pc_repr([],
                    [{k1,[a]},{k1,[b]},{k2,[c]},{k2,[d]}]))},
        {"rec_group_pc_repr() merge 4",
            ?_assertMatch(
                [{k1,[a]},{k2,[b,c]},{k3,[d]}],
                ?M:rec_group_pc_repr([],
                    [{k1,[a]},{k2,[b]},{k2,[c]},{k3,[d]}]))}
    ].

for (int i = -n*10; i <= n*10; ++i) {...}

void go_around_zero(int n) {
  assert(n >= 0); // если кому-то нужно работать с вывернутым интервалом, подумайте о направлении итераций.
  assert(n < 1000); // какому психу понадобилась такая здоровая окрестность, пусть и чинит.
  for (int i = -n*10; i <= +n*10; ++i)
    do_smth(i);
  // P.S. если ты тот самый псих, не забудь последить за целочисленным переполнением здесь, и за корректностью do_smth там.
}