Arturo ट्रैक सभी अभ्यासों के टेस्ट के लिए Unitt 3.0.0 यूनिट-टेस्टिंग पैकेज का उपयोग करता है।
यह पैकेज एक टेस्टिंग फ्रेमवर्क है, जो आधुनिक RSpec-शैली के सिंटैक्स और पुराने XUnit-शैली के सिंटैक्स, दोनों का समर्थन करता है।
अपने लोकल अभ्यास फोल्डर के अंदर से arturo tester.art या exercism test चलाने पर पहली बार यह पैकेज इंटरनेट से इंस्टॉल हो जाना चाहिए।
इसके अलावा, आप arturo --package install unitt 3.0.0 चलाकर Unitt इंस्टॉल कर सकते हैं।
शुरू में सिर्फ पहला टेस्ट ही चलाया जाएगा और उसका नतीजा आपको बताया जाएगा।
वह टेस्ट पास हो जाने के बाद अगले टेस्ट को अनस्किप कीजिए और टेस्ट दोबारा चलाइए, और ऐसा तब तक कीजिए जब तक हर टेस्ट पास न हो जाए।
RSpec और XUnit, दोनों तरह की सेटअप में यह काम उतना ही आसान है: RSpec वाले सेटअप में it.skip से और XUnit वाले सेटअप में test.skip से .skip हटा दीजिए।
सारे टेस्ट पास हो जाने पर अपना हल सबमिट कीजिए, लेकिन ध्यान रखिए कि टेस्ट रनर स्किप किए गए टेस्ट समेत सारे टेस्ट चलाता है।
शुरुआत कीजिए
आपके डाउनलोड किए गए अभ्यास फोल्डर में कुछ फाइलें होंगी, लेकिन ये तीन सबसे ज़रूरी हैं।
leap/
├── src/leap.art # Your solution file
├── tests/test-leap.art # Test cases for the exercise
└── tester.art # Test runner entry point
arturo tester.art चलाने पर Unitt सेट हो जाता है और फिर tests/test-leap.art के अंदर के टेस्ट चलने लगते हैं।
ये टेस्ट src/leap.art को इम्पोर्ट करते हैं, जिसमें आपका हल होता है, और फिर कई एसर्शन करते हैं कि खास इनपुट के लिए आपके हल को क्या लौटाना चाहिए।
हल की फाइल
isLeap?: function [year][
panic "please implement the isLeap? function"
]
कोई अभ्यास शुरू करते समय आपकी हल फाइल के साथ एक टेम्पलेट मिलता है, जिसमें वह बुनियादी ढाँचा होता है जिसकी अपेक्षा की जाती है।
Leap के इस उदाहरण में फाइल में अपेक्षित isLeap? फंक्शन की बुनियादी परिभाषा है और खास तौर पर एक panic है, जो टेस्ट चलना रोक देता है।
panic वाली लाइन हटा दीजिए और फिर isLeap? के लिए अपना कोड लिखना शुरू कीजिए।
RSpec टेस्ट का ढाँचा
import.version:3.0.0 {unitt}!
import {src/leap}!
describe "Leap" [
it "a year not divisible by 4 is a common year" [
expects.be:'false? @[isLeap? 2015]
]
it.skip "a year divisible by 4 and not divisible by 100 is a leap year" [
expects.be:'true? @[isLeap? 1996]
]
]
-
describe उन टेस्ट केसों का ब्लॉक बनाता है जो एक ही चीज़ की जाँच करते हैं। इन्हें एक के अंदर एक भी रखा जा सकता है।
-
it और it.skip दोनों एक-एक टेस्ट केस बनाते हैं, जो क्रमशः या तो चलाया जाता है या स्किप कर दिया जाता है।
-
expects उस एसर्शन की शुरुआत करता है जो हर टेस्ट केस का मूल होता है। expects.be एक प्रेडिकेट फंक्शन लेता है, जिससे एसर्शन किया जाता है।
expects.be:'false? @[isLeap? 2015] में टेस्ट सूट यह एसर्शन कर रहा है कि फंक्शन isLeap? को साल 2015 के लिए false लौटाना चाहिए।
इसे लिखने का एक और तरीका है expects.be:'equal? @[false isLeapYear? 2015], जहाँ हम यह एसर्शन कर रहे हैं कि isLeapYear? 2015 जो वैल्यू लौटाता है, वह false के बराबर है।
दो वैल्यू की तुलना करने वाला यह लंबा रूप Arturo ट्रैक पर सबसे आम तरह का एसर्शन है।
ब्लॉक में अपेक्षित वैल्यू हमेशा पहले आती है, उसके बाद परिणाम वैल्यू।
XUnit टेस्ट का ढाँचा
suite "Leap" [
test "a year not divisible by 4 is a common year" [
result: isLeap? 2015
assert -> false = result
]
test.skip "a year divisible by 4 and not divisible by 100 is a leap year" [
result: isLeap? 1996
assert -> true = result
]
]
Unitt के v1 में पेश किया गया XUnit जैसा API बैकवर्ड कंपैटिबिलिटी के लिए समर्थित है और अपने कम लचीले एसर्शन को छोड़कर मोटे तौर पर आधुनिक RSpec जैसे API के बराबर है।
-
suite उन टेस्ट केसों का ब्लॉक बनाता है जो एक ही चीज़ की जाँच करते हैं। इन्हें एक के अंदर एक भी रखा जा सकता है।
-
test और test.skip दोनों एक-एक टेस्ट केस बनाते हैं, जो क्रमशः या तो चलाया जाता है या स्किप कर दिया जाता है।
-
assert उस एसर्शन की शुरुआत करता है जो हर टेस्ट केस का मूल होता है। अगले -> के दाईं ओर वाला एक्सप्रेशन सही होना चाहिए।
XUnit टेस्ट में आम तौर पर assert लाइन से पहले परिणाम रखने वाले वेरिएबलो बनाए जाते हैं, और चाहें तो अपेक्षित वैल्यू रखने वाले वेरिएबलो भी।
टेस्ट का आउटपुट
आप RSpec API इस्तेमाल करें या XUnit API, टेस्ट का आउटपुट मोटे तौर पर एक जैसा ही रहेगा।
फर्क सिर्फ इसमें होगा कि हर टेस्ट के नाम के नीचे क्या छपता है।
XUnit एसर्शन को जाँची गई वैल्यू के साथ बताता है, इसलिए आपको false = false दिखता है।
लेकिन RSpec इसे false? false के रूप में बताता है, क्योंकि हमने expects के साथ false? फंक्शन इस्तेमाल किया था।
शुरुआत से देखें तो अगर शुरुआती फाइल से panic हटाया नहीं गया है, तो Arturo एक एरर बताएगा और कोई भी टेस्ट नहीं चलाएगा।
Uncaught error in tests/test-leap.art:
#[
output: {
══╡ Program Error ╞═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════ <script> ══
Please implement the isLeap? function
}
code: 1
]
panic हटा देने के बाद Arturo किसी टेस्ट के अंदर किए गए हर एसर्शन की स्थिति बताएगा।
अब पहला टेस्ट पास होता है, लेकिन दूसरा टेस्ट स्किप कर दिया जाता है।
======== .unitt/tests/test-leap.art ========
Describe: Leap
✅ - assert that a year not divisible by 4 is a common year
✅: false? false
⏩ - assert that a year divisible by 4 and not divisible by 100 is a leap year
skipped!
========== Summary ==========
⏏️ TOTAL: 2 assertions
✅ PASSED: 1 assertion
⏩ SKIPPED: 1 assertion
❌ FAILED: 0 assertion
========== ======= ==========
दूसरा टेस्ट हाथ से अनस्किप करने के बाद दोनों टेस्ट चलेंगे।
लेकिन isLeap? का मौजूदा कोड सिर्फ false लौटाता है, इसलिए दूसरे टेस्ट का एसर्शन फेल हो जाता है।
======== .unitt/tests/test-leap.art ========
Describe: Leap
✅ - assert that a year not divisible by 4 is a common year
✅: false? false
❌ - assert that a year divisible by 4 and not divisible by 100 is a leap year
❌: true? false
========== Summary ==========
⏏️ TOTAL: 2 assertions
✅ PASSED: 1 assertion
⏩ SKIPPED: 0 assertion
❌ FAILED: 1 assertion
========== ======= ==========
जैसे-जैसे आप और टेस्ट अनस्किप करते जाएँगे, यही क्रम चलता रहेगा।
सारे टेस्ट पास हो जाने पर आपका अभ्यास पूरा हो जाता है और आप हल सबमिट कर सकते हैं।
ध्यान रखिए कि लोकल पर टेस्ट रनर सारे टेस्ट चलाएगा, चाहे वे स्किप किए गए हों या नहीं।
