मल्टी-पैरामीटर फॉर्मूला

Question

का परीक्षण कैसे करें मैं कुछ कोड को दोबारा कर रहा हूं जो फॉर्मूला लागू करता है और मैं इसे अपने परीक्षण कौशल में सुधार करने के लिए पहले परीक्षण करना चाहता हूं, और कोड को कवर कर सकता हूं।

कोड का यह विशेष भाग एक सूत्र है जो 3 मानकों को लेता है और एक मूल्य देता है। मेरे पास अलग-अलग इनपुट के लिए अपेक्षित परिणामों के साथ कुछ डेटा टेबल भी हैं, इसलिए सिद्धांत रूप में, मैं एक ज़िलियन परीक्षण टाइप कर सकता हूं, केवल इनपुट पैरामीटर बदल रहा हूं और संबंधित अपेक्षित मान के विरुद्ध परिणामों की जांच कर सकता हूं।

लेकिन मैंने सोचा कि ऐसा करने का एक बेहतर तरीका होना चाहिए, और उन दस्तावेज़ों को देखकर मुझे मूल्य पैरामीटरेटेड टेस्ट मिल गए हैं।

तो, इसके साथ अब मैं जानता हूं कि अलग-अलग इनपुट के लिए स्वचालित रूप से परीक्षण कैसे बनाएं।
लेकिन मैं अपने अपेक्षित एक के साथ तुलना करने के लिए इसी अपेक्षित परिणाम कैसे प्राप्त करूं?

एकमात्र चीज जिसके साथ मैं आने में सक्षम हूं, एक स्थिर लुकअप टेबल और टेक्स्ट फिक्स्चर में एक स्थिर सदस्य है जो लुकअप टेबल के लिए एक सूचकांक है और प्रत्येक रन में वृद्धि हुई है। कुछ इस तरह:

#include "gtest/gtest.h" 

double MyFormula(double A, double B, double C) 
{ 
    return A*B - C*C; // Example. The real one is much more complex 
} 

class MyTest:public ::testing::TestWithParam<std::tr1::tuple<double, double, double>> 
{ 
protected: 

    MyTest(){ Index++; } 
    virtual void SetUp() 
    { 
     m_C = std::tr1::get<0>(GetParam()); 
     m_A = std::tr1::get<1>(GetParam()); 
     m_B = std::tr1::get<2>(GetParam()); 
    } 

    double m_A; 
    double m_B; 
    double m_C; 

    static double ExpectedRes[]; 
    static int Index; 

}; 

int MyTest::Index = -1; 

double MyTest::ExpectedRes[] = 
{ 
//    C = 1 
//  B: 1  2  3  4  5  6  7  8  9 10 
/*A = 1*/ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 
/*A = 2*/ 1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 
/*A = 3*/ 2.0, 5.0, 8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 29.0, 

//    C = 2 
//  B:  1  2  3  4  5  6  7  8  9 10 
/*A = 1*/ -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 
/*A = 2*/ -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 
/*A = 3*/ -1.0, 2.0, 5.0, 8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 
}; 

TEST_P(MyTest, TestFormula) 
{ 
    double res = MyFormula(m_A, m_B, m_C); 
    ASSERT_EQ(ExpectedRes[Index], res); 
} 

INSTANTIATE_TEST_CASE_P(TestWithParameters, 
         MyTest, 
         testing::Combine(testing::Range(1.0, 3.0), // C 
              testing::Range(1.0, 4.0), // A 
              testing::Range(1.0, 11.0) // B 
             )); 

यह एक अच्छा दृष्टिकोण है या उम्मीद प्रत्येक रन के लिए परिणाम सही पाने के लिए किसी भी बेहतर तरीका है?

Answer 1

मुझे यूनिट परीक्षण के साथ बहुत अधिक अनुभव नहीं है, लेकिन गणितज्ञ के रूप में, मुझे लगता है कि आप बहुत कुछ नहीं कर सकते हैं।

यदि आप अपने सूत्र के कुछ आविष्कारों को जान लेंगे, तो आप उनके लिए परीक्षण कर सकते हैं, लेकिन मुझे लगता है कि यह केवल कुछ ही परिदृश्यों में ही समझ में आता है।

उदाहरण के लिए, यदि आप, परीक्षण करने के लिए अगर आप सही तरीके प्राकृतिक घातीय समारोह को लागू किया है चाहेगा, तो आप ज्ञान का उपयोग कर सकता है कि यह व्युत्पन्न है समारोह को उसी मान होना चाहिए। फिर आप लाखों अंकों के लिए व्युत्पन्न के लिए संख्यात्मक अनुमान की गणना कर सकते हैं और देख सकते हैं कि वे वास्तविक कार्य मूल्य के करीब हैं या नहीं।

Answer 2

अपेक्षित परिणाम हार्ड कोडिंग देखें जैसे कि आप परीक्षण मामलों की संख्या को फिर से सीमित कर रहे हैं। यदि आप एक पूर्ण डेटा संचालित मॉडल प्राप्त करना चाहते हैं, तो मैं आपको एक फ्लैट फ़ाइल/xml/xls फ़ाइल से अपेक्षित परिणाम इनपुट पढ़ने के लिए सुझाव दूंगा।

Answer 3

इनपुट के साथ अपेक्षित परिणाम शामिल करें। इनपुट मानों की एक तिहाई के बजाय, अपना परीक्षण पैरामीटर 4-टुपल बनाएं।

class MyTest: public ::testing::TestWithParam< 
    std::tr1::tuple<double, double, double, double>> 
{ }; 

TEST_P(MyTest, TestFormula) 
{ 
    double const C = std::tr1::get<0>(GetParam()); 
    double const A = std::tr1::get<1>(GetParam()); 
    double const B = std::tr1::get<2>(GetParam()); 
    double const result = std::tr1::get<3>(GetParam()); 

    ASSERT_EQ(result, MyFormula(A, B, C)); 
} 

नकारात्मक पक्ष यह है कि आप testing::Combine साथ संक्षिप्त अपने परीक्षण मानकों रखने में सक्षम नहीं होगा। इसके बजाय, आप प्रत्येक विशिष्ट 4-टुपल को परिभाषित करने के लिए testing::Values का उपयोग कर सकते हैं, जिसे आप परीक्षण करना चाहते हैं। आप Values के लिए तर्क-गणना सीमा को हिट कर सकते हैं, ताकि आप अपने तत्काल विभाजन को विभाजित कर सकें, जैसे सभी सी = 1 मामलों में एक और सभी सी = 2 अन्य मामलों में।

INSTANTIATE_TEST_CASE_P(
    TestWithParametersC1, MyTest, testing::Values(
    //   C  A  B 
    make_tuple(1.0, 1.0, 1.0, 0.0), 
    make_tuple(1.0, 1.0, 2.0, 1.0), 
    make_tuple(1.0, 1.0, 3.0, 2.0), 
    // ... 
)); 

INSTANTIATE_TEST_CASE_P(
    TestWithParametersC2, MyTest, testing::Values(
    //   C  A  B 
    make_tuple(2.0, 1.0, 1.0, -3.0), 
    make_tuple(2.0, 1.0, 2.0, -2.0), 
    make_tuple(2.0, 1.0, 3.0, -1.0), 
    // ... 
)); 

या आप एक सरणी में सभी मान रख सकते हैं अपने इन्स्टेन्शियशन से अलग और फिर testing::ValuesIn का उपयोग करें:

std::tr1::tuple<double, double, double, double> const FormulaTable[] = { 
    //   C  A  B 
    make_tuple(1.0, 1.0, 1.0, 0.0), 
    make_tuple(1.0, 1.0, 2.0, 1.0), 
    make_tuple(1.0, 1.0, 3.0, 2.0), 
    // ... 
    make_tuple(2.0, 1.0, 1.0, -3.0), 
    make_tuple(2.0, 1.0, 2.0, -2.0), 
    make_tuple(2.0, 1.0, 3.0, -1.0), 
    // ... 
}; 

INSTANTIATE_TEST_CASE_P(
    TestWithParameters, MyTest, ::testing::ValuesIn(FormulaTable));