पर्ल बिल्ड, यूनिट टेस्टिंग, कोड कवरेज: एक पूर्ण कार्य उदाहरण

Question

अधिकांश स्टाकेवरफ्लो का जवाब है कि मुझे पर्ल बिल्ड प्रक्रिया और यूनिट परीक्षण और कोड कवरेज के संबंध में मिला है, बस मुझे वहां प्रलेखन के लिए सीपीएएन की ओर इशारा करता है। सीपीएएन मॉड्यूल की ओर इशारा करते हुए कुछ भी गलत नहीं है क्योंकि यही वह जगह है जहां पूर्ण प्रलेखन को निवास करना है। मुझे कई मामलों में पूर्ण वर्किंग कोड उदाहरण खोजने में परेशानी हुई है।

मैं वास्तविक कामकाजी कोड नमूनों के लिए पूरे इंटरनेट पर खोज कर रहा हूं, जिसे मैं अपने आईडीई में डाउनलोड या पेस्ट कर सकता हूं, जैसे आपके विशिष्ट ट्यूटोरियल "हैलो वर्ल्ड" उदाहरण स्रोत कोड, लेकिन एक उदाहरण जो यूनिट परीक्षण और कोड के साथ बिल्ड प्रक्रिया को प्रदर्शित करता है। कवरेज विश्लेषण। क्या किसी के पास पूर्ण कार्यशील परियोजना का एक छोटा सा उदाहरण है जो इन प्रौद्योगिकियों और प्रक्रियाओं को प्रदर्शित करता है?

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

Answer 1

मुझे कुछ समय लगा और मुझे कई स्नोत से छोटे स्निपेट लेने और उन्हें एक साथ पिघलाने में भी मदद मिली, लेकिन मुझे लगता है कि मेरे पास एक छोटा सा काम करने का उदाहरण है जो एक पर्ल नौसिखिया के लिए पर्याप्त रूप से प्रदर्शित करता है जो यूनिट परीक्षण और कोड कवरेज सहित पर्ल बिल्ड प्रक्रिया है विश्लेषण और रिपोर्टिंग। (मैं एक Windows XP प्रो पीसी पर ActiveState ActivePerl v5.10.0 का उपयोग कर रहा हूं , मॉड्यूल :: बिल्ड , टेस्ट :: अधिक , देवल :: कवर )

अपने पर्ल प्रोजेक्ट के लिए एक डायरेक्टरी से शुरुआत करें और फिर अपने प्रोजेक्ट डायरेक्टरी के तहत "लिबास" डायरेक्टरी और "टी" डायरेक्टरी बनाएं:

HelloPerlBuildWorld
        |
        |----------> lib
        |
        |----------> t

"Lib" निर्देशिका में, "HelloPerlBuildWorld.pm" नामक एक टेक्स्ट फ़ाइल बनाएं। यह फ़ाइल आपका पर्ल मॉड्यूल है जिसका आप निर्माण और परीक्षण करेंगे। निम्न सामग्री को इस फ़ाइल में पेस्ट करें:

use strict;
use warnings;
package HelloPerlBuildWorld;

$HelloPerlBuildWorld::VERSION = '0.1';

sub hello {
   return "Hello, Perl Build World!";
}

sub bye {
   return "Goodbye, cruel world!";
}

sub repeat {
   return 1;
}

sub argumentTest {
    my ($booleanArg) = @_;

    if (!defined($booleanArg)) {
        return "null";
    }
    elsif ($booleanArg eq "false") {
        return "false";
    }
    elsif ($booleanArg eq "true") {
        return "true";
    }
    else {
        return "unknown";
    }

   return "Unreachable code: cannot be covered";
}

1;

"T" निर्देशिका में, "HelloPerlBuildWorld.t" नामक एक टेक्स्ट फ़ाइल बनाएं। यह फ़ाइल आपकी इकाई परीक्षण स्क्रिप्ट है जो ऊपर दिए गए आपके पर्ल मॉड्यूल का पूरी तरह से परीक्षण करने का प्रयास करेगी। इस फ़ाइल में निम्न सामग्री पेस्ट करें:

use strict;
use warnings;
use Test::More qw(no_plan);

# Verify module can be included via "use" pragma
BEGIN { use_ok('HelloPerlBuildWorld') };

# Verify module can be included via "require" pragma
require_ok( 'HelloPerlBuildWorld' );

# Test hello() routine using a regular expression
my $helloCall = HelloPerlBuildWorld::hello();
like($helloCall, qr/Hello, .*World/, "hello() RE test");

# Test hello_message() routine using a got/expected routine
is($helloCall, "Hello, Perl Build World!", "hello() IS test");

# Do not test bye() routine

# Test repeat() routine using a got/expected routine
for (my $ctr=1; $ctr<=10; $ctr++) {
    my $repeatCall = HelloPerlBuildWorld::repeat();
    is($repeatCall, 1, "repeat() IS test");
}

# Test argumentTest() 
my $argumentTestCall1 = HelloPerlBuildWorld::argumentTest();
is($argumentTestCall1, "null", "argumentTest() IS null test");

# Test argumentTest("true") 
my $argumentTestCall2 = HelloPerlBuildWorld::argumentTest("true");
is($argumentTestCall2, "true", "argumentTest() IS true test");

# Test argumentTest("false") 
my $argumentTestCall3 = HelloPerlBuildWorld::argumentTest("false");
is($argumentTestCall3, "false", "argumentTest() IS false test");

# Test argumentTest(123) 
my $argumentTestCall4 = HelloPerlBuildWorld::argumentTest(123);
is($argumentTestCall4, "unknown", "argumentTest() IS unknown test");

अब अपने शीर्ष स्तर के प्रोजेक्ट डायरेक्टरी में वापस जाएं, "Build.PL" नामक एक टेक्स्ट फ़ाइल बनाएं। यह फ़ाइल आपकी बिल्ड स्क्रिप्ट बनाएगी जिसे आप बाद में उपयोग करेंगे। इस फ़ाइल में निम्न सामग्री पेस्ट करें:

use strict;
use warnings;
use Module::Build;

my $builder = Module::Build->new(
    module_name         => 'HelloPerlBuildWorld',
    license             => 'perl',
    dist_abstract       => 'HelloPerlBuildWorld short description',
    dist_author         => 'Author Name <[e-mail]>',
    build_requires => {
        'Test::More' => '0.10',
    },
);

$builder->create_build_script();

वह सभी फाइलें जिनकी आपको जरूरत है। अब शीर्ष स्तरीय परियोजना निर्देशिका में कमांड लाइन से, निम्न कमांड टाइप करें:

perl Build.PL

आपको निम्नलिखित के समान कुछ दिखाई देगा:

Checking prerequisites...
Looks good

Creating new 'Build' script for 'HelloPerlBuildWorld' version '0.1'

अब आपको निम्नलिखित कमांड के साथ अपने यूनिट टेस्ट चलाने में सक्षम होना चाहिए:

Build test

और कुछ इसी तरह देखें:

Copying lib\HelloPerlBuildWorld.pm -> blib\lib\HelloPerlBuildWorld.pm
t\HelloPerlBuildWorld....ok
All tests successful.
Files=1, Tests=18,  0 wallclock secs ( 0.00 cusr +  0.00 csys =  0.00 CPU)

कोड कवरेज विश्लेषण के साथ अपनी इकाई परीक्षण चलाने के लिए, यह प्रयास करें:

Build testcover

और आप इस के आदेश पर कुछ देखेंगे:

t\HelloPerlBuildWorld....ok
All tests successful.
Files=1, Tests=18, 12 wallclock secs ( 0.00 cusr +  0.00 csys =  0.00 CPU)
cover
Reading database from D:/Documents and Settings/LeuchKW/workspace/HelloPerlBuildWorld/cover_db


----------------------------------- ------ ------ ------ ------ ------ ------
File                                  stmt   bran   cond    sub   time  total
----------------------------------- ------ ------ ------ ------ ------ ------
D:/Perl/lib/ActivePerl/Config.pm       0.0    0.0    0.0    0.0    n/a    0.0
D:/Perl/lib/ActiveState/Path.pm        0.0    0.0    0.0    0.0    n/a    0.0
D:/Perl/lib/AutoLoader.pm              0.0    0.0    0.0    0.0    n/a    0.0
D:/Perl/lib/B.pm                      18.6   16.7   13.3   19.2   96.4   17.6
 ...
[SNIP]
 ...
D:/Perl/lib/re.pm                      0.0    0.0    0.0    0.0    n/a    0.0
D:/Perl/lib/strict.pm                 84.6   50.0   50.0  100.0    0.0   73.1
D:/Perl/lib/vars.pm                   44.4   36.4    0.0  100.0    0.0   36.2
D:/Perl/lib/warnings.pm               15.3   12.1    0.0   11.1    0.0   12.0
D:/Perl/lib/warnings/register.pm       0.0    0.0    n/a    0.0    n/a    0.0
blib/lib/HelloPerlBuildWorld.pm       87.5  100.0    n/a   83.3    0.0   89.3
Total                                  9.9    4.6    2.8   11.3  100.0    7.6
----------------------------------- ------ ------ ------ ------ ------ ------


Writing HTML output to D:/Documents and Settings/LeuchKW/workspace/HelloPerlBuildWorld/cover_db/coverage.html ...
done.

(कोई व्यक्ति कृपया यह बताएं कि कवर को छोड़कर सभी पर्ल पुस्तकालयों को अनदेखा करने के लिए कैसे कॉन्फ़िगर किया जाए और मेरे द्वारा लिखे गए मेरे एकल पर वापस रिपोर्ट करें। मुझे CPAN प्रलेखन के अनुसार काम करने के लिए कवर फ़िल्टरिंग नहीं मिल सकती है!)

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

_{(स्रोत: leucht.com )}

एक और चीज जो आप अपने IDE में इस प्रक्रिया को स्वचालित करने में मदद कर सकते हैं वह है कुछ और "Build.PL" प्रकार की फाइलें बनाना जो स्पष्ट रूप से कुछ निर्माण लक्ष्य बनाते हैं जो हमने कमांड लाइन से मैन्युअल रूप से ऊपर किए थे। उदाहरण के लिए, मैं निम्नलिखित सामग्री के साथ "BuildTest.PL" फ़ाइल का उपयोग करता हूं:

use strict;
use warnings;
use Module::Build;

my $build = Module::Build->resume (
  properties => {
    config_dir => '_build',
  },
);

$build->dispatch('build');
$build->dispatch('test');

फिर मैंने एक ही माउस क्लिक के साथ इस फ़ाइल ("पर्ल बिल्डटेस्ट.पीएल" के माध्यम से) को निष्पादित करने के लिए अपना आईडीई सेट किया और यह स्वचालित रूप से कमांड लाइन से मैन्युअल रूप से करने के बजाय आईडीई से मेरे यूनिट परीक्षण कोड को चलाता है। स्वचालित कोड कवरेज निष्पादन के लिए "प्रेषण (" परीक्षण ') को "प्रेषण (' टेस्टकवर ')" से बदलें। मॉड्यूल :: बिल्ड से उपलब्ध लक्ष्य की पूरी सूची के लिए "बिल्ड सहायता" टाइप करें।

Comments

एक बिल्ट.स्टाइल स्थापित करने का आपका विचार मेरे लिए अच्छा नहीं लगता। आप सिर्फ एक स्क्रिप्ट क्यों नहीं लिख सकते जो करता है Build buildऔर फिर Build test?

— लियोन टिम्मरमैन

लियोन, क्या आप एक पर्ल स्क्रिप्ट का सुझाव दे रहे हैं जो कमांड लाइन कॉल करता है? यदि ऐसा है, तो मैं कमांड लाइन कॉल नहीं कर सकता हूं यदि कॉल का प्रोग्राम बनाने के लिए एक ओओ तरीका है उदाहरण के लिए अंतर्निहितTT.PL फ़ाइल।

— कर्ट डब्ल्यू। ल्यूचट

यह आवश्यक नहीं है, मेरा स्वयं का उत्तर देखें

— लियोन टिम्मरमैन

मॉड्यूल :: बिल्ड सिर्फ CPAN के लिए नहीं है। यदि आप CPAN पर नहीं हैं, तब भी आप विभिन्न CPAN उपकरणों से सभी सुविधाएँ प्राप्त कर सकते हैं। आप निजी मॉड्यूल होने के बावजूद भी इसे उसी प्रक्रिया के साथ बना, परीक्षण, वितरित और स्थापित कर सकते हैं।

— ब्रायन डी फ़ो

डेवेल में परिणामों को फ़िल्टर करने के लिए :: कवर I में विकल्प जोड़ें $ENV{HARNESS_PERL_SWITCHES}। उदाहरण के लिए: आवेदन-निजी पुस्तकालय -MDevel::Cover=+ignore,.t$,+inc,/app/lib,-select,MyModule.pmकहां /app/libहै और MyModule.pmपरीक्षण के तहत मॉड्यूल है।

— माइकल कार्मन

Answer 2

कर्ट के जवाब में, मैं इस विकल्प को उनकी निर्मित निर्मित स्क्रिप्ट के लिए प्रस्तावित करूंगा।

use strict;
use warnings;
use Module::Build;

my $build = Module::Build->resume (
  properties => {
    config_dir => '_build',
  },
);

$build->dispatch('build');
$build->dispatch('test');

यह Build.PL द्वारा डेटाबेस के निर्माण का पुन: उपयोग करता है (और इस तरह मानता है कि पहले से ही चला गया है)।

Comments

उत्तम! धन्यवाद, लियोन। मुझे पता था कि मेरे उदाहरण में कुछ गड़बड़ है, लेकिन मैं अभी भी इस पर्ल बिल्ड सामान के लिए नया हूं! :-)

— कर्ट डब्ल्यू। ल्यूचट

Answer 3

मैं इसे इंटरमीडिएट पर्ल में और साथ ही मैस्टेरिंग पर्ल को कवर करता हूं । हालांकि, कर्ट ने एक अच्छा सारांश दिया है।

मैं इन सभी को मॉड्यूल :: रिलीज हालांकि का उपयोग करते हुए रिलीज स्क्रिप्ट में जोड़ती हूं । मैं एक कमांड टाइप करता हूं और यह सब होता है।

Answer 4

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

इसके अलावा: CPAN- संबंधित उपकरणों का उपयोग करना Module::Build- जैसे कि उन मॉड्यूलों के लिए भी जो संभवत: कभी भी सार्वजनिक रूप से जारी नहीं होंगे - एक बहुत अच्छा विचार है ।

Answer 5

(खुलासा: मैं लेखक हूं)

एक बार जब आपके पास सब कुछ ऊपर वर्णित के अनुसार हल हो जाता है, तो आप अगला कदम उठा सकते हैं और Devel :: CoverX :: Covered to eg

• स्रोत फ़ाइल को देखते हुए, परीक्षण फ़ाइलों को सूचीबद्ध करें जो उस स्रोत फ़ाइल को कवरेज प्रदान करती हैं। यह एक फ़ाइल, उप दिनचर्या और पंक्ति स्तर पर किया जा सकता है।
• एक परीक्षण फ़ाइल को देखते हुए, स्रोत फ़ाइलों को सूचीबद्ध करें और उस परीक्षण फ़ाइल द्वारा कवर किए गए उप को सूचीबद्ध करें।
• एक स्रोत फ़ाइल को देखते हुए, प्रति पंक्ति या उप कवरेज विवरणों पर कुशलता से रिपोर्ट करें।

कंक्रीट कमांड लाइन के उदाहरणों के लिए सारांश देखें ।

में Devel :: PerlySense वहाँ स्रोत कोड बफर (में कवरेज जानकारी प्रदर्शित करने के Emacs समर्थन स्क्रीन शॉट ), और परीक्षण फ़ाइलों को कवर से / करने के लिए नेविगेट करने के लिए।