आर में एक सांख्यिकीय समारोह का परीक्षण करने के लिए दिशानिर्देश?

Question

प्रश्न: मैं ऐसे पैकेज में फ़ंक्शंस का परीक्षण कर रहा हूं जो मैं विकसित कर रहा हूं और जानना चाहूंगा कि आप यह कैसे करना है इसके लिए कुछ सामान्य दिशानिर्देश सुझा सकते हैं। कार्यों में सांख्यिकीय मॉडलिंग, परिवर्तन, सबसेटिंग और साजिश की एक बड़ी श्रृंखला शामिल है। क्या कोई 'मानक' या कुछ पर्याप्त परीक्षण है?

एक उदाहरण: परीक्षण मुझे यह सवाल पूछते के लिए प्रेरित किया है कि,

समारोह dtheta:

dtheta <- function(x) { 
    ## find the quantile of the mean 
    q.mean <- mean(mean(x) >= x) 
    ## find the quantiles of ucl and lcl (q.mean +/- 0.15) 
    q.ucl <- q.mean + 0.15 
    q.lcl <- q.mean - 0.15 
    qs <- c(q.lcl, q.mean, q.ucl) 
    ## find the lcl, mean, and ucl of the vector 
    c(quantile(x,qs), var(x), sqrt(var(x))/mean(x)) 
} 

चरण 1:

set.seed(100) # per Dirk's recommendation 
test <- rnorm(100000,10,1) 

चरण 2: परीक्षण डाटा बनाने: फ़ंक्शन से वास्तविक आउटपुट के साथ फ़ंक्शन से अपेक्षित आउटपुट की तुलना करें:

expected <- quantile(test, c(0.35, 0.65, 0.5)) 
actual <- dtheta(test)[1:3] 
signif(expected,2) %in% signif(actual,2) 

चरण 3: हो सकता है एक और परीक्षण

test2 <- runif(100000, 0, 100) 
expected <- c(35, 50, 65) 
actual <- dtheta(test2) 
expected %in% signif(actual,2) 

चरण 4 कार्य करें: अगर सही है, समारोह 'कार्यात्मक'

Answer 1

यह इस बात पर निर्भर करता है कि आप वास्तव में क्या परीक्षण करना चाहते हैं। डर्क्स सिफारिशों, svUnit या RUnit पैकेज VitoshKa उल्लेख के बगल में, मैं कुछ चीजें जोड़ना चाहते हैं:

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

डेटासेट के विस्तारित परीक्षण पर एक उदाहरण: आप इन मामलों में आउटपुट के रूप में क्या देखना चाहेंगे? क्या यह परिणाम आप उम्मीद करेंगे? आपके द्वारा किए गए परीक्षण के अनुसार नहीं।

> test3 <- rep(12,100000) # data with only 1 value 
> expected <- c(12, 12, 12) 
> actual <- dtheta(test3) 
Error in quantile.default(x, qs) : 'probs' outside [0,1] 

> test4 <- rbinom(100000,30,0.5) # large dataset with a limited amount of values 
> expected <- quantile(test4,c(0.35, 0.50, 0.65)) 
> actual <- dtheta(test4) 
> expected %in% signif(actual,2) 
[1] FALSE TRUE TRUE 

> test5 <- runif(100,0,100) # small dataset. 
> expected <- c(35, 50, 65) 
> actual <- dtheta(test5) 
> expected %in% signif(actual,2) 
[1] FALSE FALSE FALSE 

संपादित करें: सही कोड इसलिए परीक्षण थोड़ा अधिक समझदार होते हैं।

Answer 2

अच्छा प्रश्न पर विचार करें।

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

Answer 3

आप

1. परीक्षणों से पता चलता है कि जब आप इनपुट समझदार मूल्यों

2. परीक्षण अपने कार्य चलता है कि सही ढंग से जब आप इनपुट बकवास में विफल रहता है तो आप सही जवाब पाने के बारे में की जरूरत है। सभी सीमा मामलों

वहाँ परीक्षण सॉफ्टवेयर के लिए विभिन्न रणनीतियों पर साहित्य की एक बड़ी राशि है के लिए

परीक्षण; विकिपीडिया के software testing page किसी भी स्थान को शुरू करने के लिए उतना ही अच्छा स्थान है।

अपने उदाहरण को देखते:

क्या होता है जब आप कोई ऐसा स्ट्रिंग/dataframe/सूची?
नकारात्मक x या काल्पनिक x के बारे में क्या?
वेक्टर/सरणी x के बारे में कैसे?
यदि केवल सकारात्मक x की अनुमति है, तो x = 0 पर क्या होता है?

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

Answer 4

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

स्वचालित परीक्षण आपको इन परीक्षण मामलों को स्थापित करने की अनुमति देता है, साथ ही अन्य जैसा उपरोक्त सुझाव दिया गया है;

• सीमा
• तनाव टेस्ट टेस्ट (कम जरूरत सटीकता के लिए परीक्षण करने के लिए, बस उसे डेटा फेंक और अगर इस पर गिर जाता है देखें)
• विभिन्न इनपुट
• अलग अंतर्निहित प्लेटफार्मों/स्थानों के साथ काम के साथ काम