दिलचस्प पोस्ट
HTML ईमेल में छवि को एम्बेड करना जेएसपी पृष्ठ में हाइपरलिंक या बटन पर क्लिक करके मैं जावा विधि को वर्तमान आइटम कैसे पारित कर सकता हूं? पायथन में पोस्ट और जीईटी व्हेरिएबल कैसे प्रबंधित किए जाते हैं? प्रतिबिंब का उपयोग करके ऑब्जेक्ट प्रॉपर्टी सेट करें आइटम देखने के लिए क्यूटी में समृद्ध (html) टेक्स्ट कैसे प्रस्तुत करें कॉल विधि जब होम बटन एंड्रॉइड पर दबाया जाता है प्रमुख जावा एचटीएमएल पार्सरों के पेशेवरों और विपक्ष क्या हैं? SQL सर्वर एक्सप्रेस की सीमाएं एचटीएमएल स्ट्रिंग्स को पढ़ना / आउटपुट करना एक .NET डेटटाइम के मिलिसेकंड को कैसे छोटा करना Codeigniter के पथ में "index.php" को कैसे निकालें अंतिम ब्लॉक को उचित रूप से गद्देदार नहीं देखा गया प्रिंट <div id = "printarea"> </ div> केवल? नक्शा कार्यों की संख्या निर्धारित करना और कार्यों को कम करना event.returnValue नापसंद है इसके बजाय मानक event.preventDefault () का उपयोग करें

JUnit4 में विशिष्ट क्रम में परीक्षा के तरीकों को कैसे चलाने के लिए?

मैं टेस्ट विधियों को निष्पादित करना चाहता हूं जो विशिष्ट @Test में @Test द्वारा एनोटेट किया गया है

उदाहरण के लिए:

 public class MyTest { @Test public void test1(){} @Test public void test2(){} } 

मैं हर बार जब @Test(order=xx) चलाता हूं तो test2() test1() से पहले test1() को चलाने के लिए सुनिश्चित करना चाहता हूं, लेकिन मुझे @Test(order=xx) जैसे एनोटेशन नहीं मिल सके।

मुझे लगता है कि ज्युनित के लिए यह काफी महत्वपूर्ण विशेषता है, अगर ज्युनिट का लेखक ऑर्डर की सुविधा नहीं चाहता है, तो क्यों?

वेब के समाधान से एकत्रित समाधान "JUnit4 में विशिष्ट क्रम में परीक्षा के तरीकों को कैसे चलाने के लिए?"

मुझे लगता है कि ज्युनित के लिए यह काफी महत्वपूर्ण विशेषता है, अगर ज्युनिट का लेखक ऑर्डर की सुविधा नहीं चाहता है, तो क्यों?

मुझे यकीन नहीं है कि जेयूनेट के साथ ऐसा करने का एक साफ तरीका है, मेरे ज्ञान के लिए, जेयूनेट मानता है कि सभी परीक्षण एक मनमाने ढंग से किए जा सकते हैं। अकसर किये गए सवाल से:

मैं एक परीक्षण स्थिरता का उपयोग कैसे करूं?

(…) टेस्ट-विधि इनवॉशन्स के आदेश की गारंटी नहीं है , इसलिए testOneItemCollection () को testEmptyCollection () से पहले निष्पादित किया जा सकता है। (…)

ऐसा क्यों है? खैर, मेरा मानना ​​है कि परीक्षण करने के आदेश को निर्भर करना एक ऐसा अभ्यास है जो लेखकों को बढ़ावा देना नहीं चाहता है। टेस्ट स्वतंत्र होने चाहिए, उन्हें युग्मित और उल्लंघन नहीं करना चाहिए, इससे चीजों को बनाए रखने में कठोर हो जाएगी, अलग-अलग परीक्षणों को चलाने की क्षमता को तोड़ दिया जाएगा (जाहिर है), आदि।

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

@FixMethodOrder 4.11 @FixMethodOrder एनोटेशन के साथ आता है। कस्टम समाधान का उपयोग करने के बजाय सिर्फ अपने FixMethodOrder(MethodSorters.NAME_ASCENDING) संस्करण को अपग्रेड करें और FixMethodOrder(MethodSorters.NAME_ASCENDING) साथ टेस्ट क्लास की व्याख्या करें FixMethodOrder(MethodSorters.NAME_ASCENDING) । विवरण के लिए रिलीज नोट्स की जांच करें

यहां एक नमूना है:

 import org.junit.runners.MethodSorters; import org.junit.FixMethodOrder; import org.junit.Test; @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class SampleTest { @Test public void firstTest() { System.out.println("first"); } @Test public void secondTest() { System.out.println("second"); } } 

यदि आप अपने मौजूदा उदाहरण से छुटकारा मिलते हैं, और निर्माण मार्ग में जेयूनिट 4.11 या उससे अधिक डाउनलोड करते हैं, तो निम्न कोड उनके नामों के क्रम में परीक्षण विधियों को आरोपित क्रम में क्रमबद्ध करेगा:

 @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class SampleTest { @Test public void testAcreate() { System.out.println("first"); } @Test public void testBupdate() { System.out.println("second"); } @Test public void testCdelete() { System.out.println("third"); } } 

यदि आदेश महत्वपूर्ण है, तो आपको अपने आप को ऑर्डर करना चाहिए।

 @Test public void test1() { ... } @Test public void test2() { test1(); ... } 

विशेष रूप से, यदि आवश्यक हो, तो आपको परीक्षण के लिए कुछ या सभी संभव क्रम क्रमांतरों को सूचीबद्ध करना चाहिए।

उदाहरण के लिए,

 void test1(); void test2(); void test3(); @Test public void testOrder1() { test1(); test3(); } @Test(expected = Exception.class) public void testOrder2() { test2(); test3(); test1(); } @Test(expected = NullPointerException.class) public void testOrder3() { test3(); test1(); test2(); } 

या, सभी क्रमपरिवर्तनों का एक पूर्ण परीक्षण:

 @Test public void testAllOrders() { for (Object[] sample: permute(1, 2, 3)) { for (Object index: sample) { switch (((Integer) index).intValue()) { case 1: test1(); break; case 2: test2(); break; case 3: test3(); break; } } } } 

यहां, permute() एक सरल कार्य है जो सरणी संग्रह में सभी संभव रूपांतरणों को दोहराता है।

TestNG के लिए माइग्रेशन का सबसे अच्छा तरीका लगता है, लेकिन मैं यहां ज्यूनेट के लिए कोई स्पष्ट समाधान नहीं देखता हूं। यहां सबसे पठनीय समाधान / स्वरूपण है जो मैं jUnit के लिए पाया है:

 @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class SampleTest { @Test void stage1_prepareAndTest(){}; @Test void stage2_checkSomething(){}; @Test void stage2_checkSomethingElse(){}; @Test void stage3_thisDependsOnStage2(){}; @Test void callTimeDoesntMatter(){} } 

यह सुनिश्चित करता है कि स्टेज 2 के तरीकों को चरण 1 वाले के बाद और चरण 3 के बाद कहा जाता है।

(अभी तक अनलिखित नहीं) परिवर्तन https://github.com/junit-team/junit/pull/386 एक @SortMethodsWith परिचय https://github.com/junit-team/junit/pull/293 कम से कम उस आदेश के बिना अनुमान लगाया गया है (जावा 7 में यह काफी यादृच्छिक हो सकता है)

एक JUnit रिपोर्ट को देखो JUnit पहले से ही पैकेज द्वारा आयोजित किया गया है। प्रत्येक पैकेज में TestSuite वर्ग (या हो सकते हैं) हैं, जिनमें से प्रत्येक में एक से अधिक टेस्ट कैसेस चलाए जाते हैं। प्रत्येक TestCase के पास public void test*() कई परीक्षण विधियां हो सकती हैं, जिनमें से प्रत्येक वास्तव में टेस्टसीज़ क्लास का एक उदाहरण बन जाएंगे जिनके लिए वे संबंधित हैं। प्रत्येक परीक्षण विधि (TestCase उदाहरण) का नाम और पास / विफल मानदंड है।

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

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

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

उदाहरण के लिए:

 Class testStateChanges extends TestCase public void testCreateObjectPlacesTheObjectInStateA() public void testTransitionToStateBAndValidateStateB() public void testTransitionToStateCAndValidateStateC() public void testTryToDeleteObjectinStateCAndValidateObjectStillExists() public void testTransitionToStateAAndValidateStateA() public void testDeleteObjectInStateAAndObjectDoesNotExist() public void cleanupIfAnythingWentWrong() 

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

क्या कोई यह समझा सकता है कि किस तरह से परीक्षण विधि के आदेश के साथ एक जेयूनेट, प्रत्येक अनुक्रमिक परीक्षण चरण के अलग-अलग पास / असफल मानदंडों का समर्थन करेगा, जैसा कि ऊपर दिए गए उदाहरण और मेरे प्रबंधन द्वारा आवश्यक है?

प्रलेखन के बावजूद, मैं इसे ज्यूनेट फ्रेमवर्क में एक गंभीर प्रतिगमन के रूप में देख रहा हूं जो कई परीक्षण डेवलपर्स के लिए जीवन कठिन बना रहा है

जब मैंने जूनी में काम किया और मैं निम्नलिखित समाधान के साथ आया, जो मेरे लिए ठीक काम करता है, तो इसका मुख्य मुद्दा यह है:

 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import org.junit.runners.BlockJUnit4ClassRunner; import org.junit.runners.model.FrameworkMethod; import org.junit.runners.model.InitializationError; public class OrderedRunner extends BlockJUnit4ClassRunner { public OrderedRunner(Class<?> clazz) throws InitializationError { super(clazz); } @Override protected List<FrameworkMethod> computeTestMethods() { List<FrameworkMethod> list = super.computeTestMethods(); List<FrameworkMethod> copy = new ArrayList<FrameworkMethod>(list); Collections.sort(copy, new Comparator<FrameworkMethod>() { @Override public int compare(FrameworkMethod f1, FrameworkMethod f2) { Order o1 = f1.getAnnotation(Order.class); Order o2 = f2.getAnnotation(Order.class); if (o1 == null || o2 == null) { return -1; } return o1.order() - o2.order(); } }); return copy; } } 

भी नीचे की तरह एक इंटरफ़ेस बनाएँ:

  @Retention(RetentionPolicy.RUNTIME) @Target({ ElementType.METHOD}) public @interface Order { public int order(); } 

अब मान लें कि आपके पास क्लास ए है, जहां आपने निम्न तरह के कई परीक्षण मामले लिखे हैं:

 (@runWith=OrderRunner.class) Class A{ @Test @Order(order = 1) void method(){ //do something } } 

इसलिए निष्पादन "विधि ()" नामक विधि से शुरू होगा धन्यवाद!

आप क्या चाहते हैं पूरी तरह से उचित है जब परीक्षण के मामलों को एक सूट के रूप में चलाया जा रहा है

दुर्भाग्य से अभी कोई पूर्ण समाधान देने के लिए कोई समय नहीं है, लेकिन कक्षा पर एक नज़र डालें:

 org.junit.runners.Suite 

जो आपको एक विशेष क्रम में परीक्षण के मामलों (किसी भी परीक्षण वर्ग से) को कॉल करने की अनुमति देता है

इसका उपयोग कार्यात्मक, एकीकरण या सिस्टम परीक्षणों के लिए किया जा सकता है।

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

हम यूनिट, एकीकरण और सिस्टम टेस्ट के लिए एक ही कोड का पुन: उपयोग करते हैं / वारदात करते हैं, कभी-कभी डेटा चालित होते हैं, कभी-कभी संचालित होते हैं, और कभी-कभी एक सुइट के रूप में चलाते हैं

निश्चित नहीं है कि मैं सहमत हूं, अगर मैं 'फाइल अपलोड' का परीक्षण करना चाहता हूं और फिर 'फाइल अपलोड द्वारा डाला गया डेटा' का परीक्षण करना चाहते हैं तो मैं यह क्यों नहीं चाहूँगा कि वे एक-दूसरे से स्वतंत्र रहें? बिल्कुल उचित मुझे लगता है कि उन्हें गोलियास्ट टेस्ट के मामले में अलग होने के बजाय उन्हें अलग से चलाने में सक्षम होना चाहिए।

मेरा समाधान यहां देखें: "जूनिट और जावा 7."

इस आलेख में मैं वर्णन करता हूं कि कैसे जूनिट परीक्षण चलाने के लिए – "बस आपके स्रोत कोड में" टेस्ट चलाए जाएंगे, क्योंकि आपके परीक्षण विधियां क्लास फ़ाइल में दिखाई देती हैं।

http://intellijava.blogspot.com/2012/05/junit-and-java-7.html

लेकिन पास्कल थिवेंट ने कहा, यह एक अच्छा अभ्यास नहीं है।

मैंने कुछ जवाब पढ़ लिए हैं और यह सबसे अच्छा अभ्यास नहीं मानता है, लेकिन अपने परीक्षणों का ऑर्डर करने का सबसे आसान तरीका है – और जिस तरह से जेयूनेट डिफ़ॉल्ट रूप से परीक्षण चलाता है, वर्णानुक्रम नाम आरोही होने से

तो बस अपने परीक्षणों को अल्फाबाटिक क्रम में नाम दें जो आप चाहते हैं। यह भी ध्यान रखें कि परीक्षण का नाम शब्द परीक्षण से शुरू होना चाहिए। बस नंबरों के लिए देखें

test12 test2 से पहले चलेंगे

इसलिए:

testA_MyFirstTest testC_ThirdTest testB_ATestThatRunsSecond

कृपया इसे एक देखें: https://github.com/TransparentMarket/junit यह परीक्षा उन क्रम में चलाती है, जो वे निर्दिष्ट हैं (संकलित क्लास फ़ाइल के भीतर परिभाषित)। साथ ही इसमें उप-पैकेज द्वारा परिभाषित परीक्षणों को चलाने के लिए ऑलस्टिस्ट सूट की सुविधा है। ऑलटेस्ट क्रियान्वयन का उपयोग करना, गुणों के लिए फ़िल्टरिंग में भी समाधान का विस्तार कर सकता है (हम @Fast एनोटेशन का उपयोग करते थे, लेकिन अभी तक प्रकाशित नहीं किए गए थे)।

यहां JUnit का एक विस्तार है जो वांछित व्यवहार उत्पन्न कर सकता है: https://github.com/aafuks/aaf-junit

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

मैं यहाँ सोच रहा था कि मेरे परीक्षण क्रम में नहीं चलते थे, लेकिन सच्चाई यह है कि गड़बड़ मेरी एशिनक नौकरियों में थी। संगामिति के साथ काम करते समय आपको अपने परीक्षणों के बीच संयोजकता जांच भी करने की आवश्यकता है। मेरे मामले में, नौकरियां और परीक्षण एक सेमाफोर साझा करते हैं, इसलिए अगले टेस्ट लटका तक चलने वाली नौकरी लॉक जारी करती है

मुझे पता है कि यह इस प्रश्न से पूरी तरह से संबंधित नहीं है, लेकिन शायद सही मुद्दे को लक्षित करने में मदद कर सकता है