सीमा मूल्यों को खोजने के लिए बीएमडब्ल्यू mnemonics

सामग्री

• बीएमडब्ल्यू Mnemonics
• आम उदाहरण
  
  • संख्या
  • तिथि
  • पंक्ति
  • फ़ाइल
  • Oracle में तालिका (डेटाबेस)
  • सिस्टम में रिपोर्ट करें
  • मोबाइल ऐप
    
    • लिंक
    • स्मृति की मात्रा
    • उपकरण विकर्ण
    • स्क्रीन रिज़ॉल्यूशन
    • GPX पथ
  • सामान्य उदाहरणों का सारांश
• मेरे अभ्यास के उदाहरण हैं
  बड़ा चूहा
  
  • लिनक्स, ल्यूसीन, मैप
  • रेडहैट 6 ≠ रेडहैट 7
  • जावा और कचरा संग्रह
  • Wildfly
  • लॉगिंग
  • लिप्यंतरण
  • ओरेकल आरएसी
  
  छोटा चूहा
  
  • खाली जशन
  • पता क्षेत्र में "मॉस्को"
• कुल मिलाकर

Mnemonics एक शब्द या वाक्यांश है जो हमें कुछ याद रखने में मदद करता है। सबसे प्रसिद्ध mnemonics है "हर शिकारी जानना चाहता है कि तीतर कहाँ बैठता है।" आप जो भी पूछते हैं, हर कोई उसे जानता है।

लेकिन पेशेवर क्षेत्र में, सब कुछ थोड़ा दुखी है। अपने साथियों से पूछें कि क्या उन्हें पता है कि SPDFOT या RCRCRC क्या है। एक तथ्य से बहुत दूर ... लेकिन सबसे महत्वपूर्ण जाँच करने के लिए भूलकर भी नस्लों को परीक्षण चलाने में हमारी मदद करते हैं। एक वाक्यांश में चेकलिस्ट ढह गई!

अंग्रेजी बोलने वाले परीक्षण सहयोगी सक्रिय रूप से mnemonics का उपयोग करते हैं। एक दोस्त जो विदेशी ब्लॉग पढ़ता है, कहता है कि अमेरिकी लगभग हर छींक के लिए उनके साथ आते हैं।

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

आज मैं सीमा मूल्यों के अध्ययन के लिए अपने बीएमडब्ल्यू mnemonics आपके साथ साझा करना चाहता हूं। यह हो सकता है:

• परीक्षण डिजाइन में सामान्य विकास के लिए कनिष्ठ देना;
• साक्षात्कार में उपयोग करें - उम्मीदवार आमतौर पर "नंबर में सीमा खोजें" कार्य को हल करता है, लेकिन क्या वह सीमा को लाइन में या फ़ाइल डाउनलोड करने के लिए खोजेगा?

बीएमडब्ल्यू Mnemonics

बी - बड़े
एम - छोटा
बी - बस सही है



यह याद रखना आसान है। बस इस शांत कार को याद रखें और तुरंत डिक्रिप्शन तैयार है! लेकिन इसका क्या मतलब है और यह साक्षात्कार में कैसे मदद करेगा?

बस सही है

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

यदि फ़ील्ड संख्यात्मक है, तो सामान्य मान दर्ज करें। मान लीजिए कि हमारे पास एक खुदरा ऑनलाइन स्टोर है। माल की मात्रा में हम 1 या 2 की जांच कर सकते हैं।

एक सकारात्मक परीक्षण - यह "बस सही है।" मैंने एक माउस के रूप में निमोचन दिखाया। यहाँ यह एक मानक आकार है।

महान

तब हम कहते हैं कि माउस को एक अविश्वसनीय आकार में फुलाया जाना चाहिए, ताकि यह सीधे चित्र में फिट न हो। और देखें कि सिस्टम इसके साथ कैसे काम करेगा।



इस मामले में, हम सिर्फ "बहुत आगे" जा रहे हैं। बहुत दूर बड़ा माउस एक तकनीकी बाउंड्री के लिए एक खोज का प्रतिनिधित्व करता है, एक मनमाना के बाहर।

माल की मात्रा दर्ज करने के लिए, यह "99999999999999999999999999999999999999999999999999999999999 ..." पर होगा। न केवल कुछ महान मूल्य (9999), बल्कि बहुत बड़ा। माउस को याद रखें - यह इतना उड़ा हुआ था कि यह तस्वीर में फिट भी नहीं था।

अंतर महत्वपूर्ण है, महान महत्व एक मनमानी सीमा खोजने में मदद करेगा, और एक विशाल एक तकनीकी एक खोजने में मदद करेगा। "बड़ा" के लिए परीक्षण अक्सर किया जाता है, "विशाल" के लिए - नहीं। Mnemonics ठीक उसके बारे में याद करते हैं।

छोटा

हम माउस को छेदते हैं, और इसे सूक्ष्म आकार में उड़ा दिया जाता है।



छोटा माउस शून्य के निकट मूल्यों की खोज है। सबसे छोटा सकारात्मक मूल्य।

"0.00000001" के परीक्षण के बारे में क्या? शून्य के लिए जाँच की, लेकिन साथ-साथ खुदाई करने के लिए मत भूलना।

और क्या है?

यह स्पष्ट बातें कह रहा है। ऐसा लगता है कि हर कोई यह पहले से ही जानता है। बस एक संख्या कार्य, एक ही त्रिकोण ( मायर्स से एक कार्य ) पर एक साक्षात्कार दें, और आप समझते हैं कि ऐसा नहीं है ... बहुत कम लोग तकनीकी सीमा की तलाश में जाएंगे या शून्य के पास एक भिन्नात्मक मूल्य में प्रवेश करने की कोशिश करेंगे। अधिकतम शून्य और चेक करने की पेशकश करेगा।

और यदि आप संख्या नहीं का परीक्षण करने का प्रस्ताव करते हैं, तो यह एक और भी बड़ा स्तूप है। संख्या के साथ, ठीक है, हमने काम के बयान के अनुसार शून्य और सीमा की जांच की, यह पहले से ही खराब नहीं है। और क्या परीक्षण करने के लिए लाइन में? और फाइल में?

मैं इस बारे में लेख में बात करना चाहता हूं। आप वास्तविक जीवन में mnemonics का उपयोग कैसे कर सकते हैं और उसी समय बग को पकड़ सकते हैं। आइए सामान्य उदाहरणों से शुरू करें - जो हर परियोजना पर पाए जाते हैं। और जो एक छोटे से कार्य के रूप में साक्षात्कार में दिया जा सकता है।

और फिर मैं अपने काम से उदाहरण बताऊंगा। हां, वे विशिष्ट हैं। हां, वे विशिष्ट प्रौद्योगिकियों के बारे में हैं। तो क्या? लेकिन वे दिखाते हैं कि आप और अधिक जटिल स्थानों में mnemonics कैसे लागू कर सकते हैं।

अर्थ समान है: सीमाएं लगभग हर जगह हैं। बस संख्या ज्ञात करें और इसके साथ प्रयोग करें। और बीएमडब्ल्यू mnemonics के बारे में मत भूलना, क्योंकि यह बी और एम पर है कि हम अक्सर बग का सामना करते हैं।

आम उदाहरण

उदाहरण जो किसी भी परियोजना में हैं: एक संख्यात्मक क्षेत्र, एक स्ट्रिंग, एक तिथि ... हम इस क्रम में विचार करेंगे:

• बस सही है
• महान
• छोटा

संख्या

• 10
• 0.00000001
• 999999999999999999999999…।

किताबें, कपड़े या जूस के पैकेट के साथ एक बॉक्स कहें। एक सकारात्मक परीक्षण के रूप में, हम कुछ पर्याप्त राशि चुनते हैं: 3, 5, 10।

एक छोटे मूल्य के रूप में, संभव के रूप में शून्य के करीब का चयन करें। याद रखें कि माउस बहुत छोटा होना चाहिए। यह केवल एक इकाई नहीं है, बल्कि Nth दशमलव स्थान है। अचानक यह शून्य से गोल हो जाएगा और कहीं-कहीं फॉर्मूला दुर्घटनाग्रस्त हो जाएगा? इसके अलावा, संख्या "1" पर सब कुछ अच्छी तरह से काम करेगा।

खैर, अधिकतम 10 मिलियन एनआईएन दर्ज करके प्राप्त किया जाता है। Perlclip जैसे उपकरणों का उपयोग करके इस तरह की स्ट्रिंग उत्पन्न करें, और आगे बढ़ें, बहुत परीक्षण करें!

यह भी देखें:
एक स्ट्रिंग के लिए समतुल्यता वर्ग जो एक संख्या को दर्शाता है - संख्यात्मक स्ट्रिंग परीक्षणों के लिए और भी अधिक विचार
एक बड़ी स्ट्रिंग, उपकरण कैसे उत्पन्न करें - महान मूल्य पैदा करने में सहायक

तिथि

• 2017/05/26
• 1900/01/01
• 21.12.3003

एक सकारात्मक तारीख या तो "आज" है अगर हम कुछ तारीख को रिपोर्ट भेजते हैं। या आपकी खुद की जन्मतिथि, अगर हम DR के बारे में बात कर रहे हैं, या कुछ अन्य जो आपकी व्यावसायिक प्रक्रिया के अनुकूल हैं।

एक छोटी सी तारीख के रूप में, हम जादू की तारीख "01/01/1900" लेते हैं, जिस पर अक्सर आवेदन अलग हो जाते हैं। इस तिथि से, एक्सेल में समय शुरू होता है। यह अनुप्रयोगों में भी रेंगता है। आप इस जादू की संख्या को उजागर करते हैं - और रिपोर्ट अलग-अलग हो जाती है, भले ही मूर्ख से शून्य तक संरक्षण हो। इसलिए मैं सत्यापन के लिए इसकी अत्यधिक अनुशंसा करता हूं।

यदि हम एक बहुत छोटे माउस के बारे में बात करते हैं, तो आप अभी भी "00.00.0000" की जांच कर सकते हैं। यह एक शून्य जांच होगी, जो महत्वपूर्ण भी है। लेकिन डेवलपर्स 01/01/1900 की तुलना में अधिक बार ऐसे मूर्ख से सुरक्षित होते हैं।

दूर का अहसास भी अलग हो सकता है। आप एक नकारात्मक में जा सकते हैं और एक तारीख या महीने की जांच कर सकते हैं जो वास्तव में मौजूद नहीं है: 05/40/2018। या दिनांक 99.99.9999 का उपयोग करके तकनीकी सीमा खोजें। और आप थोड़ा अधिक वास्तविक मूल्य ले सकते हैं, जो कि जल्द ही नहीं आएगा: 2400 या 3000।

यह भी देखें:
एक स्ट्रिंग के लिए समतुल्यता कक्षाएं जो एक तिथि को दर्शाती हैं - एक तिथि परीक्षण के लिए और भी विचार

पंक्ति

• Vasya
• (एक स्थान)
• (बहुत पाठ हुआ)

मान लीजिए कि पंजीकरण करते समय एक नाम के साथ एक फ़ील्ड है। एक सकारात्मक परीक्षण एक सामान्य नाम है: ओल्गा, वास्या, पीटर ...

थोड़ा माउस खोजते समय, हम एक खाली रेखा या एक जीवन हैक लेते हैं: एक या दो स्थान। इस स्थिति में, रेखा खाली रहती है (वहां कोई वर्ण नहीं हैं), लेकिन यह भरा हुआ प्रतीत होता है।

एक बड़े माउस की तलाश में फोकस क्या है? जब हम एक बड़े स्ट्रिंग का परीक्षण करते हैं, तो हमें BIG स्ट्रिंग का परीक्षण करने की आवश्यकता होती है! याद रखें कि माउस को बड़ा होना चाहिए। क्योंकि मैं आमतौर पर छात्रों को समझाता हूं कि यह सब कैसे काम करता है, तकनीकी दृष्टि से कैसे देखें आदि। और फिर उन्होंने मुझे डीजेड दिया और लिखा "मैंने 1000 पात्रों की जांच की - कोई तकनीकी सीमा नहीं है।"

यार्ड में 21 सदी, ठीक है, 1000 वर्ण क्या हैं? हम कोई भी उपकरण लेते हैं जो हमें 10 मिलियन उत्पन्न करने और 10 मिलियन डालने की अनुमति देता है। अब यह एक तकनीकी सीमा की खोज होगी। और इस पर पहले से ही कीड़े हैं, इस पर सिस्टम बंद हो सकता है। लेकिन 1000 अक्षर? नहीं।

यह भी देखें:
एक बड़ी स्ट्रिंग, उपकरण कैसे उत्पन्न करें - महान मूल्य पैदा करने में सहायक

लेकिन ठीक है, यहाँ भी सब कुछ स्पष्ट है। और अगर हम फ़ाइल का परीक्षण करेंगे तो क्या होगा?

फ़ाइल

मुझे फ़ाइल में नंबर कहां मिल सकता है?

सबसे पहले, फ़ाइल का आकार है:

• 5 एम.बी.
• 1 केबी
• 10 जी.बी.

एक बड़ी फ़ाइल का परीक्षण करते समय, वे आमतौर पर 30Mb जैसी किसी चीज़ की कोशिश करते हैं, और वे इस पर शांत हो जाते हैं। और फिर आप 1GB लोड करते हैं - और वह यह है, सर्वर जमा देता है।

बेशक, यदि आप एक शुरुआत कर रहे हैं और अनुभव के लिए कुछ वास्तविक साइट का परीक्षण कर रहे हैं, तो आपको इसे स्वामी के ज्ञान के बिना लोड नहीं करना चाहिए। लेकिन जब आप काम पर परीक्षण करते हैं, तो बड़े माउस को देखना सुनिश्चित करें।

दूसरे, फ़ाइल का एक नाम है → और यह उस पंक्ति की लंबाई है जिसे हमने अभी चर्चा की है।

लेकिन फ़ाइल में इसकी सामग्री भी है! कई कॉलम (कॉलम) और पंक्तियाँ हैं। लाइन परीक्षण:

• 5 लाइनों
• 1 पंक्ति
• 1,000,000,000 पंक्तियाँ

और यहीं से मस्ती शुरू होती है। क्योंकि विभिन्न संस्करणों में एक ही एक्सेल में भी, लाइनों की संख्या पर अलग-अलग प्रतिबंध हैं जो इसका समर्थन करते हैं:

• एक्सेल नीचे 97 - 16 384
• एक्सेल 97-2003 - 65 536
• एक्सेल 2007 - 1,048,576

लेकिन फिर भी संख्या काफी बड़ी है, यह दिलचस्प नहीं है। लेकिन पुराने एक्सेल ने कॉलम में 256 से अधिक नहीं खोले, और यह एक गंभीर सीमा है:

• एक्सेल 2003 - 256
• एक्सेल 2007 - 16,385

उनके मुक्त भाई, लिबर ऑफिस, 1024 से अधिक कॉलम नहीं खोल सकते।

जीवन की कहानी

हम सीएसवी प्रारूप में कुछ ऑटोटेस्ट लिखते हैं। मेज के प्रवेश द्वार पर, तालिका के आउटपुट पर। लिब्रे ऑफिस में खोलें और देखें कि कौन सा कॉलम कहां है। सब कुछ महान है, सब कुछ काम करता है। जबकि स्तंभों की संख्या 1024 के लिए नहीं निकलती है।

यहीं से # जीवन पीड़ा शुरू होती है। लिब्रे ऑफिस टेस्ट अब नहीं खुलेगा, सीएसवी प्रारूप में यह असुविधाजनक है, क्योंकि यह समझना मुश्किल है कि 555 कॉलम कहां है। आप Excel में परीक्षण खोलते हैं, संपादित करते हैं, सहेजते हैं, परीक्षण चलाते हैं ... यह 10 नए स्थानों में आता है: TIN खराब हो गया है। यह लंबा है, उदाहरण के लिए, 7710152113. एक्सेल खुशी से 1.2E + 5 प्रारूप में अनुवाद करता है।
अन्य लंबी संख्या भी खो जाती है।

यदि मान उद्धरण चिह्नों में था, तो इसे अतिरिक्त उद्धरण चिह्नों में लपेटा जाता है, जो परीक्षण की अपेक्षा नहीं करता है।

और आप इन छोटी चीजों को पहले से ही सीएसवी प्रारूप में सुधारते हैं, मानसिक रूप से खुद को एक्सेल डांटते हैं ... इसलिए एक सीमा है, इसे याद रखना चाहिए! यद्यपि यह सिस्टम पर स्वयं प्रकट नहीं होता है, यह केवल परीक्षक के जीवन को जटिल बना सकता है।

Oracle में तालिका (डेटाबेस)

और जब से हम 1024 स्तंभों के बारे में बात कर रहे हैं, हम Oracle (एक लोकप्रिय डेटाबेस) के बारे में याद करेंगे। एक ही प्रतिबंध है: एक तालिका में अधिकतम 1024 स्तंभ हो सकते हैं।

अग्रिम में यह याद रखना बेहतर है! हमारे पास एक मेज थी जिसमें लगभग 1000 कॉलम थे, लेकिन आधा भविष्य के लिए आरक्षित था: "किसी दिन यह काम आएगा, यह हमारे लिए लंबे समय तक पर्याप्त होगा।" काफी, लेकिन लंबे समय के लिए नहीं ...

कहीं भी मेज का विस्तार करने के लिए - एक सीमा में भाग गया। इसलिए या तो तालिका को दो में विभाजित करें, या सामग्रियों को एक BLOB में पैक करें: यह एक ऐसी चीज़ है जो डेटा के साथ एक ज़िप संग्रह है जो एक कॉलम पर कब्जा करने के लिए निकलता है, लेकिन इसके अंदर आपको जितने पसंद हैं उतने हैं।

लेकिन किसी भी मामले में, यह डेटा माइग्रेशन है। और डेटा माइग्रेशन हमेशा एक दर्द होता है। एक बड़े आधार पर, एक लंबा समय लगता है, नई समस्याएं लाता है जो केवल छह महीनों में शूट की जा सकती हैं ... ब्र्र्र! यदि आप प्रवास के बिना कर सकते हैं, तो करना बेहतर है।

यदि आपके पास बहुत सारी डेटा वाली तालिका है, तो भविष्य के बारे में सोचें। क्या आप हमेशा 1024 कॉलम में फिट होंगे? क्या आपको बाद में माइग्रेट करना होगा? आखिरकार, सिस्टम जितना अधिक समय तक जीवित रहेगा, स्थानांतरण उतना ही कठिन होगा। और "5 साल के लिए पर्याप्त" का मतलब है कि पांच साल की मात्रा को माइग्रेट करना होगा।

इसका परीक्षण कैसे करें? हां, कोड के आधार पर, अपने डेटा तालिकाओं का मूल्यांकन करें, जहां यह है वहां पर एक नज़र डालें। बड़े माउस पर ध्यान दें: उन तालिकाओं में जिनमें पहले से ही बहुत सारे कॉलम हैं। क्या भविष्य में उनके साथ समस्याएं होंगी?

सिस्टम में रिपोर्ट करें

लेकिन हम सिस्टम से फाइल अपलोड क्यों करते हैं या Oracle से डेटा पंप करते हैं? किसी प्रकार की रिपोर्ट बनाने के लिए सबसे अधिक संभावना है। और यहाँ आप इस mnemonics को भी लगा सकते हैं।

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

नतीजतन, हम मात्रा का परीक्षण करते हैं:

• रिपोर्ट कॉलम
• पंक्तियों;
• इनपुट डेटा;
• आउटपुट डेटा (रिपोर्ट में ही)।

संरचना (स्तंभ और पंक्तियाँ)

क्या हम पंक्तियों या स्तंभों की संख्या को प्रभावित कर सकते हैं? कभी-कभी हां, हम कर सकते हैं। दूसरे काम में, मैंने रिपोर्ट डिजाइनर का परीक्षण किया: बाईं तरफ आपके पास मापदंडों के नामों के साथ क्यूब्स हैं जो आप रिपोर्ट में क्षैतिज या लंबवत रूप से फेंक सकते हैं। यही है, आप तय करते हैं कि कितनी पंक्तियाँ होंगी और कितने कॉलम होंगे।

नीम हकीम लगाओ। एक मानक रिपोर्ट (सकारात्मक परीक्षण, "बस सही" माउस) के बाद हम थोड़ा करने की कोशिश करते हैं:

• 1 कॉलम, 0 पंक्तियाँ;
• 0 कॉलम, 1 पंक्ति;
• 1 कॉलम, 1 पंक्ति।

फिर बहुत कुछ:

• अधिकतम कॉलम, 1 पंक्ति (सभी क्यूब्स को कॉलम में फेंक दिया जाता है);
• अधिकतम पंक्तियों, 1 कॉलम;
• यदि क्यूब्स को दोहराया जा सकता है, तो वहां और वहां अधिकतम करने के लिए, लेकिन यह संदिग्ध है;
• अधिकतम नेस्टेड स्तर (यह तब होता है जब दो अन्य एक एग्रीगेटर कॉलम के अंदर होते हैं)।

अगला, हम इनपुट और आउटपुट डेटा का परीक्षण करते हैं। हम उन्हें किसी भी रिपोर्ट में प्रभावित कर सकते हैं, भले ही कोई रचनाकार न हो और पंक्तियों और स्तंभों की संख्या हमेशा समान हो।


इनपुट डेटा

हमें पता चलता है कि रिपोर्ट कैसे बनती है। मान लीजिए कि हर दिन कुछ डेटा भरा जाता है, कहते हैं, बेची गई पोशाक की संख्या, sundresses, टी-शर्ट। और रिपोर्ट में हम श्रेणियों, रंगों, आकारों द्वारा डेटा का एक समूह देखते हैं। प्रति दिन / महीने / घंटे में कितना बेचा जाता है।

हम एक रिपोर्ट बनाते हैं, और हम स्वयं इनपुट डेटा को प्रभावित करते हैं:

• सामान्य संख्या (प्रति दिन 5 कपड़े, हालांकि बड़े स्थानों पर यह संख्या 2000 या अधिक हो सकती है, आपको यह स्पष्ट करने की आवश्यकता है कि आपके सिस्टम के लिए अधिक सकारात्मक क्या होगा)।
• खाली, प्रति माह 1 आइटम नहीं बेचा / बेचा।
• प्रत्येक उत्पाद की अधिकतम मात्रा, प्रत्येक रंग, प्रत्येक आकार के साथ वॉल्यूम असमान रूप से बड़ा है। हम अधिकतम "गोदाम में झूठ" सेट करते हैं और सब कुछ बेचते हैं: एक महीने या एक दिन के भीतर। रिपोर्टिंग क्या कहेगी?

आउटपुट डेटा

सिद्धांत रूप में, आउटपुट डेटा इनपुट डेटा के साथ संबंधित है। प्रवेश द्वार पर थोड़ा → बाहर निकलने पर थोडा होगा। प्रवेश द्वार पर कई हैं - बाहर निकलने पर कई हैं।

लेकिन यह हमेशा काम नहीं करता है। कभी-कभी इनपुट डेटा को समाप्त किया जा सकता है, या, इसके विपरीत, गुणा किया जा सकता है। और फिर हम किसी तरह इसके साथ खेल सकते हैं।

उदाहरण के लिए, दादत प्रणाली। आप एक फ़ाइल को पूर्ण नाम के एक कॉलम के साथ अपलोड करते हैं, आउटपुट पर आपको कई बार एक साथ मिलता है:

1. मूल नाम, फ़ाइल में क्या था;
2. विघटित नाम (यदि आप बाहर कर सकते हैं);
3. बी लोगों की मृत्यु;
4. तिथियां। लोगों की मृत्यु;
5. बनाएँ। लोगों की मृत्यु;
6. उपनाम;
7. पहला नाम;
8. मध्य नाम;
9. पार्स स्थिति - एक तंत्र द्वारा आश्वस्त मान्यता या किसी व्यक्ति द्वारा सत्यापित;

हमें 9 मिला। एक सेल से। और यह केवल नाम से है, और सिस्टम पते को पार्स भी कर सकता है। वहां, लगभग 50 एक सेल से प्राप्त किए जाते हैं: दानेदार घटकों के अलावा, सभी प्रकार के कोड KLADR, FIAS, OKATO हैं ...

और यहाँ यह दिलचस्प है यह पता चला है कि हमारे पास इनपुट पर बहुत कम डेटा हो सकता है, लेकिन आउटपुट पर बहुत कुछ। और यदि हम कॉलम में अधिकतम जांच करते हैं, तो हमारे पास दो विकल्प हैं:

• आउटपुट पर 500 कॉलम (जो इनपुट पर लगभग 10 पते हैं);
• प्रवेश द्वार पर 500 कॉलम (और बाहर निकलने पर एक पूरा गुच्छा)।

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

और अगर वक्ताओं को बाहर रखा जा सकता है! समतुल्यता वर्ग "शून्य" की जांच करना संभव है जब शून्य आउटपुट पर होता है, तो स्रोत फ़ाइल नॉनम खाली है। आप कम से कम तब जांच सकते हैं जब उन्होंने सौ में से 1 कॉलम छोड़ा हो।

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

मोबाइल ऐप

लिंक

विभिन्न संचार विकल्प हैं:

• सामान्य;
• बहुत अंजीर (छोटा माउस);
• सुपर फास्ट (बड़ा)।

इसके अलावा, खराब संचार आंशिक रूप से हो सकता है: यदि आप सामान्य वाई-फाई और खराब सेलुलर नेटवर्क वाले क्षेत्र में हैं। इंटरनेट अच्छा काम करता है, लेकिन एसएमएस खराब है।

स्मृति की मात्रा

यह भी महत्वपूर्ण है कि आवेदन में कितनी मेमोरी है:

• सामान्य राशि;
• बहुत कम;
• बहुत कुछ।

और अगर इस मामले में इस मामले में पहला और तीसरा परीक्षण संयुक्त हो सकता है, तो छोटा माउस बहुत दिलचस्प है। और अलग-अलग विकल्प हैं:

- फोन पर एप्लिकेशन चलाएं, जिसमें पहले से ही छोटी मेमोरी है;
- स्मृति सामान्य होने पर चलाएं, ढहना, कुछ बड़ा तैनात करना, पहले आवेदन पर लौटने की कोशिश करें।

अब, यदि एप्लिकेशन को यह नहीं पता है कि मेमोरी को सामान्य रूप से कैसे आरक्षित किया जाए, तो दूसरे मामले में यह बस दुर्घटनाग्रस्त हो जाएगा, फिर मेमोरी को पहले ही दबाया गया है।

उपकरण विकर्ण

• मानक (हम बाजार का अध्ययन करते हैं, देखें कि हमारे उपयोगकर्ताओं के बीच क्या अधिक लोकप्रिय है)।
• न्यूनतम (टेलीफोन)।
• अधिकतम (बड़ी गोली)।

स्क्रीन रिज़ॉल्यूशन

• मानक;
• सबसे छोटा;
• सबसे बड़ा;

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

GPX पथ

GPX पथ अनुक्रमिक निर्देशांक के साथ XML फ़ाइलें हैं। उन्हें मोबाइल एमुलेटर पर डाउनलोड किया जा सकता है ताकि फोन को लगे कि यह कुछ गति से अंतरिक्ष में चलता है।

उपयोगी अगर आवेदन पढ़ता है जीपीएस इसके कुछ उद्देश्यों के लिए समन्वय करता है। तो यह स्वयं निर्धारित करता है कि आप जा रहे हैं, दौड़ रहे हैं या सवारी कर रहे हैं। और आप भाग नहीं सकते हैं, बस आवेदन निर्देशांक फ़ीड करें, कार्यालय में बैठते समय उनके पारित होने और परीक्षण के गुणांक निर्धारित करें।

क्या जाँच के लायक हैं? सर्वशास्त्र के अनुसार:

• 1 - सामान्य गुणांक, सरल चलने की जगह;
• 0,01 - जैसे कि आप meeeeeeeeeeeeeeeeeeeee को वैश्विक रूप से खींच रहे हैं
• 200 - भागो भी नहीं, लेकिन उड़ो!

यह सब क्यों जांचा जाना चाहिए? क्या कीड़े मिल सकते हैं?

उदाहरण के लिए, अनुप्रयोग विमान पर दुर्घटनाग्रस्त हो सकता है - यह लॉन्च हुआ, लेकिन यह तुरंत ढह गया। चूंकि यह निर्देशांक पढ़ता है और आपकी गति निर्धारित करने की कोशिश करता है। लेकिन कौन जानता था कि गति 130 से ऊपर होगी?

धीमी गति से, एप्लिकेशन क्रैश हो सकता है। वह खुद को एक लाख मध्यवर्ती अंक निर्धारित करेगा और अपनी स्मृति में उन्हें रखने में सक्षम नहीं होगा। और यह बात है!

यह भी देखें:
GPX पथ क्या हैं और उन्हें परीक्षक की आवश्यकता क्यों है? - gpx रास्तों के बारे में और इस तरह की फ़ाइल का एक उदाहरण

सामान्य उदाहरणों का सारांश

मैं यहाँ दिखाना चाहता हूँ कि ऐसा लगता है कि "बड़ा, छोटा" एक संख्या क्षेत्र है और यह है!
लेकिन वास्तव में, हर जगह mnemonics का उपयोग किया जा सकता है, चाहे वह फाइलें हों, खिलौने हों, रिपोर्ट हों ... और यह वास्तव में हमें कीड़े खोजने में मदद करता है। मेरे अभ्यास से कुछ उदाहरण यहां दिए गए हैं:


लिटिल माउस (निचला बाउंड)

- दिनांक 01/01/1900

जब मैंने फ्रीलान्स पर काम किया, तो इस तारीख ने मेरे लिए सभी रिपोर्टों को बर्बाद कर दिया। क्योंकि भले ही डेवलपर ने मूर्ख से सुरक्षा सेट की हो, उसने 0000 से सुरक्षा सेट की। लेकिन उसने 1900 से सुरक्षा सेट नहीं की।

- एक पंक्ति के अंत में एक अकेला चरित्र।

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

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


बड़ा माउस (ऊपरी बाध्य)

यदि हम एक बड़े माउस के बारे में बात करते हैं, तो आम तौर पर कीड़े की एक अनंत संख्या होती है:
- युद्ध और शांति;
- बहुत सारे डेटा;
- 2 जीबी।

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

बड़े माउस का एक और उदाहरण तनाव परीक्षण है। ओह!मेरे पास ऐसे उदाहरण हैं, इसलिए हम कट्टर जाते हैं।

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

मेरे अभ्यास के उदाहरण हैं

बड़ा चूहा

लिनक्स, ल्यूसीन, मैप

लिनक्स ऑपरेटिंग सिस्टम में खुले फ़ाइल डिस्क्रिप्टर की अधिकतम संख्या के लिए एक सेटिंग है:

• redhat-6 - /etc/security/limits.conf
• redhat-7 - / etc / systemd / system / [सेवा का नाम] .service.d / limit.conf (प्रत्येक सेवा के लिए स्वयं)

फ़ाइलों के साथ किसी भी कार्रवाई के लिए एक फ़ाइल विवरणक खोला जाता है:

• डेटाबेस कनेक्शन बनाएं;
• फ़ाइल पढ़ें;
• एक फ़ाइल के लिए लिखें।
• ...

यदि आपका सिस्टम सक्रिय रूप से फाइलों के साथ काम करता है और कई ऑपरेशन करता है, तो सेटिंग को बढ़ाना होगा। अन्यथा, मामूली भार आपको डाल देगा।

हमारा सिस्टम ल्यूसिन सर्च इंडेक्स का उपयोग करता है। यह तब है जब हम डेटाबेस से कुछ डेटा लेते हैं और इसे डिस्क पर अपलोड करते हैं, ताकि बाद में हम इसे तेजी से खोज सकें। और अगर हम mmap तकनीक का उपयोग करके सूचकांक का निर्माण करते हैं, तो यह सूचकांक के निर्माण के दौरान लिखने के लिए बहुत सारी फाइलें बनाता है।



टेस्ट बेस में आमतौर पर 100 ग्राहक होते हैं, अच्छी तरह से, 1000। ऐसा नहीं है। पुनर्निर्माण समस्याओं के बिना चलता है, भले ही आप विवरणकों को कॉन्फ़िगर न करें।

और वास्तविक प्रणाली में 10+ मिलियन ग्राहक होंगे। और अगर आप वहां फ़ाइल डिस्क्रिप्टर की संख्या को कॉन्फ़िगर नहीं करते हैं, तो जब आप इंडेक्स बनाना शुरू करते हैं, तो सबकुछ बस दुर्घटनाग्रस्त हो जाएगा।

आपको इसके बारे में जानने और तुरंत एक निर्देश लिखने की आवश्यकता है: सर्वर पर ऑपरेटिंग सिस्टम को कॉन्फ़िगर करें, अन्यथा ऐसे और ऐसे परिणाम होंगे। और इसके पक्ष में, डेटा की वास्तविक मात्रा पर न केवल कार्यात्मक परीक्षण करना आवश्यक है, बल्कि तनाव परीक्षण भी करना महत्वपूर्ण है।

रेडहैट 6 ≠ रेडहैट 7

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

क्योंकि अलग-अलग ऑपरेटिंग सिस्टम अलग तरह से काम करते हैं। और हमारे पास ऐसी स्थिति थी कि सब कुछ कॉन्फ़िगर किया गया लगता है, लेकिन सिस्टम क्रैश हो जाता है और कहता है "मेरे पास पर्याप्त खुले फ़ाइल विवरणकर्ता नहीं हैं।" हम कहते हैं:

- पैरामीटर की जाँच करें।
- वह कॉन्फ़िगर किया गया है, सब कुछ आपके निर्देशों के अनुसार है!

ऐसा कैसे? यह पता चला है कि हमारे पास Redhat 6 के लिए निर्देश हैं, और उनके पास Redhat 7 है, जहां सेटिंग बिल्कुल अलग जगह पर है! परिणामस्वरूप, उन्होंने इसे गैर-कार्य निर्देश के अनुसार किया और मानो उन्होंने ऐसा नहीं किया।

इसलिए यदि आप लिनक्स वितरण के विभिन्न संस्करणों के साथ काम कर रहे हैं, तो आपको उन सभी की जांच करने की आवश्यकता है। और न केवल एक मशीन पर सेवाओं को तैनात करें, बल्कि कम से कम एक बार लोड परीक्षण भी करें: सुनिश्चित करें कि सब कुछ काम करता है। आखिरकार, उत्पादन को समझने के बजाय परीक्षण वातावरण में बग को पकड़ना बेहतर होता है।

जावा और कचरा संग्रह

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

वास्तव में नहीं। बहुत सारे एक्सएमएक्स दें - एप्लिकेशन कचरा कलेक्टर पर लटकाएगा ...



और यह उपयोगकर्ता के लिए खुद को अचानक प्रकट करता है। यहां रात में उन्होंने एक बड़ा भार दर्ज किया, बहुत सारा डेटा डाउनलोड किया - विशेष रूप से घंटों के बाद, ताकि किसी को परेशान न करें। सुबह उपयोगकर्ता आता है, जबकि वह सिस्टम के साथ काम करने वाला एकमात्र है, लगभग कोई भार नहीं है, और उस पर सब कुछ लटका हुआ है। और वह समझ भी नहीं पाता कि क्यों।

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

Wildfly

यदि यह तदनुसार कॉन्फ़िगर नहीं है, तो WildFly जावा एप्लिकेशन सर्वर बड़ी फ़ाइलों को डाउनलोड करने की अनुमति नहीं देगा।



हम Jboss एप्लिकेशन सर्वर, उर्फ ​​वाइल्डफ्लाइ का उपयोग करते हैं। और यह पता चला है कि डिफ़ॉल्ट रूप से आप इसके लिए बड़ी फाइलें अपलोड नहीं कर सकते हैं। और हमें याद है कि माउस को बड़ा होना चाहिए। यदि हम 5mb या 50 का परीक्षण करते हैं, तो सब कुछ काम करता है, सब कुछ ठीक है।

लेकिन अगर आप 2GB डाउनलोड करने का प्रयास करते हैं, तो सिस्टम 404 त्रुटि देता है, और आप लॉग से कुछ भी नहीं समझ सकते हैं: आवेदन के लॉग खाली हैं। क्योंकि यह एप्लिकेशन किसी फ़ाइल को डाउनलोड नहीं कर सकता है, Wildfly खुद इसे काटता है।

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

और यहां हम या तो अधिकतम-पोस्ट-आकार के पैरामीटर को बढ़ाकर इसे ठीक करते हैं, या हम प्रतिबंध के बारे में जानकारी देते हैं और इसे काम के विवरण में लिखते हैं।

लॉगिंग

"बड़ा" माउस के परीक्षण के लिए एक और उदाहरण। हाँ, वह किसी भी तरह अधिक उदाहरणों को याद करती है ... अधिक बार नहीं, वह कीड़े पकड़ती है!

मान लें कि हम त्रुटि लॉगिंग की जांच करते हैं। वह त्रुटि लॉग में स्टैक ट्रेस को लिखा है। तो हमने जाँच की, हम महान हैं: हाँ, सब कुछ अच्छा है, सब कुछ दर्ज है! और मैं त्रुटि पाठ पर स्टैक से सब कुछ समझ गया। यदि ग्राहक गिरता है, तो मैं तुरंत समझूंगा कि क्यों।



और अगर हमारी एक गलती नहीं है, लेकिन कई होंगे तो क्या होगा? सब कुछ ठीक है, सब कुछ लॉग इन है, सब कुछ ठीक है! लेकिन हमें याद है कि माउस को बड़ा होना चाहिए:



अगर हमारी गलतियाँ होंगी तो क्या होगा? हमारी बस यही स्थिति थी। स्रोत सिस्टम डेटाबेस में बफर टेबल पर डेटा अपलोड करता है। हमारा सिस्टम इस डेटा को वहां से ले जाता है और किसी तरह उनके साथ काम करता है।

स्रोत प्रणाली दुर्घटनाग्रस्त हो गई और इसने एक गलत वृद्धि को अपलोड किया, जहां सभी डेटा गलत था। हमारे सिस्टम ने वेतन वृद्धि ली, और 13,600 त्रुटियां हैं। और जब जावा ने 13k त्रुटियों के लिए एक स्टैक ट्रेस उत्पन्न करने का प्रयास किया, तो उसने वह सभी मेमोरी खा ली जो उसे आवंटित की गई थी, और फिर कहा "ओह, जावा हीप स्पेस"।

इसे कैसे ठीक करें? हमने लोड कार्य के लिए पैरामीटर मैक्सस्टारराइड (डिफ़ॉल्ट 100) को जोड़ा - अधिकतम एक स्ट्रीम में मेमोरी में संग्रहीत त्रुटियों की संख्या। इस राशि तक पहुंचने पर, त्रुटियों को लॉग किया जाता है और सूची को साफ कर दिया जाता है।

हमने अपने टास्क और क्वार्ज़ रनशेल द्वारा एक कार्य के निष्पादन के बारे में त्रुटि संदेशों के दोहराव को भी हटा दिया, बाद के लॉगिंग स्तर को बढ़ाकर चेतावनी दी है (संदेश जानकारी में प्रदर्शित किया गया है)। नकल के कारण, स्टैक दोगुना हो गया ...

और इस कहानी से निष्कर्ष क्या है? "सिर्फ सही" की जाँच करना पर्याप्त नहीं है। यह एक महत्वपूर्ण और उपयोगी परीक्षण है, हाँ, कोई भी तर्क नहीं देता है। हम देखते हैं कि क्या त्रुटि सिद्धांत में लॉग इन है, जिसमें परीक्षण, आदि। लेकिन तब BIG माउस की जाँच करना बहुत महत्वपूर्ण है। बहुत सारी गलतियाँ होने पर क्या होता है?

और आपको यह समझने की आवश्यकता है कि "बहुत कुछ" - इसका मतलब बहुत कुछ है। यदि आप 10 त्रुटियों की वृद्धि को लोड करते हैं और कहते हैं कि "10 त्रुटियां भी सामान्य हैं, तो सिस्टम सभी स्टैक के निशान दिखाता है", तो ऐसा लगता है जैसे उन्होंने परीक्षण किया था, लेकिन उन्होंने समस्या का खुलासा नहीं किया। यदि हम देखते हैं कि सिस्टम सभी संदेशों को प्रदर्शित करता है, तो हमें पहले से सोचने की आवश्यकता है: यदि उनमें से बहुत सारे हैं तो क्या होगा? और जांच करें।

लिप्यंतरण

यदि आपके पास किसी प्रकार का लिप्यंतरण सिद्धांत है, तो आप जा सकते हैं और यह पता लगाने की कोशिश कर सकते हैं, लेकिन यह अंदर भी कैसे काम करता है? यदि वह दो अक्षरों को एक के रूप में अनुवादित करता है, तो क्या होगा यदि हम तीन अक्षरों या चार समान अक्षरों का परिचय देते हैं?

OO = U
LLC =?



और अगर हम उनमें से बहुत से परिचय करते हैं तो क्या होगा? यह संभव है कि सिस्टम विकल्पों के माध्यम से छंटनी शुरू कर देगा और अनंत पुनरावृत्ति में जाएगा, और फिर बस फ्रीज हो जाएगा। तो जाँच लंबी स्ट्रिंग:

OoooOOOoooOOOooOOOOooOOooOOOoooooOOOoooo

वह रुक जाता है आवेदन कसकर, अगर डेवलपर्स को ध्यान में अंतहीन चक्र विकल्प नहीं लेते हैं "ऊ"

ओरेकल आरएसी

Oracle एक लोकप्रिय डेटाबेस है। Oracle RAC तब होता है जब आपके पास कई डेटाबेस इंस्टेंसेस होते हैं। व्यापार महत्वपूर्ण प्रणालियों के सुचारू संचालन को सुनिश्चित करना आवश्यक है: भले ही एक उदाहरण टूट गया हो, बाकी काम करना जारी रखता है, उपयोगकर्ता को इसके बारे में पता भी नहीं होगा।

यदि आप Oracle RAC का उपयोग करते हैं - तो उस पर लोड परीक्षण करना MANDATORY है। यदि आपके पास यह नहीं है, तो आपको उस ग्राहक से पूछने की जरूरत है, जिसके साथ वह अपनी तरफ से भार उठाने के लिए खड़ा है।

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

यदि लोड परीक्षण नहीं किया जाता है तो क्या होगा? यहाँ जीवन से एक उदाहरण है।

डेटाबेस में एक कॉलम बनाने का अवसर है और कहते हैं कि यह एक ऑटो-इन्क्रीमेंट फ़ील्ड है। इसका मतलब है कि आप इस क्षेत्र को बिल्कुल नहीं भरते हैं; डेटाबेस इसे उत्पन्न करता है। एक नई लाइन है? मैंने "1" मान दर्ज किया। एक और नई लाइन? उसका मान "2" होगा। और प्रत्येक नया मूल्य अधिक से अधिक होगा।

इसलिए, उदाहरण के लिए, पहचानकर्ताओं को उत्पन्न करना बहुत सुविधाजनक है। आप हमेशा जानते हैं कि आपकी आईडी अद्वितीय है। और प्रत्येक नई पंक्ति के लिए यह पिछले एक से अधिक है। सिद्धांत रूप में ...

हमारे सिस्टम में दो इकाई पहचानकर्ता हैं:

• आईडी - एक विशिष्ट संस्करण की पहचानकर्ता, ऑटो-वृद्धि क्षेत्र;
• छिपाना एक ऐतिहासिक पहचानकर्ता है; एक इकाई के लिए यह हमेशा स्थिर होता है और बदलता नहीं है।

नतीजतन, आप एक विशिष्ट संस्करण के अनुसार चयन कर सकते हैं, या आप एक इकाई के छिपने से चुन सकते हैं और इसका पूरा इतिहास देख सकते हैं।

जब एक इकाई बनाई जाती है, तो आईडी = छिपाया जाता है। और फिर आईडी बढ़ता है, यह हमेशा नए संस्करणों के लिए छिपा होता है। इसलिए, संस्करण को निर्धारित करने का सूत्र:

version = (id - hid) + 1

यह नकारात्मक नहीं हो सकता है, क्योंकि आईडी डेटाबेस द्वारा ही बनाई गई है।

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

RAC में, प्रत्येक नोड का अपना कैश है। और ऐसा हो सकता है कि नोड्स के पास एक-दूसरे को सूचित करने का समय नहीं है, और आपके पास टेबलेट में दो बार एक ही संख्या है:

• एक इकाई बनाता है। नोदा कैश में दिखता है, ऑटो-इन्क्रीमेंट फ़ील्ड का अंतिम मूल्य क्या है? हाँ, 10. इसलिए मैं पहचानकर्ता को 11 दूंगा।
• तुरंत, एक नई इकाई दूसरे नोड पर आती है (अनुरोध एक साथ आए और बैलेंसर एक नोड 1 पर, और दूसरा नोड 2 पर फेंक दिया गया)।
• दूसरा नोड इसके कैश में दिखता है, फ़ील्ड का अंतिम मूल्य क्या है? हाँ, 10 (पहला नोड अभी तक दूसरे को सूचित करने में कामयाब नहीं हुआ है कि उसने यह नंबर लिया है)। इसलिए मैं पहचानकर्ता को 11 दूंगा।

कुल हम एक अद्वितीय क्षेत्र का अद्वितीय मूल्य नहीं प्राप्त करते हैं। और आखिरकार, पहचानकर्ताओं के ऐसे चौराहों के भारी भार के साथ, एक या दो भी नहीं होंगे ... यदि आपके पास सभी व्यापारिक तर्क इस तथ्य से बंधे हैं कि आईडी हमेशा अद्वितीय है और हमेशा बढ़ती है, तो यह ओह होगा।

हमारे मामले में, कुछ भी भयावह नहीं हुआ, और ग्राहक के परीक्षण बेंच पर लोड परीक्षण ने मदद की। हमने समस्या को जल्दी पाया, क्योंकि यह निकला था, सिस्टम के नकारात्मक संस्करण जीवन में हस्तक्षेप नहीं करते हैं। लेकिन हमने ऐसे मामलों के लिए, डेटाबेस निर्माण स्क्रिप्ट के लिए अनुक्रमण अनुक्रमण को जोड़ा।

इस कल्पित कहानी का नैतिक यह है - यह उसी हार्डवेयर पर लोड परीक्षण करने के लिए बहुत महत्वपूर्ण है जो PROD में होगा। सब कुछ परिणाम को प्रभावित कर सकता है: ओएस की सेटिंग्स ही, डेटाबेस की सेटिंग्स, हाँ कुछ भी। तुम्हें क्या शक भी नहीं हुआ।

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

छोटा चूहा

खाली जशन

यदि आप खुली एक्सिस लाइब्रेरी का उपयोग करते हैं, तो आवेदन के लिए खाली JSON भेजने का प्रयास करें। वह इसे पूरी तरह से लटका सकता है।

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

वास्तव में, यह बग पहले से ही एक्सिस के नए संस्करण में तय किया गया है। ऐसा लगता है कि सिर्फ उन्नयन, और यह बात है! लेकिन ... सिस्टम शायद ही कभी एक तीसरे पक्ष के पुस्तकालय का उपयोग करता है। आमतौर पर उनमें से कई हैं, वे एक दूसरे के ऊपर बंधे हैं। उन्हें अपडेट करने के लिए, आपको एक बार में सब कुछ अपडेट करने की आवश्यकता है। रिफैक्टरिंग करना आवश्यक है, क्योंकि वे अब अलग तरीके से काम करते हैं। डेवलपर संसाधन आवंटित किए जाने चाहिए।

सामान्य तौर पर, बस लाइब्रेरी संस्करण को अपडेट करने से कभी-कभी एक कूल डेवलपर से पूरी रिलीज होती है। इसलिए, उदाहरण के लिए, जब हम ल्यूसिने के नए संस्करण में चले गए, तो हमने 56 घंटे कार्य पर बिताए, यह 7 मानव-दिन, पूर्णकालिक डेवलपर का एक सप्ताह और प्लस परीक्षण है। कार्य खुद कुछ इस तरह दिखता है, वास्तुकार इसे डालता है:

Lucene। Long / IntegerField के बजाय PointValues ​​का उपयोग करने के लिए स्विच करें

ल्यूसिन माइग्रेशन 5 -> 6 डॉक में प्वाइंटवैल्यूस के पक्ष में लॉन्ग (इंटेगर / डबल) फील्ड छोड़ने के बारे में एक क्लॉज है।

ल्यूसीन 6.3.1 पर स्विच करते समय, मैंने पुराने क्षेत्रों को छोड़ दिया (सभी वर्गों का नाम लिगेसी उपसर्ग के अतिरिक्त के साथ बदल दिया गया था), क्योंकि अनुवाद एक अलग कार्य के लिए खींचता है।

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

बिल्कुल! संक्रमण पीछे संगत होना चाहिए ताकि खोज (कम से कम प्रमुख कार्य) संस्करण के उन्नयन के साथ टूट न जाए। इसे पुराने सूचकांक (पुनर्निर्माण से पहले) पर काम करना चाहिए, और पुनर्निर्माण के बाद (ग्राहक के लिए सुविधाजनक समय पर), नए क्षेत्रों को चुनना चाहिए।

और यह सिर्फ एक पुस्तकालय अद्यतन है! और एक बग के कारण एक पुस्तकालय को छोड़ देना आम तौर पर यह कल्पना करना डरावना है कि इसमें कितना समय लगेगा ...

तो यह बहुत संभव है कि कुछ समय के लिए आप बस एक बग के साथ रहेंगे। उसके बारे में जानें, लेकिन कुछ भी न बदलें। अंत में, "मूर्खतापूर्ण अनुरोध भेजने के लिए कुछ भी नहीं है।"

लेकिन किसी भी मामले में, आपको कम से कम एक बग की उपस्थिति के बारे में पता होना चाहिए। क्योंकि अगर कोई उपयोगकर्ता आपके पास आता है और कहता है, "सब कुछ आप पर लटका हुआ है," तो आपको समझना चाहिए कि क्यों। यह देखते हुए कि लॉग खाली हैं। क्योंकि यह आपका एप्लिकेशन नहीं है, इसलिए JSON रूपांतरण चरण में सब कुछ लटका हुआ है।

यह प्रतीत होता है - एक खाली अनुरोध! और यहां यह हो सकता है ... कि, भले ही आपको पता न हो कि एक्सिस में ऐसा बग है, आप बस खाली JSON, एक खाली SOAP अनुरोध की जांच कर सकते हैं। अंत में, यह एक JSON अनुरोध के संदर्भ में एक शून्य परीक्षण का एक बड़ा उदाहरण है।

शून्य का परीक्षण करना याद रखें। और कम से कम मूल्य थोड़ा माउस है, क्योंकि यह कीड़े भी लाता है, कभी-कभी इतना डरावना।

यह भी देखें:
तुल्यता वर्ग "शून्य-शून्य नहीं" - परीक्षण शून्य के बारे में अधिक

पता क्षेत्र में "मॉस्को"

दादात की सेवा पतों को मानकीकृत करने में सक्षम है - दानेदार घटकों पर एक पंक्ति में पते को बाहर करना + अपार्टमेंट के क्षेत्र को निर्धारित करना, अगर यह निर्देशिका में है।

परीक्षण के दौरान, एक मज़ेदार बग पाया गया - यदि आप पते में "मास्को" शब्द दर्ज करते हैं, तो सिस्टम अपार्टमेंट के क्षेत्र को निर्धारित करता है। हालांकि, ऐसा लगता है, इस "पते" में अपार्टमेंट कहां है?



मुझे लगता है कि यह "छोटे माउस" का एक शानदार उदाहरण है। क्योंकि आमतौर पर क्या जांचा जाता है? सामान्य पता, गली का पता, घर तक ... एक खाली मैदान। कोई भी एकल वर्ण - इसे एक इकाई परीक्षण माना जाता है।

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

और यहां यह अधिक सोचने योग्य है - क्या एक सकारात्मक इकाई है? वहाँ है एक शब्द, ऐसी प्रणाली निर्धारित करेगी। और यहां, भी, विभिन्न समतुल्य कक्षाएं हैं: यह पते (शहर) की शुरुआत से एक शब्द हो सकता है, या यह मध्य (सड़क) से हो सकता है। यह दोनों की कोशिश कर रहा लायक है लेकिन अगर आप अपने आप को केवल "पाठ क्षेत्र में इकाई = एक चरित्र" तक सीमित रखते हैं, तो आपको यह बग कभी नहीं मिलेगा।

कुल मिलाकर

Mnemonic वहाँ एक महान कई है। और उनका उपयोग करना आपकी मदद कर सकता है। क्योंकि आप पहले से ही अपने आवेदन को 10 वीं, 100 वीं बार देख रहे हैं ... आप पहले ही अपनी आँखें खो चुके हैं, आप स्पष्ट त्रुटि को छोड़ सकते हैं। और यदि आप किसी मौजूदा mnemonics लेते हैं, तो एप्लिकेशन को एक नए तरीके से देखें। नए बग का पता लगाने में क्या मदद करेगा।

और यहां तक ​​कि बीएमडब्ल्यू के रूप में इस तरह के एक सरल mnemonics बहुत मदद करता है। लेकिन, ऐसा लगता है ... बड़ा, छोटा, सोचो! सरल सीमा मूल्य। लेकिन उन्हें हमेशा याद किया जाना चाहिए और हमेशा जाँच की जानी चाहिए! यह फल और विभिन्न प्रकार के कीड़े लाता है।

अपने उदाहरणों का उपयोग करते हुए, मैं यह दिखाना चाहता था कि आप न केवल किसी पाठ या संख्यात्मक क्षेत्र में सीमाओं की खोज कर सकते हैं। Mnemonics हर जगह काम करता है: Oracle RAC, Java, Wildfly, कहीं भी! "युद्ध और शांति को पाठ बॉक्स में प्रवेश करना" की सामान्य समझ से परे सीमाओं को देखना सीखें।

बेशक, मुख्य जोर "बड़े माउस" पर है, यह सबसे अधिक कीड़े लाता है। यह वास्तव में ऐसे मामले हैं जिन्हें याद किया जाता है जब आपको लगता है कि आप अपनी परियोजना पर मिले हैं।

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

सीमाएं बहुत महत्वपूर्ण हैं। उनका परीक्षण करना याद रखें। मुझे आशा है कि मेरे उदाहरण आपको प्रेरित करते हैं, और समतुल्यता वर्गों को उजागर करते समय बीएमडब्ल्यू mnemonics हमेशा मेरे सिर में पॉप जाएगा।



या हो सकता है कि आप अपने स्वयं के mnemonics के साथ आएंगे। जो आपके लिए, आपकी टीम के लिए, आपकी सुविधाओं के लिए, आपकी प्रक्रियाओं के लिए होगा। और यह बहुत अच्छा है, यह सफलता भी है। मुख्य बात यह है कि यह मदद करता है!

PS मेरी किताब से शुरुआती परीक्षकों के लिए एक अंश है। मैंने SQA डेज़, यहाँ वीडियो पर एक रिपोर्ट में mnemonics के बारे में भी बात की।