मैं कोड-जनरेटर का परीक्षण कैसे करूं?

यदि आप * नक्स पर चल रहे हैं तो आप बैश स्क्रिप्ट या मेकफ़ाइल के पक्ष में अनजान ढांचे को डंप करने पर विचार कर सकते हैं। विंडोज़ पर आप एक शेल ऐप/फ़ंक्शन बनाने पर विचार कर सकते हैं जो जेनरेटर चलाता है और फिर कोड (अन्य प्रक्रिया के रूप में) का उपयोग करता है और उसे बेकार करता है।

एक तीसरा विकल्प कोड उत्पन्न करना होगा और फिर उसमें से एक ऐप बनाना होगा जिसमें एकजुट नहीं है लेकिन कुछ भी शामिल नहीं है। फिर आपको एक शेल स्क्रिप्ट की आवश्यकता होगी या प्रत्येक इनपुट के लिए इसे चलाने के लिए क्या नहीं होगा। अपेक्षित व्यवहार को एन्कोड करने के तरीके के रूप में, यह मेरे लिए होता है कि यह सी ++ कोड के बजाय जेनरेट किए गए इंटरफ़ेस का उपयोग करके सी ++ कोड के लिए उतना ही किया जा सकता है।

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

समस्या यह है कि परीक्षण करना मुश्किल है, जेनरेट कोड वास्तव में इकाई परीक्षण प्रणाली के वातावरण में चलाने के लिए उपयुक्त नहीं हो सकता है, और आप अपेक्षित परिणामों को कैसे एन्कोड करते हैं?

मैंने पाया है कि आपको कोड जेनरेटर को छोटे टुकड़ों में विभाजित करने और यूनिट परीक्षण करने की आवश्यकता है। यदि आप मुझसे पूछते हैं तो यूनिट परीक्षण एक पूर्ण कोड जेनरेटर परीक्षण इकाई की तुलना में एकीकरण परीक्षण की तरह है।

Recall that "unit testing" is only one kind of testing. You should be able to unit test the internal pieces of your code generator. What you're really looking at here is system level testing (a.k.a. regression testing). It's not just semantics... there are different mindsets, approaches, expectations, etc. It's certainly more work, but you probably need to bite the bullet and set up an end-to-end regression test suite: fixed C++ files -> SWIG interfaces -> python modules -> known output. You really want to check the known input (fixed C++ code) against expected output (what comes out of the final Python program). Checking the code generator results directly would be like diffing object files...

हां, परिणाम केवल एक चीज है जो मायने रखती है। असली कोर एक ढांचा लिख ​​रहा है जो आपके जेनरेट कोड को स्वतंत्र रूप से चलाने की अनुमति देता है ... अपना समय वहां व्यतीत करें।

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

असल में, आप वास्तव में क्या जानना चाहते हैं कि क्या आपका जनरेटर प्रत्येक संभावित संयोजन (भी असंभव) के शारीरिक परीक्षण के बिना आप जो अपेक्षा करते हैं वह उत्पन्न करेगा। यह सुनिश्चित करके कि आपका जनरेटर आपके द्वारा अपेक्षित तरीकों से सुसंगत है, आप बेहतर महसूस कर सकते हैं कि जेनरेटर कभी-कभी जटिल परिस्थितियों में सफल होगा।

इस तरह, आप रिग्रेशन टेस्ट का एक सूट भी बना सकते हैं (इकाई परीक्षण जिन्हें सही तरीके से काम करने की आवश्यकता है)। यह आपको यह सुनिश्चित करने में मदद करेगा कि आपके जनरेटर में परिवर्तन कोड के अन्य रूपों को तोड़ नहीं रहे हैं। जब आपको एक बग का सामना करना पड़ता है जिसमें आपके यूनिट परीक्षण नहीं पकड़े जाते हैं, तो आप इसे समान ब्रेकेज को रोकने के लिए शामिल करना चाह सकते हैं।

बस यह इंगित करना चाहता था कि परिणाम अभी सत्यापित करते समय भी आप ठीक-ठीक परीक्षण प्राप्त कर सकते हैं: आप कुछ सेटअप और सत्यापन कोड के अंदर उन्हें घोंसले करके कोड के अलग-अलग हिस्सों का परीक्षण कर सकते हैं:

int x = 0;
GENERATED_CODE
assert(x == 100);

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

यूनिट परीक्षण सिर्फ एक विशिष्ट इकाई का परीक्षण है। इसलिए यदि आप कक्षा ए के लिए एक विनिर्देश लिख रहे हैं, तो यह आदर्श है यदि कक्षा ए में कक्षा बी और सी के असली ठोस संस्करण नहीं हैं।

ठीक है मैंने बाद में देखा कि इस प्रश्न के टैग में सी ++/पायथन शामिल है, लेकिन सिद्धांत समान हैं:

    public class A : InterfaceA 
    {   
      InterfaceB b;

      InterfaceC c;

      public A(InterfaceB b, InterfaceC c)   {
          this._b = b;
          this._c = c;   }

      public string SomeOperation(string input)   
      {
          return this._b.SomeOtherOperation(input) 
               + this._c.EvenAnotherOperation(input); 
      } 
    }

चूंकि उपर्युक्त सिस्टम ए सिस्टम बी और सी में इंटरफेस इंजेक्ट करता है, इसलिए आप किसी भी अन्य सिस्टम द्वारा वास्तविक कार्यक्षमता निष्पादित किए बिना सिस्टम ए का परीक्षण कर सकते हैं। यह इकाई परीक्षण है।

सृजन से पूरा होने के लिए एक सिस्टम के पास आने के लिए एक चालाक तरीका है, एक अलग के साथ जब व्यवहार के प्रत्येक टुकड़े के लिए विनिर्देशन:

public class When_system_A_has_some_operation_called_with_valid_input : SystemASpecification
{
    private string _actualString;

    private string _expectedString;

    private string _input;

    private string _returnB;

    private string _returnC;

    [It]
    public void Should_return_the_expected_string()
    {
        _actualString.Should().Be.EqualTo(this._expectedString);
    }

    public override void GivenThat()
    {
        var randomGenerator = new RandomGenerator();
        this._input = randomGenerator.Generate();
        this._returnB = randomGenerator.Generate();
        this._returnC = randomGenerator.Generate();

        Dep().Stub(b => b.SomeOtherOperation(_input))
                         .Return(this._returnB);
        Dep().Stub(c => c.EvenAnotherOperation(_input))
                         .Return(this._returnC);

        this._expectedString = this._returnB + this._returnC;
    }

    public override void WhenIRun()
    {
        this._actualString = Sut.SomeOperation(this._input);
    }
}

तो निष्कर्ष में, एक इकाई/विनिर्देश के कई व्यवहार हो सकते हैं, और विनिर्देश बढ़ता है जब आप इकाई/प्रणाली विकसित करते हैं; और यदि परीक्षण के तहत आपका सिस्टम इसके भीतर अन्य ठोस प्रणालियों पर निर्भर करता है, तो देखें।

मुझे लगता है कि आपको यह जांचने की ज़रूरत है कि आप इसे उत्पन्न करने के तरीके से अधिक उत्पन्न कर रहे हैं।

मेरे मामले में, कार्यक्रम कई प्रकार के कोड (सी #, एचटीएमएल, एससीएसएस, जेएस, इत्यादि) उत्पन्न करता है जो वेब अनुप्रयोग में संकलित होते हैं। जेनरेटर का परीक्षण करके नहीं, कुल मिलाकर रीग्रेशन बग को कम करने के लिए मैंने पाया है कि वेब एप्लिकेशन का परीक्षण करना सबसे अच्छा तरीका है।

मुझे गलत मत समझो, अभी भी कुछ जनरेटर कोड की जांच करने वाले यूनिट परीक्षण हैं, लेकिन हमारे हिरण के लिए हमारी सबसे बड़ी धमाके जेनरेट किए गए ऐप पर ही यूआई परीक्षण हैं।

Since we're generating it we also generate a nice abstraction in JS we can use to programatically test the app. We followed some ideas outlined here: http://code.tutsplus.com/articles/maintainable-automated-ui-tests--net-35089

सबसे बड़ा हिस्सा यह है कि यह वास्तव में आपके सिस्टम को अंत तक अंत तक जांचता है, कोड पीढ़ी से जो वास्तव में आप उत्पन्न कर रहे हैं। एक बार परीक्षण विफल हो जाने पर, जनरेटर को तोड़ने के लिए इसे वापस ट्रैक करना आसान होता है।

यह बहुत प्यारा है।

सौभाग्य!