සමච්චල් කිරීම සහ මුරණ්ඩුකම අතර වෙනස කුමක්ද?

මාටින් ෆෝලර්ගේ මොක්ස් අරන්ට් ස්ටබ්ස් ද ඇතුළුව, පරීක්ෂාවට ලක් කිරීම හා සමච්චල් කිරීම පිළිබඳව මම විවිධ ලිපි කියවා ඇත්තෙමි , නමුත් තවමත් වෙනස තේරෙන්නේ නැත.

ස්ටබ්

මම විශ්වාස කරන්නේ ලොකුම වෙනස නම් ඔබ දැනටමත් කලින් නියම කර ඇති හැසිරීමකින් ලියා ඇති මිටියක් බවයි. එබැවින් ඔබ පරීක්ෂණ අරමුණු සඳහා ව්‍යාජ වන පරායත්තතාව (වියුක්ත පංතිය හෝ අතුරුමුහුණත) ක්‍රියාත්මක කරන පන්තියක් ඔබට ඇති අතර ක්‍රමවේදයන් නිශ්චිත ප්‍රතිචාර වලින් මුළා වනු ඇත. ඔවුන් මනස්කාන්ත කිසිවක් නොකරන අතර ඔබේ පරීක්ෂණයෙන් පිටත ඔබ ඒ සඳහා මුරණ්ඩු කේතය දැනටමත් ලියා තිබුණි.

සමච්චල් කරන්න

විහිළුවක් යනු ඔබේ පරීක්ෂණයේ කොටසක් ලෙස ඔබේ අපේක්ෂාවන් සමඟ සැකසිය යුතු දෙයකි. විහිළුවක් කලින් තීරණය කළ ආකාරයට සකසා නැති නිසා ඔබේ පරීක්ෂණයෙහි එය සිදු කරන කේතයක් ඔබට ඇත. යම් ආකාරයකින් විහිළු ක්‍රියාත්මක වන වේලාවේදී තීරණය වන්නේ අපේක්ෂාවන් සැකසෙන කේතය ඕනෑම දෙයක් කිරීමට පෙර ක්‍රියාත්මක විය යුතු බැවිනි.

මොක්ස් සහ ස්ටබ් අතර වෙනස

විහිළු සමඟ ලියා ඇති පරීක්ෂණ සාමාන්‍යයෙන් initialize -> set expectations -> exercise -> verifyපරීක්ෂණ සඳහා රටාවක් අනුගමනය කරයි . කලින් ලියා ඇති කඳ කොටස අනුගමනය කරනු ඇත initialize -> exercise -> verify.

මොක්ස් සහ ස්ටබ් අතර සමානකම

දෙකෙහිම පරමාර්ථය වන්නේ පන්තියක හෝ ශ්‍රිතයක සියලු පරායත්තතාවයන් පරීක්ෂා කිරීම තුරන් කිරීමයි, එවිට ඔබේ පරීක්ෂණ ඔවුන් ඔප්පු කිරීමට උත්සාහ කරන දෙය කෙරෙහි වැඩි අවධානයක් හා සරල වේ.

පෙරවදන

වස්තූන් පිළිබඳ අර්ථකථන කිහිපයක් ඇත, ඒවා සැබෑ නොවේ. සාමාන්‍ය පදය පරීක්ෂණ ද්විත්ව වේ. මෙම පදය ඇතුළත් වේ: ව්‍යාජ , ව්‍යාජ , මුරණ්ඩු , සමච්චල් .

යොමුව

අනුව මාටින් ලතා ලිපිය :

• ව්‍යාජ වස්තූන් පසුකර ගිය නමුත් ඇත්ත වශයෙන්ම භාවිතා නොවේ. සාමාන්‍යයෙන් ඒවා පරාමිති ලැයිස්තු පිරවීම සඳහා භාවිතා කරයි.
• ව්යාජ වස්තූන් ඇත්ත වශයෙන්ම ක්රියාත්මක කිරීමේ ක්රියාත්මක කිරීම් ඇත, නමුත් සාමාන්යයෙන් කෙටිමඟක් ගෙන ඒවා නිෂ්පාදනයට නුසුදුසු වේ (මතක දත්ත ගබඩාවක් හොඳ උදාහරණයකි).
• පරීක්ෂණය අතරතුරදී කරන ලද ඇමතුම් සඳහා ස්ටබ්ස් ටින් කළ පිළිතුරු සපයයි, සාමාන්‍යයෙන් පරීක්ෂණය සඳහා වැඩසටහන්ගත කර ඇති දේට පිටින් කිසිවක් ප්‍රතිචාර නොදක්වයි. ඊ-තැපැල් ගේට්වේ ස්ටබ් වැනි ඇමතුම් පිළිබඳ තොරතුරු පටිගත කළ හැකිය, එය 'එවන ලද' පණිවිඩ මතක තබා ගත හැකිය, නැතහොත් එය 'යැවූ' පණිවිඩ ගණන පමණි.
• විහිළු යනු අප මෙහි කතා කරන්නේ: අපේක්ෂාවන් සමඟ පූර්ව වැඩසටහන්ගත කර ඇති වස්තූන්, ඔවුන්ට ලැබීමට අපේක්ෂා කරන ඇමතුම්වල පිරිවිතරයක් සාදයි.

විලාසය

මොක්ස් එදිරිව ස්ටබ්ස් = චර්යාත්මක පරීක්ෂණ එදිරිව රාජ්‍ය පරීක්ෂාව

මූලධර්මය

ටෙස්ට් මූලධර්මයට අනුව , එක් පරීක්ෂණයකට එක් දෙයක් පමණක් තිබිය හැකි අතර, එක් පරීක්ෂණයක දී මුරණ්ඩු කිහිපයක් තිබිය හැකි නමුත් සාමාන්‍යයෙන් ඇත්තේ එක් විහිළුවක් පමණි.

ජීවන චක්රය

මුරණ්ඩු සමඟ ජීවන චක්‍රය පරීක්ෂා කරන්න:

1. සැකසුම - පරීක්ෂා කරනු ලබන වස්තුව සහ එහි මුරණ්ඩු සහකරුවන් සූදානම් කරන්න.
2. ව්යායාම - ක්රියාකාරිත්වය පරීක්ෂා කරන්න.
3. තත්වය සත්‍යාපනය කරන්න - වස්තුවේ තත්වය පරීක්ෂා කිරීම සඳහා ප්‍රකාශ භාවිතා කරන්න.
4. කඳුළු සැලීම - සම්පත් පිරිසිදු කිරීම.

විහිළු සහිත ජීවන චක්‍රය පරීක්ෂා කරන්න:

1. දත්ත සැකසීම - පරීක්ෂා කරනු ලබන වස්තුව සකස් කරන්න.
2. අපේක්ෂාවන් සැකසීම - ප්‍රාථමික වස්තුව විසින් භාවිතා කරනු ලබන සමච්චලයට අපේක්ෂාවන් සකස් කරන්න.
3. ව්යායාම - ක්රියාකාරිත්වය පරීක්ෂා කරන්න.
4. අපේක්ෂාවන් සත්‍යාපනය කරන්න - සරදමට සරදම් ක්‍රම භාවිතා කර ඇති බව තහවුරු කරන්න.
5. තත්වය සත්‍යාපනය කරන්න - වස්තුවේ තත්වය පරීක්ෂා කිරීම සඳහා ප්‍රකාශ භාවිතා කරන්න.
6. කඳුළු සැලීම - සම්පත් පිරිසිදු කිරීම.

සාරාංශය

සමච්චල් කිරීම සහ මුරණ්ඩු පරීක්ෂාව යන දෙකම ප්‍රශ්නයට පිළිතුරක් ලබා දෙයි: ප්‍රති result ලය කුමක්ද?

සමච්චල් කිරීම සමඟ පරීක්ෂා කිරීම ද උනන්දු වේ: ප්‍රති result ලය ලබා ඇත්තේ කෙසේද?

මුරණ්ඩු යනු සරල ව්‍යාජ වස්තුවකි. එමඟින් පරීක්ෂණය සුමටව සිදුවන බව සහතික කරයි.
සමච්චල් කිරීම යනු වඩා හොඳ කඳකි. ඔබගේ පරීක්ෂණය ඒ හරහා ගමන් කරන බව ඔබ සත්‍යාපනය කරයි.

මෙන්න සැබෑ ලෝක නියැදිය සමඟ එක් එක් විස්තරය.

• ආදර්ශ - පිනවීම පමණක් ව්යාජ වටිනාකම් API.

  උදාහරණය : ඔබේ පරීක්ෂණයට කිසිදු බලපෑමක් නොකරන ඉදිකිරීම්කරුවෙකු තුළ අනිවාර්ය පරාමිතීන් අවශ්‍ය වන පන්තියක ක්‍රමයක් ඔබ පරීක්ෂා කරන්නේ නම් , එවිට ඔබට පන්තියක නව අවස්ථා නිර්මාණය කිරීම සඳහා ව්‍යාජ වස්තු නිර්මාණය කළ හැකිය.

• ව්‍යාජ - සමහර බාහිර යටිතල පහසුකම් මත යැපීමක් ඇති පන්තියක පරීක්ෂණ ක්‍රියාත්මක කිරීමක් සාදන්න. (ඔබේ ඒකක පරීක්ෂණය ඇත්ත වශයෙන්ම බාහිර යටිතල පහසුකම් සමඟ අන්තර්ක්‍රියා නොකිරීම හොඳ පුරුද්දකි .)

  උදාහරණය : දත්ත සමුදායකට ප්‍රවේශ වීම සඳහා ව්‍යාජ ක්‍රියාත්මක කිරීමක් සාදන්න, එය in-memoryඑකතු කිරීම වෙනුවට ආදේශ කරන්න .

• ජෛව තොරතුරු විද්යාව - අභිබවා ක්රම ද ලෙස සඳහන් දෘඪ-කේතනය සාරධර්ම, ආපසු state-based.

  උදාහරණය : ඔබේ පරීක්ෂණ පන්තිය රඳා පවතින්නේ Calculate()සම්පූර්ණ කිරීමට මිනිත්තු 5 ක් ගතවන ක්‍රමයක් මතය . මිනිත්තු 5 ක් බලා සිටීම වෙනුවට, ඔබට එහි සැබෑ ක්‍රියාත්මක කිරීම දෘඩ කේත අගයන් ලබා දෙන මුරණ්ඩු ආදේශ කළ හැකිය; ගත කරන්නේ ඉතා සුළු කාලයකි.

• ව්යාජ - ඉතා සමාන Stubනමුත් interaction-basedරාජ්ය පදනම් කරගත් වඩා. මෙයින් අදහස් කරන්නේ ඔබ Mockයම් වටිනාකමක් ලබා දෙනු ඇතැයි අපේක්ෂා නොකරන නමුත් නිශ්චිත ක්‍රම ඇමතුම් පිළිවෙලක් කර ඇති බව උපකල්පනය කිරීමයි.

  උදාහරණය: ඔබ පරිශීලක ලියාපදිංචි පන්තියක් පරීක්ෂා කරමින් සිටී. ඇමතීමෙන් පසු Saveඑය ඇමතිය යුතුය SendConfirmationEmail.

Stubsහා Mocksසත්ය වශයෙන්ම උප වර්ග Mockපරීක්ෂණය ක්රියාත්මක කිරීම සමග හුවමාරු සැබෑ ක්රියාත්මක කිරීම යන දෙකම, නමුත්, විවිධ, විශේෂ හේතු සඳහා.

තුළ codeschool.com පාඨමාලාව, Zombies සඳහා රේල් පීලි පරීක්ෂණ , ඔවුන් කොන්දේසි මෙම අර්ථ දැක්වීම දෙන්න:

ස්ටබ්

නිශ්චිත ප්‍රති .ලයක් ලබා දෙන කේතයක් සමඟ ක්‍රමයක් ප්‍රතිස්ථාපනය කිරීම සඳහා.

සමච්චල් කරන්න

ක්‍රමවේදය කැඳවන බවට ප්‍රකාශයක් සහිත කඳක්.

ෂෝන් කෝපන්හේවර් ඔහුගේ පිළිතුරෙහි විස්තර කර ඇති පරිදි, වෙනස වන්නේ සමච්චල් කිරීම අපේක්ෂාවන් සැකසීමයි (එනම්, ඔවුන් කැඳවන්නේද නැද්ද යන්න පිළිබඳව ප්‍රකාශ කිරීම).

ස්ටබ්ස් ඔබේ පරීක්ෂණ අසමත් නොවේ, සමච්චල් කළ හැකිය.

මෙම ප්‍රශ්නයට සරලම හා පැහැදිලි පිළිතුර රෝයි ඔෂෙරෝව් විසින් රචිත The Art of Unit Testing (පිටුව 85)

අපි කඳක් සමඟ ගනුදෙනු කරන බව පැවසීමට ඇති පහසුම ක්‍රමය නම්, කඳට කිසි විටෙකත් පරීක්ෂණයෙන් අසමත් විය නොහැකි බව දැකීමයි. පරීක්ෂණ භාවිතය සැමවිටම පරීක්ෂණයට ලක්වන පන්තියට විරුද්ධ බව ප්‍රකාශ කරයි.

අනෙක් අතට, පරීක්ෂණය අසමත් ද නැද්ද යන්න තහවුරු කර ගැනීම සඳහා පරීක්ෂණය ව්‍යාජ වස්තුවක් භාවිතා කරයි. [...]

නැවතත්, ව්‍යාජ වස්තුව යනු පරීක්ෂණය අසමත් ද නැද්ද යන්න බැලීමට අප භාවිතා කරන වස්තුවයි.

එයින් අදහස් වන්නේ ඔබ ව්‍යාජයට එරෙහිව ප්‍රකාශ කරන්නේ නම් එයින් අදහස් කරන්නේ ඔබ ව්‍යාජය විහිළුවක් ලෙස භාවිතා කරන බවයි, ඔබ ව්‍යාජය භාවිතා කරන්නේ නම් ඒ පිළිබඳව කිසිදු ප්‍රකාශයක් නොමැතිව පරීක්ෂණය ක්‍රියාත්මක කිරීමට පමණක් නම් ඔබ ව්‍යාජය මුරණ්ඩු ලෙස භාවිතා කරයි.

ඉහත සියලු පැහැදිලි කිරීම් කියවා, ense නීභවනය කිරීමට උත්සාහ කරමි:

• ස්ටබ් : පරීක්ෂණය ක්‍රියාත්මක කිරීමට ඉඩ දෙන ව්‍යාජ කේත කෑල්ලක්, නමුත් එයට කුමක් සිදුවේදැයි ඔබ ගණන් ගන්නේ නැත.
• විහිළුව : පරීක්ෂණයේ කොටසක් ලෙස ඔබ සත්‍යාපනය කර ඇති ව්‍යාජ කේත කැබැල්ලක්.
• ඔත්තු බැලීම: ව්‍යාජ කේත කැබැල්ලක් වන අතර එමඟින් සමහර ඇමතුම් සැබෑ කේත කැබැල්ලකට බාධා වන අතර එමඟින් සම්පූර්ණ මුල් වස්තුව ප්‍රතිස්ථාපනය නොකර ඇමතුම් සත්‍යාපනය කිරීමට ඉඩ ලබා දේ.

විහිළුවක් යනු හැසිරීම පරීක්ෂා කිරීම පමණක් වන අතර ඇතැම් ක්‍රම හැඳින්වීමට වග බලා ගන්න. ස්ටබ් යනු කිසියම් වස්තුවක පරීක්ෂා කළ හැකි අනුවාදයකි.

ඔබ ඇපල් ක්‍රමයක් අදහස් කරන්නේ කුමක්ද?

ඔබ එය නිදොස්කරණය සමඟ සංසන්දනය කරන්නේ නම්:

ස්ටබ් යනු ක්‍රමයක් නිවැරදි අගය ලබා දෙන බවට වග බලා ගැනීමයි

සමච්චලයට සමාන වන්නේ ක්‍රමයට පියවර තැබීම හා නිවැරදි අගය ලබා දීමට පෙර ඇතුළත ඇති සියල්ල නිවැරදි බවට වග බලා ගැනීමයි.

ඉතා පැහැදිලි හා ප්‍රායෝගික වීමට:

කඳ: පංතිය / වස්තුව ව්‍යාජ / ව්‍යාජ වස්තු ක්‍රම ක්‍රියාත්මක කරන අතර සෑම විටම ඔබට අවශ්‍ය දේ ආපසු ලබා දේ.

JavaScript හි උදාහරණය:

var Stub = {
   method_a: function(param_a, param_b){
      return 'This is an static result';
   }
}

විහිළුව: මුරණ්ඩුකමට සමාන ය, නමුත් එය යම් ක්‍රමයක් තර්ක කළ විට “සත්‍යාපනය” කරන තර්කනයක් එක් කරයි, එවිට යම් ක්‍රියාත්මක කිරීමක් එම ක්‍රමයට කැඳවන බව ඔබට සහතික විය හැකිය.

LmLevan පවසන පරිදි ඔබ පරිශීලක ලියාපදිංචි පන්තියක් පරීක්ෂා කරන බවට උදාහරණයක් ලෙස සිතන්න. Save ඇමතීමෙන් පසුව, එය SendConfirmationEmail අමතන්න.

ඉතා මෝඩ කේතයක් උදාහරණය:

var Mock = {
   calls: {
      method_a: 0
   }

   method_a: function(param_a, param_b){
     this.method_a++; 
     console.log('Mock.method_a its been called!');
   }
}

මානසික ආකෘතියක් භාවිතා කිරීම මට මෙය තේරුම් ගැනීමට උපකාරී විය, සියලු පැහැදිලි කිරීම් සහ ලිපි වලට වඩා, එය “ගිලී” නැත.

ඔබේ දරුවා මේසය මත වීදුරු තහඩුවක් ඇති බව සිතන්න. ඔහු එය සමඟ සෙල්ලම් කිරීමට පටන් ගනී. දැන්, එය බිඳී යනු ඇතැයි ඔබ බිය වේ. ඉතින්, ඔබ ඔහුට ප්ලාස්ටික් තහඩුවක් දෙන්න. එය විහිළුවක් වනු ඇත (එකම හැසිරීම, එකම අතුරුමුහුණත, "මෘදු" ක්‍රියාත්මක කිරීම).

දැන්, ඔබට ප්ලාස්ටික් ආදේශකයක් නොමැති බව පවසන්න, එබැවින් ඔබ පැහැදිලි කරන්නේ "ඔබ එය සමඟ දිගටම ක්‍රීඩා කළහොත් එය බිඳී යනු ඇත!". එය ස්ටබ් එකක් , ඔබ කලින් නියම කළ තත්වයක් කල්තියා ලබා දුන්නා.

ඒ ආදර්ශ ඔහු පවා භාවිතා කළේ නැහැ එම දෙබලක වනු ඇත ... හා ඔත්තු සේවය බව ඔබ දැනටමත් භාවිතා එකම පැහැදිලි කිරීමක් ලබා වගේ දෙයක් වෙන්න පුළුවන්.

මම හිතන්නේ ඔවුන් අතර වඩාත්ම වැදගත් වෙනස ඔවුන්ගේ අභිප්‍රායන් ය.

WHY stub එදිරිව WHY සමච්චලයට එය පැහැදිලි කිරීමට මට ඉඩ දෙන්න

මගේ මැක් ට්විටර් සේවාදායකයාගේ පොදු කාලරාමු පාලකය සඳහා මම පරීක්ෂණ කේතයක් ලියමි යැයි සිතමු

මෙන්න පරීක්ෂණ නියැදි කේතය

twitter_api.stub(:public_timeline).and_return(public_timeline_array)
client_ui.should_receive(:insert_timeline_above).with(public_timeline_array)
controller.refresh_public_timeline

• ස්ටබ්: ට්විටර් ඒපීඅයි වෙත ජාල සම්බන්ධතාවය ඉතා මන්දගාමී වන අතර එමඟින් මගේ පරීක්ෂණය මන්දගාමී වේ. එය කාලරාමු නැවත ලබා දෙන බව මම දනිමි, එබැවින් මම HTTP ට්විටර් ඒපීඅයි අනුකරණය කරමින් ස්ටබ් එකක් සෑදුවෙමි, එවිට මගේ පරීක්ෂණය එය ඉතා වේගයෙන් ක්‍රියාත්මක වන අතර මට නොබැඳිව වුවද පරීක්ෂණය ක්‍රියාත්මක කළ හැකිය.
• MOCK: මම තවම මගේ UI ක්‍රම කිසිවක් ලියා නැති අතර මගේ ui වස්තුව සඳහා ලිවිය යුතු ක්‍රම මොනවාදැයි මට විශ්වාස නැත. පරීක්ෂණ කේතය ලිවීමෙන් මගේ පාලකය මගේ ui වස්තුව සමඟ සහයෝගයෙන් කටයුතු කරන්නේ කෙසේදැයි දැන ගැනීමට මම බලාපොරොත්තු වෙමි.

විහිළු ලිවීමෙන්, අපේක්ෂාව සපුරා ඇති බව තහවුරු කර ගැනීමෙන් ඔබ වස්තු සහයෝගීතා සම්බන්ධතාවය සොයා ගන්නා අතර මුරණ්ඩු වස්තුවේ හැසිරීම අනුකරණය කරයි.

ඔබ විහිළු ගැන වැඩි විස්තර දැන ගැනීමට උත්සාහ කරන්නේ නම් මෙම ලිපිය කියවීමට මම යෝජනා කරමි: http://jmock.org/oopsla2004.pdf

මෙම විනිවිදකය ප්‍රධාන වෙනස්කම් ඉතා හොඳින් පැහැදිලි කරයි.

* වොෂිංටන් විශ්ව විද්‍යාලයේ සීඑස්ඊ 403 දේශනය 16 සිට (“මාටි ස්ටෙප්” විසින් නිර්මාණය කරන ලද විනිවිදකය)

රෝයි ඔෂෙරෝව් විසින් ඉදිරිපත් කරන ලද පැහැදිලි කිරීමට මම කැමතියි [වීඩියෝ සබැඳිය] .

නිර්මාණය කරන ලද සෑම පන්තියක් හෝ වස්තුවක්ම ව්‍යාජ ය. ඔබ එයට එරෙහි ඇමතුම් සත්‍යාපනය කරන්නේ නම් එය විහිළුවකි. එසේ නොමැති නම් එය මුරණ්ඩු ය.

• ස්ටබ්ස් එදිරිව මොක්ස්
  • පල්
    1. ක්‍රම ඇමතුම් සඳහා නිශ්චිත පිළිතුරු සපයන්න
       • උදා: myStubbedService.getValues ​​() පරීක්ෂණයට ලක්ව ඇති කේතයට අවශ්‍ය නූලක් ආපසු එවන්න
    2. එය හුදකලා කිරීම සඳහා පරීක්ෂණය යටතේ ඇති කේතය භාවිතා කරයි
    3. පරීක්ෂණය අසමත් විය නොහැක
       • උදා: myStubbedService.getValues ​​() විසින් මුරණ්ඩු අගය ලබා දෙයි
    4. බොහෝ විට වියුක්ත ක්‍රම ක්‍රියාත්මක කරන්න
  • සමච්චල්
    1. මුරණ්ඩු වල “සුපර්සෙට්”; සමහර ක්‍රම හැඳින්විය හැකි බව ප්‍රකාශ කළ හැකිය
       • උදා: myMockedService.getValues ​​() කැඳවනු ලැබුවේ එක් වරක් පමණක් බව තහවුරු කරන්න
    2. පරීක්ෂණය යටතේ කේතයේ හැසිරීම පරීක්ෂා කිරීමට භාවිතා කරයි
    3. පරීක්ෂණය අසමත් විය හැකිය
       • උදා: myMockedService.getValues ​​() එක් වරක් කැඳවූ බව තහවුරු කරන්න; සත්‍යාපනය අසමත් වේ, මන්ද මගේ පරීක්‍ෂා කළ කේතය මගින් myMockedService.getValues ​​() කැඳවනු නොලැබේ
    4. බොහෝ විට අතුරු මුහුණත් සමච්චලයට ලක් කරයි

ටෙස්ට් ඩබල් බලන්න:

• ව්යාජ : ව්යාජ යනු ක්රියාත්මක ක්රියාත්මක කිරීම් ඇති වස්තූන් වන නමුත් නිෂ්පාදනයට සමාන නොවේ. වැනි : දත්ත ප්‍රවේශ වස්තුව හෝ නිධිය මතකයේ ක්‍රියාත්මක කිරීම.

• ස්ටබ් : ස්ටබ් යනු පූර්ව නිශ්චිත දත්ත රඳවා තබා ඇති අතර පරීක්ෂණ අතරතුර ඇමතුම්වලට පිළිතුරු දීමට එය භාවිතා කරයි. වැනි : ක්‍රමවේදය ඇමතුමකට ප්‍රතිචාර දැක්වීම සඳහා දත්ත සමුදායෙන් දත්ත ලබා ගැනීමට අවශ්‍ය වස්තුවකි.

• විහිළු : විහිළු යනු ඔවුන්ට ලැබෙන ඇමතුම් ලියාපදිංචි කරන වස්තු ය. පරීක්ෂණ ප්‍රකාශයේදී, අපේක්ෂිත සියලු ක්‍රියා සිදු කර ඇති බව අපට මොක්ස් මත සත්‍යාපනය කළ හැකිය. වැනි : විද්‍යුත් තැපැල් යැවීමේ සේවාව ලෙස හඳුන්වන ක්‍රියාකාරීත්වය. වැඩි විස්තර සඳහා මෙය පරීක්ෂා කරන්න .

ඒ ව්යාජ නිසා ඔවුන් දෙදෙනාම සැබෑ වස්තුව මෙන් පෙනුම, අංකුර ලිපියකි හෝ ව්යාජ වස්තුව (අතින් ලියන හෝ වෙනත්) එක්කෝ විස්තර කිරීමට යොදා ගත හැකි බව සැලකූවිට වේ.

ව්‍යාජ එකක් දඩබ්බරකමක් හෝ විහිළුවක් ද යන්න රඳා පවතින්නේ එය වර්තමාන පරීක්ෂණය සඳහා භාවිතා කරන ආකාරය මත ය. එය අන්තර්ක්‍රියාකාරිත්වයක් පරීක්ෂා කිරීමට භාවිතා කරන්නේ නම් (එයට එරෙහිව අවධාරනය කර ඇත), එය ව්‍යාජ වස්තුවකි. එසේ නොමැති නම්, එය මුරණ්ඩු ය.

ව්‍යාජ ලෙස පරීක්‍ෂණය සුමටව සිදු වන බවට වග බලා ගනී. එහි අර්ථය වන්නේ ඔබේ අනාගත පරීක්ෂණය කියවන්නාට එහි වස්තු මූලාශ්‍ර කේතය කියවීමකින් තොරව (බාහිර සම්පත් මත යැපීමකින් තොරව) ව්‍යාජ වස්තුවේ හැසිරීම කුමක් වේද යන්න අවබෝධ වනු ඇති බවයි.

ටෙස්ට් ධාවනය සුමටව අදහස් කරන්නේ කුමක්ද?
පහත කේතයේ Forexample:

 public void Analyze(string filename)
        {
            if(filename.Length<8)
            {
                try
                {
                    errorService.LogError("long file entered named:" + filename);
                }
                catch (Exception e)
                {
                    mailService.SendEMail("admin@hotmail.com", "ErrorOnWebService", "someerror");
                }
            }
        }

ඔබට mailService.SendEMail () ක්‍රමය පරීක්ෂා කිරීමට අවශ්‍ය වන්නේ, ඔබ තුළ පරීක්ෂණ ක්‍රමයක් තුළ ව්‍යතිරේකයක් අනුකරණය කිරීමට අවශ්‍ය නිසා, එම ප්‍රති result ලය අනුකරණය කිරීම සඳහා ඔබ ව්‍යාජ මුරණ්ඩු සේවා සේවා පන්තියක් නිර්මාණය කළ යුතුය, එවිට ඔබේ පරීක්ෂණ කේතය පරීක්ෂා කිරීමට හැකි වනු ඇත mailService.SendEMail () ක්‍රමය. ඔබ දකින පරිදි ඔබට වෙනත් බාහිර යැපුම් දෝෂ සේවා පන්තියක ප්‍රති result ලයක් අනුකරණය කළ යුතුය.

අයිතිය කඩදාසි සිට සමච්චල් භූමිකා, Objects නොවන jMock වන සංවර්ධකයින් විසින්,:

ස්ටබ්ස් යනු ටින් කළ ප්‍රති .ල ලබා දෙන නිෂ්පාදන කේතය ව්‍යාජ ලෙස ක්‍රියාත්මක කිරීමයි. ව්‍යාජ වස්තූන් මුරණ්ඩු ලෙස ක්‍රියා කරන අතර ඉලක්කගත වස්තුව අසල්වැසියන් සමඟ අන්තර්ක්‍රියා කිරීමට උපකාරී වේ.

ඉතින්, ප්රධාන වෙනස්කම් වන්නේ:

• මුරණ්ඩු මත තබා ඇති අපේක්ෂාවන් සාමාන්‍යයෙන් ජනක වන අතර, විහිළු මත තබා ඇති අපේක්ෂාවන් වඩාත් “දක්ෂ” විය හැකිය (උදා: මෙය පළමු ඇමතුමට ආපසු එවන්න, මෙය දෙවනුව යනාදිය).
• stubs ප්රධාන වශයෙන් භාවිතා කරන්නේ ද SUT ක පිහිටුවීම් වක්ර යෙදවුම් අතර, mocks පරීක්ෂා කිරීම සඳහා භාවිතා කල හැක වක්ර යෙදවුම් හා වක්ර වූ SUT දැක්මත්.

සාරාංශයක් ලෙස, ෆවුලර්ගේ ලිපි මාතෘකාවෙන් ව්‍යාකූලත්වය විසුරුවා හැරීමට උත්සාහ කරන අතරම : සමච්චල් යනු මුරණ්ඩු ය, නමුත් ඒවා මුරණ්ඩු පමණක් නොවේ .

මම ආර්ට් ඔෆ් යුනිට් ටෙස්ටිං කියවමින් සිටි අතර පහත දැක්වෙන අර්ථ දැක්වීම මත පැටලී සිටියෙමි .

ඒ ව්යාජ නිසා ඔවුන් දෙදෙනාම සැබෑ වස්තුව මෙන් පෙනුම, අංකුර ලිපියකි හෝ ව්යාජ වස්තුව (අතින් ලියන හෝ වෙනත්) එක්කෝ විස්තර කිරීමට යොදා ගත හැකි බව සැලකූවිට වේ. ව්‍යාජ එකක් දඩබ්බරකමක් හෝ විහිළුවක් ද යන්න රඳා පවතින්නේ එය වර්තමාන පරීක්ෂණය සඳහා භාවිතා කරන ආකාරය මත ය. එය අන්තර්ක්‍රියාකාරිත්වයක් පරීක්ෂා කිරීමට භාවිතා කරන්නේ නම් (එයට එරෙහිව අවධාරනය කරනු ලැබේ), එය ව්‍යාජ වස්තුවකි . එසේ නොමැති නම්, එය මුරණ්ඩු ය .

අන්කල් බොබ් ද ලිට්ල් මොකර්ගේ මෙම රසවත් ලිපිය මට හමු විය . එය සියලු පාරිභාෂිතය ඉතා පහසුවෙන් තේරුම් ගත හැකි ආකාරයෙන් පැහැදිලි කරයි, එබැවින් එය ආරම්භකයින්ට ප්‍රයෝජනවත් වේ. මාටින් ෆෝලර්ස් ලිපිය විශේෂයෙන් මා වැනි ආරම්භකයින් සඳහා කියවීමට අපහසුය.

පරීක්ෂණය ක්‍රියාත්මක කිරීමට ස්ටබ් අපට උපකාරී වේ. කෙසේද? එය පරීක්ෂණය ක්‍රියාත්මක කිරීමට උපකාරී වන අගයන් ලබා දෙයි. මෙම අගයන් සත්‍ය නොවන අතර අපි මෙම අගයන් නිර්මාණය කළේ පරීක්ෂණය ක්‍රියාත්මක කිරීම සඳහා ය. උදාහරණයක් ලෙස දත්ත සමුදා වගුවේ ඇති අගයන්ට සමාන අගයන් අපට ලබා දීම සඳහා අපි හැෂ්මැප් එකක් නිර්මාණය කරමු. එබැවින් දත්ත සමුදාය සමඟ කෙලින්ම මැදිහත් වීම වෙනුවට අපි හැෂ්මාප් සමඟ අන්තර්ක්‍රියා කරන්නෙමු.

මොක් යනු පරීක්ෂණය මෙහෙයවන ව්‍යාජ වස්තුවකි. එහිදී අපි තරයේ කියා සිටිමු.

C # සහ Moq රාමුව භාවිතා කරමින් mocks vs stubs සඳහා පහත උදාහරණය බලන්න. මොක් හට ස්ටබ් සඳහා විශේෂ මූල පදයක් නොමැත, නමුත් ඔබට මොක් වස්තුව භාවිතා කර ස්ටබ් නිර්මාණය කළ හැකිය.

namespace UnitTestProject2
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;
    [TestClass]
    public class UnitTest1
    {
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method calls Repository GetName method "once" when Id is greater than Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_GetNameCalledOnce()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));

            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Once);
        }
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method doesn't call Repository GetName method when Id is Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsZero_GetNameNeverCalled()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));
            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(0);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Never);
        }
        /// <summary>
        /// Test using Stub to Verify that GetNameWithPrefix method returns Name with a Prefix
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_ReturnsNameWithPrefix()
        {
            // Arrange 
            var stubEntityRepository = new Mock<IEntityRepository>();
            stubEntityRepository.Setup(m => m.GetName(It.IsAny<int>()))
                .Returns("Stub");
            const string EXPECTED_NAME_WITH_PREFIX = "Mr. Stub";
            var entity = new EntityClass(stubEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            Assert.AreEqual(EXPECTED_NAME_WITH_PREFIX, name);
        }
    }
    public class EntityClass
    {
        private IEntityRepository _entityRepository;
        public EntityClass(IEntityRepository entityRepository)
        {
            this._entityRepository = entityRepository;
        }
        public string Name { get; set; }
        public string GetNameWithPrefix(int id)
        {
            string name = string.Empty;
            if (id > 0)
            {
                name = this._entityRepository.GetName(id);
            }
            return "Mr. " + name;
        }
    }
    public interface IEntityRepository
    {
        string GetName(int id);
    }
    public class EntityRepository:IEntityRepository
    {
        public string GetName(int id)
        {
            // Code to connect to DB and get name based on Id
            return "NameFromDb";
        }
    }
}

මුරණ්ඩු හා ව්‍යාජ පරීක්ෂණ දෘෂ්ටි කෝණය:

• ස්ටබ් යනු ව්‍යාජ ලෙස ක්‍රියාවට නැංවීම පරිශීලකයා විසින් ස්ථිතික ආකාරයකින් සිදු කිරීම යන්නෙන් අදහස් වන්නේ ක්‍රියාත්මක කිරීමේ කේතය ලිවීමයි. එබැවින් එයට සේවා අර්ථ දැක්වීම සහ ගතික තත්ත්වය හැසිරවිය නොහැක, සාමාන්‍යයෙන් මෙය විහිළු රාමුවක් භාවිතා නොකර JUnit රාමුව තුළ සිදු කෙරේ.

• මොක් යනු ව්‍යාජ ක්‍රියාත්මක කිරීමක් වන නමුත් එය ක්‍රියාත්මක කිරීම මොකිටෝ වැනි විහිළු රාමු භාවිතා කරමින් ගතික ආකාරයකින් සිදු කරයි. එබැවින් අපට තත්වය සහ සේවා අර්ථ දැක්වීම ගතික ආකාරයක් ලෙස හැසිරවිය හැකිය, එනම් ධාවන වේලාවේදී කේතයෙන් විහිළු ගතිකව නිර්මාණය කළ හැකිය. එබැවින් විහිළුවක් භාවිතා කිරීමෙන් අපට ස්ටබ්ස් ගතිකව ක්‍රියාත්මක කළ හැකිය.

විහිළුවක් යනු තාක්‍ෂණික හා ක්‍රියාකාරී වස්තුවකි.

සමච්චලය තාක්ෂණික ය . බයිට් කේත උත්පාදනයට ස්තූතිවන්ත වන එය විහිළු පුස්තකාලයක් මගින් නිර්මාණය කර ඇත (ඊසි මොක්, ජේමොකිට් සහ මෑතකදී මොකිටෝ මේවා සඳහා ප්‍රසිද්ධයි) .
ව්‍යාජ ක්‍රියාවට නැංවීම ජනනය කරනු ලබන්නේ ක්‍රමවේදයක් ක්‍රියාත්මක කළ විට නිශ්චිත අගයක් ලබා දීම සඳහා අපට එය උපයෝගී කර ගත හැකි ආකාරයට වන අතර, සමහර විශේෂිත පරාමිතීන් (දැඩි පරීක්ෂාව) හෝ ඕනෑම පරාමිතීන් (ව්‍යාජ පරීක්ෂාව) සමඟ ව්‍යාජ ක්‍රමයක් ආයාචනා කර ඇත්දැයි තහවුරු කර ගැනීම වැනි වෙනත් කරුණු ද ඇත. දැඩි පරීක්ෂාවක් නොමැත).

විහිළුවක් ස්ථාපනය කිරීම:

@Mock Foo fooMock

හැසිරීමක් පටිගත කිරීම:

when(fooMock.hello()).thenReturn("hello you!");

ආයාචනයක් සත්‍යාපනය කිරීම:

verify(fooMock).hello()

මේවා පැහැදිලිවම Foo පන්තිය / හැසිරීම ක්ෂණිකව / ඉක්මවා යාමේ ස්වාභාවික ක්‍රමය නොවේ. ඒ නිසා මම තාක්ෂණික අංශයක් ගැන සඳහන් කරමි.

නමුත් විහිළුව ද ක්‍රියාකාරී වන්නේ එය SUT වෙතින් හුදකලා කිරීමට අවශ්‍ය පන්තියේ අවස්ථාවක් වන බැවිනි. ඒ මත පටිගත කරන ලද හැසිරීම් සමඟ, අපට එය මුරණ්ඩුකමකට වඩා SUT හි භාවිතා කළ හැකිය.

කඳ කොටස යනු ක්‍රියාකාරී වස්තුවකි: එය අප SUT වෙතින් හුදකලා කළ යුතු පන්තියේ උදාහරණයක් වන අතර එපමණයි. එයින් අදහස් වන්නේ අපගේ ඒකක පරීක්ෂණ වලදී අවශ්‍ය වන මුරණ්ඩු පන්තිය සහ සියලු හැසිරීම් සවිකිරීම් පැහැදිලිව නිර්වචනය කළ යුතු බවයි.
නිදසුනක් ලෙස, hello()මුරණ්ඩු කිරීම සඳහා Fooපංතිය උප පංතියට (හෝ එහි ඇති අතුරු මුහුණත ක්‍රියාත්මක කිරීමට) සහ අභිබවා යාමට අවශ්‍ය වේ hello() :

public class HelloStub extends Hello{    
  public String hello { 
      return "hello you!"; 
  }
}

තවත් පරීක්ෂණ අවස්ථාවකට තවත් අගය ප්‍රතිලාභයක් අවශ්‍ය නම්, ප්‍රතිලාභ සැකසීමට අපට සාමාන්‍ය ක්‍රමයක් නිර්වචනය කිරීමට අවශ්‍ය වනු ඇත:

public class HelloStub extends Hello{    
  public HelloStub(String helloReturn){
       this.helloReturn = helloReturn;
  }
  public String hello { 
      return helloReturn; 
  }
}

වෙනත් අවස්ථා: මට අතුරු ආබාධ ක්‍රමයක් තිබුනේ නම් (ආපසු නොපැමිණේ) සහ එම ක්‍රමය ක්‍රියාත්මක කර ඇත්දැයි මම පරීක්ෂා කර බැලුවහොත්, බොහෝ විට ක්‍රමවේදය ක්‍රියාත්මක කළ ආකාරය ගණනය කිරීම සඳහා මම ස්ටබ් පන්තියේ බූලියන් හෝ කවුන්ටරයක් ​​එක් කළ යුතුව තිබුණි.

නිගමනය

ඔබේ ඒකක පරීක්ෂණය සඳහා ලිවීමට බොහෝ විට උඩිස් / කේත අවශ්‍ය වේ. කොටුවෙන් පිටත පටිගත කිරීමේ / සත්‍යාපන විශේෂාංග සැපයීමට ස්තූතිවන්ත වන විහිළුව කුමක්ද?
විශිෂ් mo විහිළු පුස්තකාලවල පැමිණීමත් සමඟ වර්තමානයේ මුරණ්ඩු ප්‍රවේශය ප්‍රායෝගිකව භාවිතා වන්නේ එබැවිනි.

මාටින් ෆෝලර් ලිපිය ගැන: මම විහිළු භාවිතා කරන අතරේ මම "විහිළුකාර" ක්‍රමලේඛකයෙකු යැයි නොසිතමි.
නමුත් මම විහිළුවක් භාවිතා කරන්නේ එය ඇත්ත වශයෙන්ම අවශ්‍ය වූ විටය (කරදරකාරී පරායත්තතා) සහ පරායත්තතාව ඉහළ මට්ටමක පවතින පරායත්තතා සහිත පන්තියක් පරීක්ෂා කරන විට මම පරීක්ෂණ පෙති කැපීම සහ කුඩා ඒකාබද්ධ කිරීමේ පරීක්ෂණ වලට කැමැත්තෙමි.

ප්ලස් ප්‍රයෝජනවත් පිළිතුරු, උප වලට වඩා මොක්ස් භාවිතා කිරීමේ වඩාත් ප්‍රබල කරුණකි

[ප්‍රධාන කේතය මත රඳා පවතින] සහකාරිය අපගේ පාලනය යටතේ නොමැති නම් (උදා: තෙවන පාර්ශවීය පුස්තකාලයකින්),
මේ අවස්ථාවේ දී, සමච්චලයට වඩා ලිවීමට අපහසුය .

වෙනස්කම් පැහැදිලි කිරීම සඳහා මම මගේ පිළිතුරේ පයිතන් උදාහරණ භාවිතා කර ඇත්තෙමි.

Stub - Stubbing යනු සංවර්ධන ජීවන චක්‍රයේ මුල් අවධියේ පන්තිවල ක්‍රමවේදයන් ක්‍රියාත්මක කිරීම සඳහා භාවිතා කරන මෘදුකාංග සංවර්ධන තාක්‍ෂණයකි. දන්නා අතුරු මුහුණතක් ක්‍රියාවට නැංවීම සඳහා ඒවා පොදුවේ භාවිතා කරන්නන් ලෙස භාවිතා කරනු ලැබේ, එහිදී අතුරු මුහුණත අවසන් හෝ දන්නා නමුත් ක්‍රියාත්මක කිරීම තවමත් හඳුනාගෙන හෝ අවසන් කර නොමැත. ඔබ ආරම්භ කරන්නේ ස්ටබ්ස් වලින් වන අතර එයින් අදහස් කරන්නේ ඔබ ශ්‍රිතයක අර්ථ දැක්වීම ලියා පසුව සත්‍ය කේතය පසුව තබන්න. වාසිය නම් ඔබට ක්‍රම අමතක නොවන අතර ඔබේ සැලසුම කේතයෙන් දකින අතරතුර ඔබට දිගටම සිතීමට හැකිය. ඔබේ කේතයේ වෙනත් කොටස් වලට ප්‍රතිචාරය වහාම භාවිතා කළ හැකි වන පරිදි ඔබේ මුරණ්ඩුයට ස්ථිතික ප්‍රතිචාරයක් ලබා දිය හැකිය. මුරණ්ඩු වස්තූන් වලංගු ප්‍රතිචාරයක් ලබා දෙයි, නමුත් එය ස්ථිතික වන්නේ ඔබ කුමන ආදානයක් ලබා දුන්නද, ඔබට සැමවිටම එකම ප්‍රතිචාරයක් ලැබෙනු ඇත:

class Foo(object):
    def bar1(self):
        pass

    def bar2(self):
        #or ...
        raise NotImplementedError

    def bar3(self):
        #or return dummy data
        return "Dummy Data"

ව්‍යාජ වස්තූන් ව්‍යාජ පරීක්ෂණ අවස්ථා වලදී භාවිතා කරනු ලැබේ. ව්‍යාජ වස්තූන් යනු පාලනය කරන ලද ආකාරවලින් සැබෑ වස්තූන්ගේ හැසිරීම අනුකරණය කරන අනුකරණ වස්තු වේ. ඔබ සාමාන්‍යයෙන් වෙනත් වස්තුවක හැසිරීම පරීක්ෂා කිරීම සඳහා ව්‍යාජ වස්තුවක් නිර්මාණය කරයි. ඒකක පරීක්ෂණ සඳහා ලබා ගත නොහැකි හෝ ප්‍රමාණවත් නොවන සම්පත් අනුකරණය කිරීමට විහිළු අපට ඉඩ දෙයි.

mymodule.py:

import os
import os.path

def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

test.py:

from mymodule import rm
import mock
import unittest

class RmTestCase(unittest.TestCase):
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")

if __name__ == '__main__':
    unittest.main()

මෙය ඉතා මූලික උදාහරණයකි, එය rm ධාවනය කර එය සමඟ හැඳින්වූ පරාමිතිය තහවුරු කරයි. මෙහි පෙන්වා ඇති ආකාරයට පමණක් නොව ඔබට වස්තූන් සමඟ විහිළු භාවිතා කළ හැකි අතර, ඔබට වටිනාකමක් ද ලබා දිය හැකි අතර එමඟින් ව්‍යාජ වස්තුවක් පරීක්ෂා කිරීම සඳහා කඳක් ආදේශ කිරීමට භාවිතා කළ හැකිය.

Unittest.mock පිළිබඳ වැඩි විස්තර , python 2.x mock හි සටහන unittest හි ඇතුළත් කර නැති නමුත් බාගත කළ හැකි මොඩියුලයක් වන අතර එය නල මාර්ගයෙන් බාගත කළ හැකිය (pip install mock).

රෝයි ඔෂෙරෝව් විසින් රචිත "ද ආර්ට් ඔෆ් යුනිට් ටෙස්ටිං" ද මම කියවා ඇති අතර, පයිතන් සහ පයිතන් උදාහරණ භාවිතා කරමින් සමාන පොතක් ලියා ඇත්නම් එය ඉතා හොඳ යැයි මම සිතමි. එවැනි පොතක් ගැන යමෙක් දන්නේ නම් කරුණාකර බෙදාගන්න. චියර්ස් :)

කඳක් යනු පරීක්ෂණ අරමුණු සඳහා සාදන ලද ව්‍යාජ වස්තුවකි. විහිළුවක් යනු අපේක්ෂිත ඇමතුම් effectively ලදායී ලෙස සිදුවී ඇත්දැයි සටහන් කරන කඳකි.

කඳක් යනු හිස් ශ්‍රිතයක් වන අතර එය පරීක්ෂණ අතරතුරදී පාලනයකින් තොරව ව්‍යතිරේකයන් වළක්වා ගැනීමට භාවිතා කරයි:

function foo(){}

විහිළුවක් යනු පරීක්ෂණ වලදී මෙහෙයුම් පද්ධතිය, පරිසරය හෝ දෘඩාංග පරායත්තතාවයන් වළක්වා ගැනීම සඳහා භාවිතා කරන කෘතිම ශ්‍රිතයකි:

function foo(bar){ window = this; return window.toString(bar); }

ප්‍රකාශයන් සහ තත්වය අනුව:

• සිදුවීමක් හෝ රාජ්‍ය වෙනසක් කිරීමට පෙර සමච්චල් කරනු ලැබේ
• සම්බන්ධක ඒකක වලින් කේත ක්‍රියාත්මක නොකිරීමට ඒවා සිදුවීමට පෙර තත්වය සපයයි
• ඔත්තුකරුවන් යනු මුරණ්ඩු වැනි සැකසුමකි
• ව්යාජ ලෙස ප්රකාශ නොකෙරේ, ඒවා රාජ්යයෙන් වැළකී සිටීම සඳහා දෘඩ කේත පරායත්තයන් සහිත සිදුවීමකට පසු ධාවනය වේ

යොමුව

• ගීක් ටීකාව: සමච්චල් කරන්න
• ගීක් ටීකාව: කඳ
• ගීක් ටීකාව: ඔත්තු
• පරීක්ෂණ ද්විත්ව: ව්‍යාජ, විහිළු සහ පඩිපෙළ

වලංගු පිළිතුරු රාශියක් එහි ඇති නමුත් මාමා බොබ් පෝරමය සඳහන් කිරීම වටී යැයි මම සිතමි: https://8thlight.com/blog/uncle-bob/2014/05/14/TheLittleMocker.html

උදාහරණ සමඟ හොඳම පැහැදිලි කිරීම!