Правильное написание unit тестов и наименование функции тестирования

Задача заключается в том, чтобы протестировать структуру с одним методом toStr, который возвращает тип в виде строки.

Данная структура выглядит так:

struct Individ
{
    enum : qint8
    {
        TypeX01 =  1,
        TypeX02 =  2,
        TypeX03 =  3,
        // ...
        TypeUnk = -127,

    } Type;

    Individ(decltype(Type) type = TypeX01) : Type(type) {}

    QString toStr() const
    {
        switch (Type)
        {
        case Individ::TypeX01 : return "Type X01";
        case Individ::TypeX02 : return "Type X02";
        case Individ::TypeX03 : return "Type X03";
        // ...
        case Individ::TypeUnk : return "Unknown type";
        default               : return QString();
        }
    }
    explicit operator bool() const { return Type != Individ::TypeX00N; }
};

inline bool operator ==(const Individ& lIndivid, const Individ& rIndivid) noexcept {
    return lIndivid.Type == rIndivid.Type;
}

inline bool operator !=(const Individ& lIndivid, const Individ& rIndivid) noexcept {
    return lIndivid.Type != rIndivid.Type;
}

Мы можем заметить, что в дополнение к тестированию самой функции мы также должны проверить операторы проверки равенства (operator==) и неравенства (operator!=). И тут возникает вопрос. Как правильно назвать такой метод, который проверяет такие операторы ? В моем случае, метод проверки оператора равенства, называется equalityOperatorTests, а неравенства inequalityOperatorTests.

Также стоит ли проверять, например, оператор равенства на возврат true и false. В моем случае, я проверяю лишь на true возврат.

Вот код для примера того, как я реализовал тесты. Для тестирования я использую Google Test Framework:

individ_tests.h

#include <gtest/gtest.h>
#include "individ.h"

static const quint8 NUM_OF_INDIVID_TYPES = 4;

static const struct {

    Individ i;
    QString s;

} listOfIndividTypes[NUM_OF_INDIVID_TYPES] {

    { Individ::TypeX01, "Type X01"     },
    { Individ::TypeX02, "Type X02"     },
    { Individ::TypeX03, "Type X03"     },
    { Individ::TypeUnk, "Unknown type" }
};

TEST(IndividTests, toStrTests)
{
    for (qint8 i = 0; i < NUM_OF_INDIVID_TYPES; i++) {
         ASSERT_STREQ(listOfIndividTypes[i].i.toStr().toUtf8(),
                      listOfIndividTypes[i].s.toUtf8());
    }
    // Симулируем подачу несуществующего индивида. 
    const Individ individ = static_cast<decltype(Individ::Type)>(127);
    ASSERT_STREQ(individ.toStr().toUtf8(), QString().toUtf8());
}

TEST(IndividTests, equalityOperatorTests)
{
    for (qint8 i = 0; i < NUM_OF_INDIVID_TYPES; i++) {
         ASSERT_TRUE (listOfIndividTypes[i].i == listOfIndividTypes[i].i);
    }
}

TEST(IndividTests, inequalityOperatorTests)
{
    for (qint8 i = 0; i < NUM_OF_INDIVID_TYPES; i++) {
         ASSERT_FALSE(listOfIndividTypes[i].i != listOfIndividTypes[i].i);
    }
}

main.cpp

#include "individ_tests.h"

int main(int argc, char *argv[])
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

P.S Не судите строго об этой структуре. Она приводится в качестве примера.