टेस्ट डेंसिटी और बग डेंसिटी कैलकुलेटर

गणना दर्ज करें

टेस्ट की संख्या (tests)

बग की संख्या (bugs)

सोर्स कोड की लाइनें

कोड साइज़ इकाई LOC KLOC

परिणाम

बग डेंसिटी (प्रति KLOC)

2.5

बग/KLOC

टेस्ट डेंसिटी (प्रति LOC)	0.05 tests/LOC
टेस्ट डेंसिटी (प्रति KLOC)	50 tests/KLOC
बग डेंसिटी (प्रति LOC)	0.0025 bugs/LOC
बग डेंसिटी (प्रति KLOC)	2.5 bugs/KLOC
नॉर्मलाइज़्ड कोड साइज़	10,000 LOC

यह कैलकुलेटर क्या करता है

यह टूल सॉफ़्टवेयर इंजीनियरिंग में आमतौर पर इस्तेमाल होने वाले दो क्वालिटी मेट्रिक्स निकालता है: टेस्ट डेंसिटी (आपके कोडबेस के आकार की तुलना में कितने टेस्ट केस हैं) और बग डेंसिटी (कोडबेस के आकार की तुलना में कितने डिफेक्ट मिले)। दोनों मान प्रति LOC (Lines Of Code यानी कोड की लाइनें) और प्रति KLOC (हज़ार लाइनों के हिसाब से) दिखाए जाते हैं, क्योंकि इंडस्ट्री में रिपोर्टिंग के लिए KLOC ही मानक इकाई है। यह एक यूनिवर्सल मेट्रिक है, जिसमें किसी देश या क्षेत्र के अलग नियम नहीं होते।

इसका इस्तेमाल कैसे करें

चलाए गए टेस्ट केस की संख्या, मिले हुए बग की संख्या और अपने सोर्स कोड का आकार दर्ज करें। यह चुनें कि कोड साइज़ का आँकड़ा सीधे लाइनों में (LOC) है या हज़ार लाइनों में (KLOC) — कैलकुलेटर गणना से पहले इसे कच्ची LOC में बदल लेता है। इसके बाद सारी डेंसिटी अपने-आप निकल आती हैं।

फ़ॉर्मूला समझें

सबसे पहले कोड साइज़ को नॉर्मलाइज़ किया जाता है: \( \text{locLines} = \text{loc} \times \text{factor} \), जहाँ LOC के लिए factor 1 और KLOC के लिए 1000 होता है। फिर प्रति LOC टेस्ट डेंसिटी = टेस्ट संख्या / locLines, और प्रति LOC बग डेंसिटी = बग संख्या / locLines। प्रति KLOC वाले मान बस प्रति LOC वाले मान को 1000 से गुणा करके मिलते हैं। टेस्ट और बग की संख्या सादी पूर्णांक गिनती होती है और इन्हें कभी स्केल नहीं किया जाता।

$$\text{Test Density} = \frac{\text{Test Count}}{L} \times 1000, \qquad \text{Bug Density} = \frac{\text{Bug Count}}{L} \times 1000$$

जहाँ \( L = \text{Source Lines of Code} \times 1\ (\text{LOC}) \) या \( L = \text{Source Lines of Code} \times 1000\ (\text{KLOC}) \)।

दोनों मेट्रिक एक गिनती (बग या टेस्ट) को कोड आकार से विभाजित करते हैं, प्रति-KLOC में मापा गया।

हल किया हुआ उदाहरण

मान लीजिए आपने 500 टेस्ट चलाए, 25 बग पाए, और आपका कोडबेस 10 KLOC का है। नॉर्मलाइज़्ड साइज़ = \( 10 \times 1000 = 10{,}000 \) LOC।

$$\text{Test Density} = \frac{500}{10{,}000} = 0.05\ \text{टेस्ट/LOC} = 50\ \text{टेस्ट/KLOC}$$$$\text{Bug Density} = \frac{25}{10{,}000} = 0.0025\ \text{बग/LOC} = 2.5\ \text{बग/KLOC}$$

अक्सर पूछे जाने वाले सवाल

प्रति LOC और प्रति KLOC दोनों क्यों दिए जाते हैं? प्रति LOC मान बहुत छोटे होते हैं और पढ़ने में मुश्किल, इसलिए इंडस्ट्री में आमतौर पर प्रति KLOC रिपोर्ट किया जाता है। दोनों में जानकारी एक ही होती है — एक बस दूसरे का 1000 गुना है।

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

क्या मैं इन आँकड़ों की तुलना अलग-अलग प्रोजेक्ट्स के बीच कर सकता हूँ? सिर्फ़ तभी, जब LOC गिनने के नियम एक जैसे हों। यह तय कर लें कि कमेंट लाइनें और खाली लाइनें गिनी जाएँगी या नहीं, क्योंकि यह चुनाव डेंसिटी के मानों को काफ़ी हद तक बदल देता है।