Почему разработчики не любят Юнит Тесты

struct NewAlloc
{
    static void* malloc(int size)
    {
        return ::malloc(size);
    }

    static void free(void* item)
    {
        ::free(item);
    }
};

template <typename Alloc = NewAlloc>
class LList
{
    typedef struct node
    {
        int val = 0;
        struct node* next = nullptr;
    } node_t;

    node_t* list_head = nullptr;

public:
    void list_push(int val)
    {
        node_t* current = list_head;
        if (list_head == nullptr) {
            list_head = (node_t*)Alloc::malloc(sizeof(node_t));
            list_head->val = val;
            list_head->next = NULL;
        }
        else {
            while (current->next != NULL) {
                current = current->next;
            }
            current->next = (node_t*)Alloc::malloc(sizeof(node_t));
            current->next->val = val;
            current->next->next = NULL;
        }
    }

    int list_pop(void)
    {
        if (list_head == nullptr) {
            return -1;
        }

        node_t* next_node = list_head->next;
        int retval = list_head->val;
        Alloc::free(list_head);
        list_head = next_node;
        return retval;
    }
};

struct CountingAlloc
{
    static int mallocCounter;
    static int freeCounter;

    static void reset()
    {
        mallocCounter = 0;
        freeCounter = 0;
    }

    static void* malloc(int size)
    {
        mallocCounter ++;
        return ::malloc(size);
    }

    static void free(void* item)
    {
        freeCounter --;
        ::free(item);
    }
};

int CountingAlloc::mallocCounter = 0;
int CountingAlloc::freeCounter = 0;

namespace UnitTest1
{
    TEST_CLASS(UnitTest1)
    {
    public:

        TEST_METHOD(test_push)
        {
            CountingAlloc::reset();
            LList<CountingAlloc> l;
            l.list_push(1);
            Assert::AreEqual(1, CountingAlloc::mallocCounter);
            Assert::AreEqual(0, CountingAlloc::freeCounter);
        }

        TEST_METHOD(test_pop)
        {
            CountingAlloc::reset();
            LList<CountingAlloc> l;
            l.list_push(1);
            l.list_pop();
            Assert::AreEqual(1, CountingAlloc::mallocCounter);
            Assert::AreEqual(1, CountingAlloc::freeCounter);
        }
    };
}