નફો:
- AI સાથે અર્થપૂર્ણ નિવેદન સાથે એકમ, એકીકરણ અને ધાર કેસ પરીક્ષણો ઉત્પન્ન કરવાની ક્ષમતા
- AI સપોર્ટ સાથે ટેસ્ટ કવરેજ, મર્યાદા મૂલ્યો અને નકારાત્મક દૃશ્યોને વ્યવસ્થિત રીતે કાઢવાની ક્ષમતા
- AI દ્વારા ઉત્પાદિત પરીક્ષણો ખરેખર વર્તનને ચકાસે છે તે ચકાસવાની ક્ષમતા અને માત્ર હાલના કોડનું પુનરાવર્તન કરતા નથી
પરીક્ષણ એ એક પદ્ધતિ છે જે સાબિત કરે છે કે સોફ્ટવેર ખરેખર વચન મુજબ વર્તે છે. એક સારો ટેસ્ટ સ્યુટ તમને સેકન્ડોમાં જણાવે છે કે શું ફેરફાર કંઈક તોડે છે અને એન્જિનિયરને આત્મવિશ્વાસ સાથે કામ કરવાની સ્વતંત્રતા આપે છે. AI પરીક્ષણ લેખનના સૌથી કંટાળાજનક અને સૌથી વધુ અવગણવામાં આવેલા ભાગને ઝડપી બનાવે છે: ઘણા બધા દૃશ્યો, બ્રેકપોઇન્ટ્સ અને નકારાત્મક કેસોનું સર્જન કરે છે. પરંતુ અહીં એક સ્નીકી ટ્રેપ છે: AI પરીક્ષણો લખી શકે છે જે કોડની વર્તમાન (કદાચ ખામીયુક્ત) વર્તણૂકને ચકાસે છે, તેના માનવામાં આવતા વર્તનને નહીં; અથવા તે ખાલી પરીક્ષણો ઉત્પન્ન કરી શકે છે જે હંમેશા પાસ થાય છે, વાસ્તવમાં કંઈપણ તપાસતા નથી. પરીક્ષણનું મૂલ્ય તે પાસ થાય છે કે કેમ તેમાં નથી, પરંતુ તે યોગ્ય વસ્તુ માટે તપાસે છે કે કેમ અને જ્યારે તે ખોટું છે ત્યારે લાલ થાય છે.
આ એકમમાં, તમે અર્થપૂર્ણ નિવેદનો સાથે એકમ, એકીકરણ અને ધાર કેસ પરીક્ષણો કેવી રીતે બનાવવી તે શીખી શકશો; ટેસ્ટ કવરેજ, બ્રેકપોઇન્ટ્સ અને ડાઉનસાઇડ દૃશ્યોને વ્યવસ્થિત રીતે કેવી રીતે બહાર કાઢવું; અને અમે જોઈશું કે તમે કેવી રીતે તપાસ કરી શકો છો કે AI જે પરીક્ષણો બનાવે છે તે ખરેખર વર્તનને માન્ય કરે છે.
વિભાવનાઓ: એકમ પરીક્ષણ: એકલ કાર્ય/વર્ગને અલગતામાં પરીક્ષણ કરે છે. એકીકરણ પરીક્ષણ: પરીક્ષણો કે બહુવિધ ભાગો એકસાથે યોગ્ય રીતે કાર્ય કરે છે. ભારપૂર્વક: એક નિવેદન જે ચકાસે છે કે પરિણામ અપેક્ષિત હતું તે બરાબર છે; આ પરીક્ષાનું હૃદય છે. કવરેજ: કોડનો કેટલો ભાગ પરીક્ષણો દ્વારા ચલાવવામાં આવે છે; ઉચ્ચ કવરેજ ગુણવત્તાની બાંયધરી આપતું નથી.
અર્થપૂર્ણ પરીક્ષણોનું ઉત્પાદન
સારી કસોટી સ્પષ્ટ રીતે ત્રણ બાબતો કરે છે: તે એક સ્થિતિ સ્થાપિત કરે છે, તે ક્રિયા કરે છે, તે પરિણામની ખાતરી આપે છે. AI પર પરીક્ષણો છાપતી વખતે, તમે કઈ વર્તણૂકને ચકાસવા માંગો છો અને તે કયા દૃશ્યોને આવરી લેવું જોઈએ તે સ્પષ્ટ કરો; નહિંતર, તે સુપરફિસિયલ પરીક્ષણો ઉત્પન્ન કરે છે જે હંમેશા પસાર થાય છે.
- ચકાસવા માટેના વર્તનને વ્યાખ્યાયિત કરો. "શું યોગ્ય ગણાય છે?" પ્રશ્નનો સ્પષ્ટ જવાબ આપો.
- દૃશ્ય પ્રકારો માટે પૂછો. સામાન્ય, મર્યાદા, નકારાત્મક, ભૂલની સ્થિતિ.
- અર્થપૂર્ણ ભારપૂર્વક આયાત કરો. તે માત્ર "એક ભૂલ ફેંકી" નથી, તે "સાચી કિંમત પરત કરે છે".
- પરીક્ષણની ચોકસાઈ તપાસો. જ્યારે તમે સભાનપણે કોડ ભંગ કરો છો ત્યારે શું પરીક્ષણ લાલ થઈ જાય છે?
વ્યાપક ટેસ્ટ જનરેશન પ્રોમ્પ્ટ: "નીચેની 'એપ્લાયડિસ્કાઉન્ટ(રકમ, કૂપન)' ફંક્શન માટે એકમ પરીક્ષણો લખો. નીચેની કેટેગરીમાં ઓછામાં ઓછું એક દૃશ્ય રાખો: (1) સામાન્ય માન્ય કૂપન, (2) બ્રેકપોઇન્ટ્સ (0 રકમ, 100% ડિસ્કાઉન્ટ), (3) નકારાત્મક (અમાન્ય રકમ) (અમાન્ય રકમ પર) (4) નેગેટિવ (અમાન્ય રકમ) તરીકે દાખલ કરો. દરેક કસોટીમાં કોંક્રીટીનું અપેક્ષિત મૂલ્ય (માત્ર 'કામ કર્યું' નથી)
બાઉન્ડ્રી મૂલ્ય નિષ્કર્ષણ પ્રોમ્પ્ટ: "આ ફંક્શનના ઇનપુટ્સ માટે સીમા મૂલ્ય વિશ્લેષણ કરો. દરેક પરિમાણ માટે, ટેબલ તરીકે 'ફક્ત સીમા પર', 'સીમાની બરાબર નીચે', 'સીમાની બરાબર ઉપર' મૂલ્યોને બહાર કાઢો. પછી આ સીમાઓને આવરી લેતા પરીક્ષણ દૃશ્યોની સૂચિ બનાવો. માત્ર કોડના રૂપરેખા લખો, માત્ર કોડ અને ફંકશન લખો નહીં. [સહી]"
સાવધાન: ઉચ્ચ પરીક્ષણ કવરેજ (દા.ત. 90%) સાબિત કરતું નથી કે કોડ સાચો છે. કવરેજ માપે છે કે કેટલી પંક્તિઓ ચલાવવામાં આવી હતી; એવું નથી કે તે રેખાઓ યોગ્ય પરિણામ આપે છે. અર્થપૂર્ણ દાવા વિનાનું પરીક્ષણ કવરેજમાં વધારો કરે છે પરંતુ કંઈપણ ગેરંટી આપતું નથી. નિવેદનની સામગ્રી ગુણવત્તા નક્કી કરે છે, નિવેદનોની સંખ્યા નહીં.
ટેસ્ટિંગ ઇટસેલ્ફ: ધ લોજિક ઓફ મ્યુટેશન
એઆઈ-જનરેટેડ ટેસ્ટ વાસ્તવમાં કામ કરે છે કે કેમ તે સમજવાની સૌથી વ્યવહારુ રીત એ કોડ (પરિવર્તન પરીક્ષણ તર્ક) ને જાણી જોઈને તોડવાનો છે. શરત ઉલટાવી, + ચિહ્ન બનાવો -; જો કોઈ પરીક્ષણો લાલ ન થાય, તો તમારા પરીક્ષણો ખરેખર તે વર્તનને જાળવી રાખતા નથી.
પરીક્ષણ નબળાઈ શિકાર પ્રોમ્પ્ટ: "મને જણાવો કે આ કોડમાં કઈ સંભવિત ભૂલો નીચેના પરીક્ષણો પકડી શકશે નહીં. કોડમાં કરી શકાય તેવા 5 નાના પરિવર્તન સૂચવો (દા.ત. >=ને બદલે >, - + ની જગ્યાએ) અને દરેક માટે સૂચવો કે શું હાલના પરીક્ષણો તેને પકડશે કે કેમ. જેઓ પકડાયા નથી, તેમના માટે પરીક્ષણ સૂચવો કે જે [code:] ઉમેરવું જોઈએ.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા: "આ કાર્ય માટે એક પરીક્ષણ લખો." (પરિણામ: સામાન્ય રીતે એક સુખદ દૃશ્ય, નબળું નિવેદન; ભૂલો ચૂકી જાય છે.) સ્ટ્રોંગ: "આ 'પાસવર્ડસ્ટ્રોંગ' ફંક્શન માટે એક પરીક્ષણ લખો. નિયમ: ઓછામાં ઓછા 8 અક્ષરો, 1 અપરકેસ અક્ષર, 1 અંક જરૂરી છે. નીચેના દૃશ્યોને અલગ પરીક્ષણો તરીકે આવરી લો: બરાબર 8 અક્ષરો (મર્યાદા), 7 અક્ષરો, ઓછા અક્ષરો, 7 અક્ષરો નહીં ખાલી સ્ટ્રિંગ, માત્ર ખાલી જગ્યાઓ, ખૂબ લાંબી (1000 અક્ષરો) દરેક ટેસ્ટમાં અપેક્ષિત સાચું/ખોટું મૂલ્ય સ્પષ્ટપણે જણાવો અને તે જે તપાસે છે તેના આધારે પરીક્ષણને નામ આપો."
શક્તિશાળી પ્રોમ્પ્ટ નિયમો અને સંપૂર્ણ સીમાના દૃશ્યો આપે છે. "બરાબર 8 / 7 અક્ષરો" જેવી સીમા જોડી ભૂલો કરવા માટે સૌથી સામાન્ય સ્થાનો છે (ગૂંચવણમાં મૂકે છે > સાથે >=). નબળા પ્રોમ્પ્ટ આ સીમાઓને બાયપાસ કરે છે અને ઉત્પાદનમાં ભૂલને વહન કરે છે.
ટેસ્ટના પ્રકારો અને ક્યાં ઉપયોગ કરવો
ટેસ્ટ પ્રકાર
તે શું પુષ્ટિ કરે છે?
AI યોગદાન
ધ્યાન
એકમ
સિંગલ ફંક્શન/વર્ગ
બહુ-દૃશ્યોને ઝડપથી જનરેટ કરે છે
અર્થપૂર્ણ નિવેદન જરૂરી છે
એકીકરણ
ભાગો એકસાથે કામ કરે છે
દૃશ્ય અને મોક ડેટા ડ્રાફ્ટ
સાચું વ્યસન વર્તન
અંત/સ્વીકારો
સમગ્ર વપરાશકર્તા પ્રવાહ
પગલાઓની સૂચિ અને અપેક્ષા
બરડપણું માટે સંવેદનશીલ
રીગ્રેશન
જૂની ભૂલ પરત આવતી નથી
ખામી ચોક્કસ પરીક્ષણ
દરેક ફિક્સમાં ઉમેરવું જોઈએ
મીની કેસો
કેસ 1 - પરીક્ષા જે હંમેશા પાસ થાય છે. AI કાર્ય માટે 12 પરીક્ષણો લખે છે અને તે બધા પાસ થાય છે. ઇજનેર શંકાસ્પદ બને છે અને ઇરાદાપૂર્વક કાર્યના વળતર મૂલ્યને વિકૃત કરે છે; માત્ર 3 પરીક્ષણો લાલ થાય છે. અન્ય 9 પરીક્ષણોમાં અર્થપૂર્ણ નિવેદનો નથી. પરિવર્તન શિકાર દ્વારા પરીક્ષણને મજબૂત બનાવવામાં આવે છે; વાસ્તવિક સુરક્ષા 9 પરિસ્થિતિઓમાં પ્રાપ્ત થાય છે.
કેસ 2 - સીમા ભૂલ. વય ચકાસણી કાર્ય "18 અને તેથી વધુ માન્ય છે" કહેવું જોઈએ પરંતુ >18 લખાયેલું છે, એટલે કે 18 વર્ષની વય નકારી છે. ભૂલ પરીક્ષણમાં તરત જ દેખાય છે કારણ કે AI બ્રેકપોઇન્ટ વિશ્લેષણ દ્વારા "બરાબર 18" દૃશ્ય જનરેટ કરે છે. એક મર્યાદા પરીક્ષણ કોઈપણ વાસ્તવિક વપરાશકર્તા ફરિયાદોને અટકાવે છે.
કેસ 3 - વર્તમાન વર્તનને ઠીક કરવું. જ્યારે AI ને "આ કોડના આધારે ટેસ્ટ લખવાનું" કહેવામાં આવે છે, ત્યારે તે એક પરીક્ષણ ઉત્પન્ન કરે છે જે કોડમાં પહેલેથી જ અસ્તિત્વમાં રહેલી રાઉન્ડિંગ ભૂલને "સાચી" તરીકે સ્વીકારે છે. જ્યારે ઈજનેર જરૂરીયાત (અપેક્ષિત સાચી કિંમત) અનુસાર ટેસ્ટ પ્રિન્ટ કરે છે અને કોડ નહીં, ત્યારે ટેસ્ટ લાલ થઈ જાય છે અને વાસ્તવિક ભૂલ થાય છે. પરીક્ષણો કોડમાંથી નહીં, અપેક્ષામાંથી મેળવવામાં આવવી જોઈએ.
સામાન્ય ભૂલો
- અર્થહીન દાવો. "એક ભૂલ ફેંકી નથી" પૂરતું નથી; સાચું મૂલ્ય ચકાસવું આવશ્યક છે.
- ગુણવત્તા સાથે ગૂંચવણભરી અવકાશ. ઉચ્ચ કવરેજ ચોક્કસ પરિણામોની કોઈ ગેરંટી નથી.
- કોડ દ્વારા ટેસ્ટ પ્રિન્ટીંગ. વર્તમાન ભૂલને "સાચી" પર સુધારે છે; કસોટીઓ અપેક્ષાઓમાંથી મેળવવી જોઈએ.
- મર્યાદા મૂલ્યોને છોડી દેવા. મૂંઝવણ > સાથે >= એ સૌથી સામાન્ય ભૂલ છે; સીમા જોડીનું પરીક્ષણ કરવું આવશ્યક છે.
- ટેસ્ટનું જ ઓડિટ નથી. જ્યારે તમે કોડ તોડશો ત્યારે લાલ ન થાય તે પરીક્ષણ સુરક્ષા પ્રદાન કરતું નથી.
સારાંશમાં
એક સારો ટેસ્ટિંગ સ્યુટ એ આત્મવિશ્વાસ સાથે ફેરફારો કરવાની ચાવી છે. AI ઝડપથી દૃશ્યો, સીમાઓ અને નકારાત્મક પરિસ્થિતિઓનો સમૂહ પેદા કરે છે; પરંતુ જો તે આવશ્યકતાઓને બદલે કોડમાંથી પરીક્ષણો મેળવે છે, તો તે હાલની ભૂલોને ઠીક કરી શકે છે અથવા હંમેશા પાસ થતા અર્થહીન પરીક્ષણો લખી શકે છે. દરેક કસોટીમાં ચોક્કસ અપેક્ષિત મૂલ્યની ખાતરી કરો, બાઉન્ડ જોડીનો સમાવેશ કરો અને ચકાસો કે તમારા પરીક્ષણો ખરેખર કોડને તોડીને સુરક્ષિત કરે છે. દાવાની સામગ્રી, સ્કોપ્સની સંખ્યા નહીં, ગુણવત્તા નક્કી કરે છે.
એપ્લિકેશન કાર્ય
ફંક્શન પસંદ કરો અને તેને ચાર શ્રેણીઓમાં પરીક્ષણો જનરેટ કરો (સામાન્ય, મર્યાદા, નકારાત્મક, ભૂલ) વ્યાપક પરીક્ષણ જનરેશન પ્રોમ્પ્ટ સાથે; દરેક કસોટીમાં નિશ્ચિત અપેક્ષિત મૂલ્ય ભારપૂર્વક જણાવો. પછી પરીક્ષણ નબળાઈ શિકાર પ્રોમ્પ્ટ ચલાવો, કોડમાં 5 નાના મ્યુટેશન સૂચવો, અને તેઓ કયાને પકડે છે તે ચકાસવા માટે પરીક્ષણો ચલાવો. ઓછામાં ઓછા એક પરિવર્તન માટે એક નવું પરીક્ષણ ઉમેરો જે પકડાયું ન હતું અને બતાવો કે તે હવે લાલમાં છે.
ચેકલિસ્ટ
- [ ] મેં અપેક્ષિત/સાચા વર્તનના આધારે પરીક્ષણો છાપ્યા, કોડના નહીં.
- [ ] મેં સામાન્ય, મર્યાદા, નકારાત્મક અને ભૂલના દૃશ્યોને આવરી લીધાં છે.
- [ ] મેં દરેક કસોટીમાં નક્કર અપેક્ષિત મૂલ્ય ભારપૂર્વક જણાવ્યું હતું.
- [ ] મેં બોર્ડર જોડીનું પરીક્ષણ કર્યું (ફક્ત ઉપર-નીચે / ફક્ત ઉપર-નીચે).
- [ ] ઇરાદાપૂર્વક કોડ તોડીને, મેં પુષ્ટિ કરી કે પરીક્ષણો લાલ થઈ ગયા છે.
- [ ] મેં વણશોધાયેલા પરિવર્તન માટે એક નવો ટેસ્ટ ઉમેર્યો છે.