Boost Test Case Donner des résultats mitigés

Question

Je pratique actuellement le style de programmation de développement piloté par les tests, tout en essayant de mémoriser des idiomes utiles et des règles de sécurité exceptionnelles que j'ai apprises. J'ai utilisé une ancienne mission de programmation du premier semestre pour tout simplement devenir dingue, utiliser des trucs là où ça ne devrait pas être utilisé pour avoir une idée d'eux, apprendre leurs avantages et leurs inconvénients respectifs. Vous savez, pratiquer.

J'ai codé avec le framework Boost_Unit_Test, et ça s'est bien passé jusqu'à présent (seulement le framework de test que j'ai essayé). Sauf ici, dans ce test:

BOOST_AUTO_TEST_CASE(CopyConstructor) 
{ 
    Field *field = Field::EmptyField(); 
    PushValsToField(&field, 5); 
    Field *field2 = new Field(*field); 

    BOOST_REQUIRE_EQUAL(field->Size(), field2->Size()); 
    BOOST_REQUIRE_EQUAL((*field)[0], (*field2)[0]); 
    BOOST_REQUIRE_EQUAL((*field)[1], (*field2)[1]); 
    BOOST_REQUIRE_EQUAL((*field)[2], (*field2)[2]); 
    BOOST_REQUIRE_EQUAL((*field)[3], (*field2)[3]); 
    BOOST_REQUIRE_EQUAL((*field)[4], (*field2)[4]); 
    // Error with BOOST_EQUAL_REQUIRE_COLLECTIONS 
    BOOST_REQUIRE_EQUAL_COLLECTIONS(&(*field)[0], &(*field)[5], 
            &(*field2)[0], &(*field)[5]); 
    delete field; 
    delete field2; 
} 

Je ne sais pas pourquoi, mais le test de recouvrement échoue sur la dernière comparaison ([5]). Cependant, les autres tests passent. Pourquoi le dernier test échoue?

En outre, tous les guides de style ou des pointeurs seraient grandement appréciés, mais pas dans le cadre de la question.

Erreur:

fatal error in "CopyConstructor": 

critical check { &(*field)[0], &(*field)[5] } == { &(*field2)[0], &(*field)[5] } failed. 

Collections size mismatch: 5 != 1073731817 

Informations pratiques et Code Snippets

void PushValsToField(Field **field, int numPushes) 
{ 
    for (int i(1); i <= numPushes; ++i) 
     (*field)->Push_Back(i*10); 
} 

Constructors

Field *Field::EmptyField() 
{ 
    return new Field(); 
} 

Field::Field() 
    : v_(new ElemType[10000]), vused_(0), vsize_(10000) 
{} 

Field::Field(const Field& other) 
    : v_(h::NewCopy(other.v_, 
        other.vsize_, 
        other.vsize_)), 
     vused_(other.vused_), 
     vsize_(other.vsize_) 
{}  

// Also available as a const& version 
int& Field::operator[](int index) throw(const char *) 
{ 
    if (index < 0 || index > vused_) 
     throw "Index out of bounds."; 
    else 
     return v_[index]; 
} 

Fonction copie

template <class T> 
T *NewCopy(const T* src, 
      size_t srcSize, 
      size_t destSize) 
{ 
    assert(destSize >= srcSize); 

    T *dest = new T[destSize]; 
    try 
    { 
     std::copy(src, (src + srcSize), dest); 
    } 
    catch(...) 
    { 
     delete[] dest; 
     throw; 
    } 

    return dest; 
} 

Answer 1

Si votre taille est 5, ne sont pas vos indices valides 0-4? 5 serait hors de portée. Je pense que vous avez une erreur dans vos limites operator[] vérifier:

if (index < 0 || index > vused_) 

... doit être ...

if (index < 0 || index >= vused_) 

Answer 2

BOOST_REQUIRE_EQUAL((*field)[0], (*field2)[0]); // one 
BOOST_REQUIRE_EQUAL((*field)[1], (*field2)[1]); // two 
BOOST_REQUIRE_EQUAL((*field)[2], (*field2)[2]); // three 
BOOST_REQUIRE_EQUAL((*field)[3], (*field2)[3]); // four 
BOOST_REQUIRE_EQUAL((*field)[4], (*field2)[4]); // five 
BOOST_REQUIRE_EQUAL((*field)[5], (*field2)[5]); // wait, six? 

Compte le nombre d'éléments que vous vérifiez, zéro à cinq. .. Il vous donne six. Mais votre collection est censée avoir cinq éléments.