---
title: "స్మార్ట్ కాంట్రాక్ట్‌ల టెస్టింగ్"
description: "ఎథీరియం స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి పద్ధతులు మరియు పరిగణనల అవలోకనం."
lang: te
---

ఎథీరియం వంటి పబ్లిక్ బ్లాక్‌చైన్‌లు మార్చలేనివి, కాబట్టి డిప్లాయ్‌మెంట్ తర్వాత స్మార్ట్ కాంట్రాక్ట్ కోడ్‌ను మార్చడం కష్టం. "వర్చువల్ అప్‌గ్రేడ్‌లు" చేయడానికి [కాంట్రాక్ట్ అప్‌గ్రేడ్ ప్యాటర్న్‌లు](/developers/docs/smart-contracts/upgrading/) ఉన్నాయి, కానీ వీటిని అమలు చేయడం కష్టం మరియు సామాజిక ఏకాభిప్రాయం అవసరం. అంతేకాకుండా, ఒక లోపాన్ని కనుగొన్న _తర్వాత_ మాత్రమే అప్‌గ్రేడ్ దాన్ని పరిష్కరించగలదు—ఒకవేళ దాడి చేసే వ్యక్తి ముందుగా ఆ దుర్బలత్వాన్ని కనుగొంటే, మీ స్మార్ట్ కాంట్రాక్ట్ దోపిడీకి గురయ్యే ప్రమాదం ఉంది.

ఈ కారణాల వల్ల, మెయిన్‌నెట్‌కు [డిప్లాయ్ చేయడానికి](/developers/docs/smart-contracts/deploying/) ముందు స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడం [భద్రత](/developers/docs/smart-contracts/security/) కోసం కనీస అవసరం. కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి మరియు కోడ్ ఖచ్చితత్వాన్ని అంచనా వేయడానికి అనేక పద్ధతులు ఉన్నాయి; మీరు ఎంచుకునేది మీ అవసరాలపై ఆధారపడి ఉంటుంది. అయినప్పటికీ, కాంట్రాక్ట్ కోడ్‌లోని చిన్న మరియు పెద్ద భద్రతా లోపాలను పట్టుకోవడానికి వివిధ సాధనాలు మరియు విధానాలతో కూడిన టెస్ట్ సూట్ అనువైనది.

## ముందస్తు అవసరాలు {#prerequisites}

ఎథీరియం నెట్‌వర్క్‌లో డిప్లాయ్ చేయడానికి ముందు స్మార్ట్ కాంట్రాక్ట్‌లను ఎలా టెస్ట్ చేయాలో ఈ పేజీ వివరిస్తుంది. మీకు [స్మార్ట్ కాంట్రాక్ట్‌ల](/developers/docs/smart-contracts/) గురించి తెలుసని ఇది భావిస్తుంది.

## స్మార్ట్ కాంట్రాక్ట్ టెస్టింగ్ అంటే ఏమిటి? {#what-is-smart-contract-testing}

స్మార్ట్ కాంట్రాక్ట్ టెస్టింగ్ అనేది స్మార్ట్ కాంట్రాక్ట్ కోడ్ ఆశించిన విధంగా పనిచేస్తుందో లేదో ధృవీకరించే ప్రక్రియ. ఒక నిర్దిష్ట స్మార్ట్ కాంట్రాక్ట్ విశ్వసనీయత, వినియోగం మరియు భద్రత కోసం అవసరాలను తీరుస్తుందో లేదో తనిఖీ చేయడానికి టెస్టింగ్ ఉపయోగపడుతుంది.

విధానాలు వేర్వేరుగా ఉన్నప్పటికీ, చాలా టెస్టింగ్ పద్ధతులకు స్మార్ట్ కాంట్రాక్ట్ నిర్వహించాల్సిన డేటా యొక్క చిన్న నమూనాతో దాన్ని అమలు చేయడం అవసరం. నమూనా డేటా కోసం కాంట్రాక్ట్ సరైన ఫలితాలను ఇస్తే, అది సరిగ్గా పనిచేస్తుందని భావించబడుతుంది. కాంట్రాక్ట్ అమలు ఆశించిన ఫలితాలతో సరిపోలుతుందో లేదో తనిఖీ చేయడానికి [టెస్ట్ కేసులను](https://en.m.wikipedia.org/wiki/Test_case) రాయడానికి మరియు అమలు చేయడానికి చాలా టెస్టింగ్ సాధనాలు వనరులను అందిస్తాయి.

### స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడం ఎందుకు ముఖ్యం? {#importance-of-testing-smart-contracts}

స్మార్ట్ కాంట్రాక్ట్‌లు తరచుగా అధిక-విలువైన ఆర్థిక ఆస్తులను నిర్వహిస్తాయి కాబట్టి, చిన్న ప్రోగ్రామింగ్ లోపాలు [వినియోగదారులకు భారీ నష్టాలకు](https://rekt.news/leaderboard/) దారితీయవచ్చు మరియు తరచుగా దారితీస్తాయి. అయితే, కఠినమైన టెస్టింగ్ స్మార్ట్ కాంట్రాక్ట్ కోడ్‌లోని లోపాలు మరియు సమస్యలను ముందుగానే కనుగొనడంలో మరియు మెయిన్‌నెట్‌లో ప్రారంభించడానికి ముందే వాటిని పరిష్కరించడంలో మీకు సహాయపడుతుంది.

బగ్‌ను కనుగొంటే కాంట్రాక్ట్‌ను అప్‌గ్రేడ్ చేయడం సాధ్యమే అయినప్పటికీ, అప్‌గ్రేడ్‌లు సంక్లిష్టమైనవి మరియు సరిగ్గా నిర్వహించకపోతే [లోపాలకు దారితీయవచ్చు](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/). కాంట్రాక్ట్‌ను అప్‌గ్రేడ్ చేయడం మార్చలేనితనం సూత్రాన్ని మరింత దెబ్బతీస్తుంది మరియు అదనపు విశ్వాస ఉపకల్పనలతో వినియోగదారులపై భారం మోపుతుంది. దీనికి విరుద్ధంగా, మీ కాంట్రాక్ట్‌ను టెస్ట్ చేయడానికి సమగ్ర ప్రణాళిక స్మార్ట్ కాంట్రాక్ట్ భద్రతా ప్రమాదాలను తగ్గిస్తుంది మరియు డిప్లాయ్ చేసిన తర్వాత సంక్లిష్టమైన లాజిక్ అప్‌గ్రేడ్‌లను చేయాల్సిన అవసరాన్ని తగ్గిస్తుంది.

## స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేసే పద్ధతులు {#methods-for-testing-smart-contracts}

ఎథీరియం స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేసే పద్ధతులు రెండు విస్తృత వర్గాల కిందకు వస్తాయి: **ఆటోమేటెడ్ టెస్టింగ్** మరియు **మాన్యువల్ టెస్టింగ్**. ఆటోమేటెడ్ టెస్టింగ్ మరియు మాన్యువల్ టెస్టింగ్ ప్రత్యేక ప్రయోజనాలు మరియు ట్రేడ్‌ఆఫ్‌లను అందిస్తాయి, అయితే మీ కాంట్రాక్ట్‌లను విశ్లేషించడానికి బలమైన ప్రణాళికను రూపొందించడానికి మీరు రెండింటినీ కలపవచ్చు.

### ఆటోమేటెడ్ టెస్టింగ్ {#automated-testing}

ఆటోమేటెడ్ టెస్టింగ్ అనేది అమలులో లోపాల కోసం స్మార్ట్ కాంట్రాక్ట్ కోడ్‌ను స్వయంచాలకంగా తనిఖీ చేసే సాధనాలను ఉపయోగిస్తుంది. కాంట్రాక్ట్ కార్యాచరణల మూల్యాంకనానికి మార్గనిర్దేశం చేయడానికి [స్క్రిప్ట్‌లను](https://www.techtarget.com/whatis/definition/script?amp=1) ఉపయోగించడం ద్వారా ఆటోమేటెడ్ టెస్టింగ్ ప్రయోజనం లభిస్తుంది. స్క్రిప్ట్ చేయబడిన టెస్ట్‌లను కనీస మానవ జోక్యంతో పదేపదే అమలు చేయడానికి షెడ్యూల్ చేయవచ్చు, ఇది మాన్యువల్ టెస్టింగ్ విధానాల కంటే ఆటోమేటెడ్ టెస్టింగ్‌ను మరింత సమర్థవంతంగా చేస్తుంది.

టెస్ట్‌లు పునరావృతమయ్యేవి మరియు సమయం తీసుకునేవి అయినప్పుడు; మాన్యువల్‌గా నిర్వహించడం కష్టమైనప్పుడు; మానవ తప్పిదాలకు గురయ్యే అవకాశం ఉన్నప్పుడు; లేదా క్లిష్టమైన కాంట్రాక్ట్ ఫంక్షన్‌లను మూల్యాంకనం చేయాల్సి వచ్చినప్పుడు ఆటోమేటెడ్ టెస్టింగ్ ప్రత్యేకంగా ఉపయోగపడుతుంది. కానీ ఆటోమేటెడ్ టెస్టింగ్ సాధనాలకు లోపాలు ఉండవచ్చు—అవి కొన్ని బగ్‌లను కోల్పోవచ్చు మరియు అనేక [ఫాల్స్ పాజిటివ్‌లను](https://www.contrastsecurity.com/glossary/false-positive) ఉత్పత్తి చేయవచ్చు. అందువల్ల, స్మార్ట్ కాంట్రాక్ట్‌ల కోసం ఆటోమేటెడ్ టెస్టింగ్‌ను మాన్యువల్ టెస్టింగ్‌తో జత చేయడం అనువైనది.

### మాన్యువల్ టెస్టింగ్ {#manual-testing}

మాన్యువల్ టెస్టింగ్ అనేది మానవ-సహాయంతో జరుగుతుంది మరియు స్మార్ట్ కాంట్రాక్ట్ ఖచ్చితత్వాన్ని విశ్లేషించేటప్పుడు మీ టెస్ట్ సూట్‌లోని ప్రతి టెస్ట్ కేసును ఒకదాని తర్వాత ఒకటి అమలు చేయడం ఇందులో ఉంటుంది. ఇది ఆటోమేటెడ్ టెస్టింగ్ లాగా ఉండదు, ఇక్కడ మీరు ఒక కాంట్రాక్ట్‌పై ఏకకాలంలో బహుళ వివిక్త టెస్ట్‌లను అమలు చేయవచ్చు మరియు విఫలమైన మరియు ఉత్తీర్ణమైన అన్ని టెస్ట్‌లను చూపే నివేదికను పొందవచ్చు.

వివిధ టెస్ట్ దృశ్యాలను కవర్ చేసే వ్రాతపూర్వక టెస్ట్ ప్లాన్‌ను అనుసరించి ఒకే వ్యక్తి మాన్యువల్ టెస్టింగ్‌ను నిర్వహించవచ్చు. మాన్యువల్ టెస్టింగ్‌లో భాగంగా మీరు నిర్దిష్ట వ్యవధిలో స్మార్ట్ కాంట్రాక్ట్‌తో పరస్పర చర్య చేయడానికి బహుళ వ్యక్తులు లేదా సమూహాలను కూడా కలిగి ఉండవచ్చు. టెస్టర్‌లు కాంట్రాక్ట్ యొక్క వాస్తవ ప్రవర్తనను ఆశించిన ప్రవర్తనతో పోల్చి చూస్తారు, ఏదైనా వ్యత్యాసాన్ని బగ్‌గా ఫ్లాగ్ చేస్తారు.

సమర్థవంతమైన మాన్యువల్ టెస్టింగ్‌కు గణనీయమైన వనరులు (నైపుణ్యం, సమయం, డబ్బు మరియు కృషి) అవసరం, మరియు టెస్ట్‌లను అమలు చేస్తున్నప్పుడు మానవ తప్పిదం కారణంగా కొన్ని లోపాలను కోల్పోయే అవకాశం ఉంది. కానీ మాన్యువల్ టెస్టింగ్ కూడా ప్రయోజనకరంగా ఉంటుంది—ఉదాహరణకు, ఆటోమేటెడ్ టెస్టింగ్ సాధనం కోల్పోయే ఎడ్జ్ కేసులను గుర్తించడానికి మానవ టెస్టర్ (ఉదా., ఆడిటర్) అంతర్ దృష్టిని ఉపయోగించవచ్చు.

## స్మార్ట్ కాంట్రాక్ట్‌ల కోసం ఆటోమేటెడ్ టెస్టింగ్ {#automated-testing-for-smart-contracts}

### యూనిట్ టెస్టింగ్ {#unit-testing-for-smart-contracts}

యూనిట్ టెస్టింగ్ కాంట్రాక్ట్ ఫంక్షన్‌లను విడిగా అంచనా వేస్తుంది మరియు ప్రతి భాగం సరిగ్గా పనిచేస్తుందో లేదో తనిఖీ చేస్తుంది. మంచి యూనిట్ టెస్ట్‌లు సరళంగా ఉండాలి, త్వరగా అమలు కావాలి మరియు టెస్ట్‌లు విఫలమైతే ఏమి తప్పు జరిగిందో స్పష్టమైన ఆలోచనను అందించాలి.

ఫంక్షన్‌లు ఆశించిన విలువలను అందిస్తాయో లేదో మరియు ఫంక్షన్ అమలు తర్వాత కాంట్రాక్ట్ నిల్వ సరిగ్గా నవీకరించబడిందో లేదో తనిఖీ చేయడానికి యూనిట్ టెస్ట్‌లు ఉపయోగపడతాయి. అంతేకాకుండా, కాంట్రాక్ట్ కోడ్‌బేస్‌లో మార్పులు చేసిన తర్వాత యూనిట్ టెస్ట్‌లను అమలు చేయడం వల్ల కొత్త లాజిక్‌ను జోడించడం వల్ల లోపాలు రాకుండా చూసుకోవచ్చు. సమర్థవంతమైన యూనిట్ టెస్ట్‌లను అమలు చేయడానికి క్రింద కొన్ని మార్గదర్శకాలు ఉన్నాయి:

#### స్మార్ట్ కాంట్రాక్ట్‌ల యూనిట్ టెస్టింగ్ కోసం మార్గదర్శకాలు {#unit-testing-guidelines}

##### 1. మీ కాంట్రాక్ట్ వ్యాపార లాజిక్ మరియు వర్క్‌ఫ్లోను అర్థం చేసుకోండి

యూనిట్ టెస్ట్‌లను రాయడానికి ముందు, స్మార్ట్ కాంట్రాక్ట్ ఏ కార్యాచరణలను అందిస్తుందో మరియు వినియోగదారులు ఆ ఫంక్షన్‌లను ఎలా యాక్సెస్ చేస్తారో మరియు ఉపయోగిస్తారో తెలుసుకోవడం సహాయపడుతుంది. చెల్లుబాటు అయ్యే వినియోగదారు ఇన్‌పుట్‌ల కోసం కాంట్రాక్ట్‌లోని ఫంక్షన్‌లు సరైన అవుట్‌పుట్‌ను అందిస్తాయో లేదో నిర్ణయించే [హ్యాపీ పాత్ టెస్ట్‌లను](https://en.m.wikipedia.org/wiki/Happy_path) అమలు చేయడానికి ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. [వేలం కాంట్రాక్ట్](https://docs.soliditylang.org/en/v0.8.17/solidity-by-example.html?highlight=Auction%20contract#simple-open-auction) యొక్క ఈ (సంక్షిప్త) ఉదాహరణను ఉపయోగించి మేము ఈ భావనను వివరిస్తాము

```solidity
constructor(
        uint biddingTime,
        address payable beneficiaryAddress
    ) {
        beneficiary = beneficiaryAddress;
        auctionEndTime = block.timestamp + biddingTime;
    }

function bid() external payable {

      if (block.timestamp > auctionEndTime)
            revert AuctionAlreadyEnded();

      if (msg.value <= highestBid)
            revert BidNotHighEnough(highestBid);

 if (highestBid != 0) {
    pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
    }

 function withdraw() external returns (bool) {
        uint amount = pendingReturns[msg.sender];
        if (amount > 0) {
           pendingReturns[msg.sender] = 0;

        if (!payable(msg.sender).send(amount)) {
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

function auctionEnd() external {
       if (block.timestamp < auctionEndTime)
            revert AuctionNotYetEnded();
        if (ended)
            revert AuctionEndAlreadyCalled();

        ended = true;
        emit AuctionEnded(highestBidder, highestBid);

        beneficiary.transfer(highestBid);
    }
}
```

ఇది బిడ్డింగ్ వ్యవధిలో బిడ్‌లను స్వీకరించడానికి రూపొందించబడిన ఒక సాధారణ వేలం కాంట్రాక్ట్. `highestBid` పెరిగితే, మునుపటి అత్యధిక బిడ్డర్ వారి డబ్బును అందుకుంటారు; బిడ్డింగ్ వ్యవధి ముగిసిన తర్వాత, `beneficiary` వారి డబ్బును పొందడానికి కాంట్రాక్ట్‌ను పిలుస్తారు.

ఇలాంటి కాంట్రాక్ట్ కోసం యూనిట్ టెస్ట్‌లు కాంట్రాక్ట్‌తో పరస్పర చర్య చేస్తున్నప్పుడు వినియోగదారు కాల్ చేయగల విభిన్న ఫంక్షన్‌లను కవర్ చేస్తాయి. వేలం కొనసాగుతున్నప్పుడు వినియోగదారు బిడ్ వేయగలరో లేదో తనిఖీ చేసే యూనిట్ టెస్ట్ (అంటే, `bid()` కు కాల్‌లు విజయవంతమవుతాయి) లేదా ప్రస్తుత `highestBid` కంటే వినియోగదారు ఎక్కువ బిడ్ వేయగలరో లేదో తనిఖీ చేసేది ఒక ఉదాహరణ.

కాంట్రాక్ట్ కార్యాచరణ వర్క్‌ఫ్లోను అర్థం చేసుకోవడం అమలు అవసరాలకు అనుగుణంగా ఉందో లేదో తనిఖీ చేసే యూనిట్ టెస్ట్‌లను రాయడంలో కూడా సహాయపడుతుంది. ఉదాహరణకు, వేలం ముగిసినప్పుడు (అంటే, `auctionEndTime` `block.timestamp` కంటే తక్కువగా ఉన్నప్పుడు) వినియోగదారులు బిడ్‌లను వేయలేరని వేలం కాంట్రాక్ట్ నిర్దేశిస్తుంది. అందువల్ల, వేలం ముగిసినప్పుడు (అంటే, `auctionEndTime` > `block.timestamp` ఉన్నప్పుడు) `bid()` ఫంక్షన్‌కు కాల్‌లు విజయవంతమవుతాయా లేదా విఫలమవుతాయా అని తనిఖీ చేసే యూనిట్ టెస్ట్‌ను డెవలపర్ అమలు చేయవచ్చు.

##### 2. కాంట్రాక్ట్ అమలుకు సంబంధించిన అన్ని ఉపకల్పనలను అంచనా వేయండి

కాంట్రాక్ట్ అమలు గురించి ఏవైనా ఉపకల్పనలను డాక్యుమెంట్ చేయడం మరియు ఆ ఉపకల్పనల చెల్లుబాటును ధృవీకరించడానికి యూనిట్ టెస్ట్‌లను రాయడం ముఖ్యం. ఊహించని అమలు నుండి రక్షణ కల్పించడమే కాకుండా, నిర్ధారణలను టెస్ట్ చేయడం స్మార్ట్ కాంట్రాక్ట్ భద్రతా నమూనాను విచ్ఛిన్నం చేసే కార్యకలాపాల గురించి ఆలోచించేలా చేస్తుంది. ఒక ఉపయోగకరమైన చిట్కా ఏమిటంటే "హ్యాపీ యూజర్ టెస్ట్‌ల"కు మించి వెళ్లి, తప్పు ఇన్‌పుట్‌ల కోసం ఫంక్షన్ విఫలమవుతుందో లేదో తనిఖీ చేసే నెగటివ్ టెస్ట్‌లను రాయడం.

అనేక యూనిట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లు నిర్ధారణలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి—కాంట్రాక్ట్ ఏమి చేయగలదో మరియు ఏమి చేయలేదో తెలిపే సాధారణ ప్రకటనలు—మరియు ఆ నిర్ధారణలు అమలులో ఉన్నాయో లేదో చూడటానికి టెస్ట్‌లను అమలు చేస్తాయి. ముందుగా వివరించిన వేలం కాంట్రాక్ట్‌పై పనిచేస్తున్న డెవలపర్ నెగటివ్ టెస్ట్‌లను అమలు చేయడానికి ముందు దాని ప్రవర్తన గురించి ఈ క్రింది నిర్ధారణలను చేయవచ్చు:

- వేలం ముగిసినప్పుడు లేదా ప్రారంభం కానప్పుడు వినియోగదారులు బిడ్‌లను వేయలేరు.

- బిడ్ ఆమోదయోగ్యమైన పరిమితి కంటే తక్కువగా ఉంటే వేలం కాంట్రాక్ట్ వెనక్కి మళ్లుతుంది.

- బిడ్‌ను గెలుచుకోవడంలో విఫలమైన వినియోగదారులకు వారి నిధులు జమ చేయబడతాయి

**గమనిక**: ఉపకల్పనలను టెస్ట్ చేయడానికి మరొక మార్గం కాంట్రాక్ట్‌లో [ఫంక్షన్ మాడిఫైయర్‌లను](https://docs.soliditylang.org/en/v0.8.16/contracts.html#function-modifiers), ముఖ్యంగా `require`, `assert`, మరియు `if…else` స్టేట్‌మెంట్‌లను ట్రిగ్గర్ చేసే టెస్ట్‌లను రాయడం.

##### 3. కోడ్ కవరేజీని కొలవండి

[కోడ్ కవరేజ్](https://en.m.wikipedia.org/wiki/Code_coverage) అనేది టెస్ట్‌ల సమయంలో అమలు చేయబడిన మీ కోడ్‌లోని బ్రాంచ్‌లు, లైన్‌లు మరియు స్టేట్‌మెంట్‌ల సంఖ్యను ట్రాక్ చేసే టెస్టింగ్ మెట్రిక్. టెస్ట్ చేయని దుర్బలత్వాల ప్రమాదాన్ని తగ్గించడానికి టెస్ట్‌లు మంచి కోడ్ కవరేజీని కలిగి ఉండాలి. తగినంత కవరేజ్ లేకుండా, అన్ని టెస్ట్‌లు ఉత్తీర్ణత సాధించినందున మీ కాంట్రాక్ట్ సురక్షితమైనదని మీరు తప్పుగా భావించవచ్చు, అయితే టెస్ట్ చేయని కోడ్ మార్గాల్లో దుర్బలత్వాలు ఇంకా ఉండవచ్చు. అయితే, అధిక కోడ్ కవరేజీని రికార్డ్ చేయడం వల్ల స్మార్ట్ కాంట్రాక్ట్‌లోని అన్ని స్టేట్‌మెంట్‌లు/ఫంక్షన్‌లు ఖచ్చితత్వం కోసం తగినంతగా టెస్ట్ చేయబడ్డాయనే భరోసా లభిస్తుంది.

##### 4. బాగా అభివృద్ధి చెందిన టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లను ఉపయోగించండి

మీ స్మార్ట్ కాంట్రాక్ట్‌ల కోసం యూనిట్ టెస్ట్‌లను అమలు చేయడంలో ఉపయోగించే సాధనాల నాణ్యత చాలా ముఖ్యం. అనువైన టెస్టింగ్ ఫ్రేమ్‌వర్క్ అనేది క్రమం తప్పకుండా నిర్వహించబడేది; ఉపయోగకరమైన లక్షణాలను (ఉదా., లాగింగ్ మరియు రిపోర్టింగ్ సామర్థ్యాలు) అందిస్తుంది; మరియు ఇతర డెవలపర్‌లచే విస్తృతంగా ఉపయోగించబడి మరియు పరిశీలించబడి ఉండాలి.

Solidity స్మార్ట్ కాంట్రాక్ట్‌ల కోసం యూనిట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లు విభిన్న భాషలలో (ఎక్కువగా JavaScript, Python మరియు Rust) వస్తాయి. విభిన్న టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లతో యూనిట్ టెస్ట్‌లను అమలు చేయడం ఎలా ప్రారంభించాలో సమాచారం కోసం దిగువన ఉన్న కొన్ని మార్గదర్శకాలను చూడండి:

- **[Brownie తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)**
- **[Foundry తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://book.getfoundry.sh/forge/writing-tests)**
- **[Waffle తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)**
- **[Remix తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://remix-ide.readthedocs.io/en/latest/unittesting.html#write-tests)**
- **[Ape తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://docs.apeworx.io/ape/stable/userguides/testing.html)**
- **[Hardhat తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)**
- **[Wake తో యూనిట్ టెస్ట్‌లను అమలు చేయడం](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)**

### ఇంటిగ్రేషన్ టెస్టింగ్ {#integration-testing-for-smart-contracts}

యూనిట్ టెస్టింగ్ కాంట్రాక్ట్ ఫంక్షన్‌లను విడిగా డీబగ్ చేస్తున్నప్పుడు, ఇంటిగ్రేషన్ టెస్ట్‌లు స్మార్ట్ కాంట్రాక్ట్ భాగాలను మొత్తంగా అంచనా వేస్తాయి. ఇంటిగ్రేషన్ టెస్టింగ్ క్రాస్-కాంట్రాక్ట్ కాల్స్ లేదా ఒకే స్మార్ట్ కాంట్రాక్ట్‌లోని విభిన్న ఫంక్షన్‌ల మధ్య పరస్పర చర్యల వల్ల తలెత్తే సమస్యలను గుర్తించగలదు. ఉదాహరణకు, [వారసత్వం](https://docs.soliditylang.org/en/v0.8.12/contracts.html#inheritance) మరియు డిపెండెన్సీ ఇంజెక్షన్ వంటివి సరిగ్గా పనిచేస్తాయో లేదో తనిఖీ చేయడానికి ఇంటిగ్రేషన్ టెస్ట్‌లు సహాయపడతాయి.

మీ కాంట్రాక్ట్ మాడ్యులర్ ఆర్కిటెక్చర్‌ను అవలంబిస్తే లేదా అమలు సమయంలో ఇతర ఆన్‌చైన్ కాంట్రాక్ట్‌లతో ఇంటర్‌ఫేస్ అయితే ఇంటిగ్రేషన్ టెస్టింగ్ ఉపయోగపడుతుంది. ఇంటిగ్రేషన్ టెస్ట్‌లను అమలు చేయడానికి ఒక మార్గం ఏమిటంటే, నిర్దిష్ట ఎత్తులో [బ్లాక్‌చైన్‌ను ఫోర్క్ చేయడం](/glossary/#fork) ([Forge](https://book.getfoundry.sh/forge/fork-testing) లేదా [Hardhat](https://hardhat.org/hardhat-network/docs/guides/forking-other-networks) వంటి సాధనాన్ని ఉపయోగించి) మరియు మీ కాంట్రాక్ట్ మరియు డిప్లాయ్ చేయబడిన కాంట్రాక్ట్‌ల మధ్య పరస్పర చర్యలను అనుకరించడం.

ఫోర్క్ చేయబడిన బ్లాక్‌చైన్ మెయిన్‌నెట్ మాదిరిగానే ప్రవర్తిస్తుంది మరియు అనుబంధిత స్థితులు మరియు బ్యాలెన్స్‌లతో ఖాతాలను కలిగి ఉంటుంది. కానీ ఇది శాండ్‌బాక్స్ చేయబడిన స్థానిక అభివృద్ధి వాతావరణంగా మాత్రమే పనిచేస్తుంది, అంటే ఉదాహరణకు లావాదేవీల కోసం మీకు నిజమైన ETH అవసరం లేదు, లేదా మీ మార్పులు నిజమైన ఎథీరియం ప్రోటోకాల్‌ను ప్రభావితం చేయవు.

### ప్రాపర్టీ-ఆధారిత టెస్టింగ్ {#property-based-testing-for-smart-contracts}

ప్రాపర్టీ-ఆధారిత టెస్టింగ్ అనేది స్మార్ట్ కాంట్రాక్ట్ కొన్ని నిర్వచించబడిన ప్రాపర్టీని సంతృప్తి పరుస్తుందో లేదో తనిఖీ చేసే ప్రక్రియ. ప్రాపర్టీలు విభిన్న దృశ్యాలలో నిజంగా ఉంటాయని ఆశించే కాంట్రాక్ట్ ప్రవర్తన గురించి వాస్తవాలను నొక్కి చెబుతాయి—స్మార్ట్ కాంట్రాక్ట్ ప్రాపర్టీకి ఉదాహరణ "కాంట్రాక్ట్‌లోని అంకగణిత కార్యకలాపాలు ఎప్పుడూ ఓవర్‌ఫ్లో లేదా అండర్‌ఫ్లో కావు."

**స్టాటిక్ అనాలిసిస్** మరియు **డైనమిక్ అనాలిసిస్** అనేవి ప్రాపర్టీ-ఆధారిత టెస్టింగ్‌ను అమలు చేయడానికి రెండు సాధారణ పద్ధతులు, మరియు ప్రోగ్రామ్ (ఈ సందర్భంలో స్మార్ట్ కాంట్రాక్ట్) కోసం కోడ్ కొన్ని ముందే నిర్వచించిన ప్రాపర్టీని సంతృప్తి పరుస్తుందని రెండూ ధృవీకరించగలవు. కొన్ని ప్రాపర్టీ-ఆధారిత టెస్టింగ్ సాధనాలు ఆశించిన కాంట్రాక్ట్ ప్రాపర్టీల గురించి ముందే నిర్వచించిన నియమాలతో వస్తాయి మరియు ఆ నియమాలకు వ్యతిరేకంగా కోడ్‌ను తనిఖీ చేస్తాయి, మరికొన్ని స్మార్ట్ కాంట్రాక్ట్ కోసం అనుకూల ప్రాపర్టీలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి.

#### స్టాటిక్ అనాలిసిస్ {#static-analysis}

స్టాటిక్ ఎనలైజర్ స్మార్ట్ కాంట్రాక్ట్ సోర్స్ కోడ్‌ను ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు కాంట్రాక్ట్ ప్రాపర్టీని సంతృప్తి పరుస్తుందో లేదో ప్రకటించే ఫలితాలను అవుట్‌పుట్ చేస్తుంది. డైనమిక్ అనాలిసిస్ వలె కాకుండా, స్టాటిక్ అనాలిసిస్‌లో ఖచ్చితత్వం కోసం విశ్లేషించడానికి కాంట్రాక్ట్‌ను అమలు చేయడం ఉండదు. స్టాటిక్ అనాలిసిస్ బదులుగా అమలు సమయంలో స్మార్ట్ కాంట్రాక్ట్ తీసుకోగల అన్ని సాధ్యమైన మార్గాల గురించి వివరిస్తుంది (అంటే, రన్‌టైమ్‌లో కాంట్రాక్ట్ ఆపరేషన్‌కు దీని అర్థం ఏమిటో నిర్ణయించడానికి సోర్స్ కోడ్ నిర్మాణాన్ని పరిశీలించడం ద్వారా).

కాంట్రాక్ట్‌లపై స్టాటిక్ అనాలిసిస్‌ను అమలు చేయడానికి [లింటింగ్](https://www.perforce.com/blog/qac/what-is-linting) మరియు [స్టాటిక్ టెస్టింగ్](https://www.techtarget.com/whatis/definition/static-analysis-static-code-analysis) సాధారణ పద్ధతులు. రెండింటికీ కంపైలర్ ద్వారా అవుట్‌పుట్ చేయబడిన [అబ్‌స్ట్రాక్ట్ సింటాక్స్ ట్రీలు](https://en.m.wikipedia.org/wiki/Abstract_syntax_tree) మరియు [కంట్రోల్ ఫ్లో గ్రాఫ్‌ల](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/amp/) వంటి కాంట్రాక్ట్ అమలు యొక్క తక్కువ-స్థాయి ప్రాతినిధ్యాలను విశ్లేషించడం అవసరం.

చాలా సందర్భాలలో, కాంట్రాక్ట్ కోడ్‌లో అసురక్షిత నిర్మాణాల ఉపయోగం, సింటాక్స్ లోపాలు లేదా కోడింగ్ ప్రమాణాల ఉల్లంఘనల వంటి భద్రతా సమస్యలను గుర్తించడానికి స్టాటిక్ అనాలిసిస్ ఉపయోగపడుతుంది. అయినప్పటికీ, స్టాటిక్ ఎనలైజర్‌లు లోతైన దుర్బలత్వాలను గుర్తించడంలో సాధారణంగా అస్థిరంగా ఉంటాయని తెలుసు, మరియు అధిక ఫాల్స్ పాజిటివ్‌లను ఉత్పత్తి చేయవచ్చు.

#### డైనమిక్ అనాలిసిస్ {#dynamic-analysis}

ఏదైనా అమలు ట్రేస్(లు) నిర్దిష్ట ప్రాపర్టీలను ఉల్లంఘిస్తుందో లేదో చూడటానికి డైనమిక్ అనాలిసిస్ స్మార్ట్ కాంట్రాక్ట్ ఫంక్షన్‌లకు సింబాలిక్ ఇన్‌పుట్‌లను (ఉదా., [సింబాలిక్ ఎగ్జిక్యూషన్](https://en.m.wikipedia.org/wiki/Symbolic_execution) లో) లేదా కాంక్రీట్ ఇన్‌పుట్‌లను (ఉదా., [ఫజ్జింగ్](https://owasp.org/www-community/Fuzzing) లో) ఉత్పత్తి చేస్తుంది. ఈ రకమైన ప్రాపర్టీ-ఆధారిత టెస్టింగ్ యూనిట్ టెస్ట్‌ల నుండి భిన్నంగా ఉంటుంది, ఇందులో టెస్ట్ కేసులు బహుళ దృశ్యాలను కవర్ చేస్తాయి మరియు ప్రోగ్రామ్ టెస్ట్ కేసుల ఉత్పత్తిని నిర్వహిస్తుంది.

స్మార్ట్ కాంట్రాక్ట్‌లలో ఏకపక్ష ప్రాపర్టీలను ధృవీకరించడానికి డైనమిక్ అనాలిసిస్ టెక్నిక్‌కు [ఫజ్జింగ్](https://www.halborn.com/blog/post/what-is-fuzz-testing-fuzzing) ఒక ఉదాహరణ. ఫజ్జర్ నిర్వచించబడిన ఇన్‌పుట్ విలువ యొక్క యాదృచ్ఛిక లేదా తప్పుగా రూపొందించబడిన వైవిధ్యాలతో లక్ష్య కాంట్రాక్ట్‌లోని ఫంక్షన్‌లను ప్రేరేపిస్తుంది. స్మార్ట్ కాంట్రాక్ట్ ఎర్రర్ స్థితికి ప్రవేశిస్తే (ఉదా., నిర్ధారణ విఫలమయ్యే చోట), సమస్య ఫ్లాగ్ చేయబడుతుంది మరియు దుర్బలమైన మార్గం వైపు అమలును నడిపించే ఇన్‌పుట్‌లు నివేదికలో ఉత్పత్తి చేయబడతాయి.

ఊహించని ఇన్‌పుట్‌లను సరిగ్గా నిర్వహించకపోవడం అనాలోచిత అమలుకు దారితీయవచ్చు మరియు ప్రమాదకరమైన ప్రభావాలను చూపుతుంది కాబట్టి స్మార్ట్ కాంట్రాక్ట్ ఇన్‌పుట్ ధ్రువీకరణ యంత్రాంగాన్ని అంచనా వేయడానికి ఫజ్జింగ్ ఉపయోగపడుతుంది. ఈ రకమైన ప్రాపర్టీ-ఆధారిత టెస్టింగ్ అనేక కారణాల వల్ల అనువైనదిగా ఉంటుంది:

1. **అనేక దృశ్యాలను కవర్ చేయడానికి టెస్ట్ కేసులను రాయడం కష్టం.** ప్రాపర్టీ టెస్ట్‌కు మీరు ప్రవర్తనను మరియు ప్రవర్తనను టెస్ట్ చేయడానికి డేటా పరిధిని నిర్వచించడం మాత్రమే అవసరం—ప్రోగ్రామ్ నిర్వచించిన ప్రాపర్టీ ఆధారంగా స్వయంచాలకంగా టెస్ట్ కేసులను ఉత్పత్తి చేస్తుంది.

2. **మీ టెస్ట్ సూట్ ప్రోగ్రామ్‌లోని అన్ని సాధ్యమైన మార్గాలను తగినంతగా కవర్ చేయకపోవచ్చు.** 100% కవరేజీతో కూడా, ఎడ్జ్ కేసులను కోల్పోయే అవకాశం ఉంది.

3. **నమూనా డేటా కోసం కాంట్రాక్ట్ సరిగ్గా అమలు అవుతుందని యూనిట్ టెస్ట్‌లు నిరూపిస్తాయి, అయితే నమూనా వెలుపల ఉన్న ఇన్‌పుట్‌ల కోసం కాంట్రాక్ట్ సరిగ్గా అమలు అవుతుందా అనేది తెలియదు.** నిర్ధారణ వైఫల్యాలకు కారణమయ్యే అమలు ట్రేస్‌లను కనుగొనడానికి ప్రాపర్టీ టెస్ట్‌లు ఇచ్చిన ఇన్‌పుట్ విలువ యొక్క బహుళ వైవిధ్యాలతో లక్ష్య కాంట్రాక్ట్‌ను అమలు చేస్తాయి. అందువల్ల, విస్తృత తరగతి ఇన్‌పుట్ డేటా కోసం కాంట్రాక్ట్ సరిగ్గా అమలు అవుతుందని ప్రాపర్టీ టెస్ట్ మరిన్ని హామీలను అందిస్తుంది.

### స్మార్ట్ కాంట్రాక్ట్‌ల కోసం ప్రాపర్టీ-ఆధారిత టెస్టింగ్‌ను అమలు చేయడానికి మార్గదర్శకాలు {#running-property-based-tests}

ప్రాపర్టీ-ఆధారిత టెస్టింగ్‌ను అమలు చేయడం సాధారణంగా మీరు స్మార్ట్ కాంట్రాక్ట్‌లో ధృవీకరించాలనుకుంటున్న ప్రాపర్టీని (ఉదా., [పూర్ణాంక ఓవర్‌ఫ్లోలు](https://github.com/ConsenSysDiligence/mythril/wiki/Integer-Overflow) లేకపోవడం) లేదా ప్రాపర్టీల సేకరణను నిర్వచించడంతో ప్రారంభమవుతుంది. ప్రాపర్టీ టెస్ట్‌లను రాసేటప్పుడు లావాదేవీ ఇన్‌పుట్‌ల కోసం ప్రోగ్రామ్ డేటాను ఉత్పత్తి చేయగల విలువల పరిధిని కూడా మీరు నిర్వచించాల్సి ఉంటుంది.

సరిగ్గా కాన్ఫిగర్ చేసిన తర్వాత, ప్రాపర్టీ టెస్టింగ్ సాధనం యాదృచ్ఛికంగా రూపొందించబడిన ఇన్‌పుట్‌లతో మీ స్మార్ట్ కాంట్రాక్ట్ ఫంక్షన్‌లను అమలు చేస్తుంది. ఏవైనా నిర్ధారణ ఉల్లంఘనలు ఉంటే, మూల్యాంకనంలో ఉన్న ప్రాపర్టీని ఉల్లంఘించే కాంక్రీట్ ఇన్‌పుట్ డేటాతో మీరు నివేదికను పొందాలి. విభిన్న సాధనాలతో ప్రాపర్టీ-ఆధారిత టెస్టింగ్‌ను అమలు చేయడం ప్రారంభించడానికి దిగువన ఉన్న కొన్ని మార్గదర్శకాలను చూడండి:

- **[స్లిదర్ తో స్మార్ట్ కాంట్రాక్ట్‌ల స్టాటిక్ అనాలిసిస్](https://github.com/crytic/slither)**
- **[Wake తో స్మార్ట్ కాంట్రాక్ట్‌ల స్టాటిక్ అనాలిసిస్](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)**
- **[Brownie తో ప్రాపర్టీ-ఆధారిత టెస్టింగ్](https://eth-brownie.readthedocs.io/en/stable/tests-hypothesis-property.html)**
- **[Foundry తో కాంట్రాక్ట్‌ల ఫజ్జింగ్](https://book.getfoundry.sh/forge/fuzz-testing)**
- **[ఎకిడ్నా తో కాంట్రాక్ట్‌ల ఫజ్జింగ్](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial)**
- **[Wake తో కాంట్రాక్ట్‌ల ఫజ్జింగ్](https://ackeeblockchain.com/wake/docs/latest/testing-framework/fuzzing/)**
- **[మాంటికోర్ తో స్మార్ట్ కాంట్రాక్ట్‌ల సింబాలిక్ ఎగ్జిక్యూషన్](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore#manticore-tutorial)**
- **[Mythril తో స్మార్ట్ కాంట్రాక్ట్‌ల సింబాలిక్ ఎగ్జిక్యూషన్](https://github.com/ConsenSysDiligence/mythril/blob/develop/docs/source/tutorial.rst)**

## స్మార్ట్ కాంట్రాక్ట్‌ల కోసం మాన్యువల్ టెస్టింగ్ {#manual-testing-for-smart-contracts}

స్మార్ట్ కాంట్రాక్ట్‌ల మాన్యువల్ టెస్టింగ్ తరచుగా ఆటోమేటెడ్ టెస్ట్‌లను అమలు చేసిన తర్వాత అభివృద్ధి చక్రంలో వస్తుంది. ఈ రకమైన టెస్టింగ్ స్మార్ట్ కాంట్రాక్ట్‌ను ఒక పూర్తి ఇంటిగ్రేటెడ్ ఉత్పత్తిగా అంచనా వేస్తుంది, ఇది సాంకేతిక అవసరాలలో పేర్కొన్న విధంగా పనిచేస్తుందో లేదో చూడటానికి.

### స్థానిక బ్లాక్‌చైన్‌లో కాంట్రాక్ట్‌లను టెస్ట్ చేయడం {#testing-on-local-blockchain}

స్థానిక అభివృద్ధి వాతావరణంలో నిర్వహించబడే ఆటోమేటెడ్ టెస్టింగ్ ఉపయోగకరమైన డీబగ్గింగ్ సమాచారాన్ని అందించగలిగినప్పటికీ, ఉత్పత్తి వాతావరణంలో మీ స్మార్ట్ కాంట్రాక్ట్ ఎలా ప్రవర్తిస్తుందో మీరు తెలుసుకోవాలనుకుంటారు. అయినప్పటికీ, ప్రధాన ఎథీరియం చైన్‌కు డిప్లాయ్ చేయడానికి గ్యాస్ ఫీజులు చెల్లించాల్సి ఉంటుంది—మీ స్మార్ట్ కాంట్రాక్ట్‌లో ఇంకా బగ్‌లు ఉంటే మీరు లేదా మీ వినియోగదారులు నిజమైన డబ్బును కోల్పోవచ్చని ప్రత్యేకంగా చెప్పనవసరం లేదు.

స్థానిక బ్లాక్‌చైన్‌లో (దీనిని [డెవలప్‌మెంట్ నెట్‌వర్క్](/developers/docs/development-networks/) అని కూడా పిలుస్తారు) మీ కాంట్రాక్ట్‌ను టెస్ట్ చేయడం మెయిన్‌నెట్‌లో టెస్ట్ చేయడానికి సిఫార్సు చేయబడిన ప్రత్యామ్నాయం. స్థానిక బ్లాక్‌చైన్ అనేది మీ కంప్యూటర్‌లో స్థానికంగా నడుస్తున్న ఎథీరియం బ్లాక్‌చైన్ యొక్క కాపీ, ఇది ఎథీరియం యొక్క అమలు పొర ప్రవర్తనను అనుకరిస్తుంది. అందువల్ల, మీరు గణనీయమైన ఓవర్‌హెడ్ లేకుండా కాంట్రాక్ట్‌తో పరస్పర చర్య చేయడానికి లావాదేవీలను ప్రోగ్రామ్ చేయవచ్చు.

స్థానిక బ్లాక్‌చైన్‌లో కాంట్రాక్ట్‌లను అమలు చేయడం మాన్యువల్ ఇంటిగ్రేషన్ టెస్టింగ్ రూపంగా ఉపయోగపడుతుంది. [స్మార్ట్ కాంట్రాక్ట్‌లు అత్యంత కూర్చదగినవి](/developers/docs/smart-contracts/composability/), ఇవి ఇప్పటికే ఉన్న ప్రోటోకాల్‌లతో ఏకీకృతం కావడానికి మిమ్మల్ని అనుమతిస్తాయి—కానీ అటువంటి సంక్లిష్టమైన ఆన్‌చైన్ పరస్పర చర్యలు సరైన ఫలితాలను ఇస్తాయని మీరు ఇంకా నిర్ధారించుకోవాలి.

[డెవలప్‌మెంట్ నెట్‌వర్క్‌ల గురించి మరింత.](/developers/docs/development-networks/)

### టెస్ట్‌నెట్‌లలో కాంట్రాక్ట్‌లను టెస్ట్ చేయడం {#testing-contracts-on-testnets}

టెస్ట్ నెట్‌వర్క్ లేదా టెస్ట్‌నెట్ ఎథీరియం మెయిన్‌నెట్ లాగానే పనిచేస్తుంది, అయితే ఇది వాస్తవ-ప్రపంచ విలువ లేని ఈథర్ (ETH) ను ఉపయోగిస్తుంది. మీ కాంట్రాక్ట్‌ను [టెస్ట్‌నెట్](/developers/docs/networks/#ethereum-testnets) లో డిప్లాయ్ చేయడం అంటే నిధులను ప్రమాదంలో పడేయకుండా ఎవరైనా దానితో పరస్పర చర్య చేయవచ్చు (ఉదా., dapp యొక్క ఫ్రంటెండ్ ద్వారా).

వినియోగదారు కోణం నుండి మీ అప్లికేషన్ యొక్క ఎండ్-టు-ఎండ్ ప్రవాహాన్ని అంచనా వేయడానికి ఈ రకమైన మాన్యువల్ టెస్టింగ్ ఉపయోగపడుతుంది. ఇక్కడ, బీటా టెస్టర్‌లు ట్రయల్ రన్‌లను కూడా చేయవచ్చు మరియు కాంట్రాక్ట్ వ్యాపార లాజిక్ మరియు మొత్తం కార్యాచరణతో ఏవైనా సమస్యలను నివేదించవచ్చు.

స్థానిక బ్లాక్‌చైన్‌లో టెస్ట్ చేసిన తర్వాత టెస్ట్‌నెట్‌లో డిప్లాయ్ చేయడం అనువైనది ఎందుకంటే మునుపటిది ఎథీరియం వర్చువల్ మెషిన్ ప్రవర్తనకు దగ్గరగా ఉంటుంది. అందువల్ల, వాస్తవ-ప్రపంచ పరిస్థితులలో స్మార్ట్ కాంట్రాక్ట్ ఆపరేషన్‌ను అంచనా వేయడానికి అనేక ఎథీరియం-స్థానిక ప్రాజెక్ట్‌లు టెస్ట్‌నెట్‌లలో dappలను డిప్లాయ్ చేయడం సాధారణం.

[ఎథీరియం టెస్ట్‌నెట్‌ల గురించి మరింత.](/developers/docs/development-networks/#public-beacon-testchains)

## టెస్టింగ్ వర్సెస్ నియత ధృవీకరణ {#testing-vs-formal-verification}

కొన్ని డేటా ఇన్‌పుట్‌ల కోసం కాంట్రాక్ట్ ఆశించిన ఫలితాలను అందిస్తుందని నిర్ధారించడానికి టెస్టింగ్ సహాయపడుతున్నప్పటికీ, టెస్ట్‌ల సమయంలో ఉపయోగించని ఇన్‌పుట్‌ల కోసం ఇది ఖచ్చితంగా నిరూపించదు. అందువల్ల, స్మార్ట్ కాంట్రాక్ట్‌ను టెస్ట్ చేయడం "కార్యాచరణ ఖచ్చితత్వానికి" హామీ ఇవ్వదు (అంటే, _అన్ని_ ఇన్‌పుట్ విలువల సెట్‌లకు అవసరమైన విధంగా ప్రోగ్రామ్ ప్రవర్తిస్తుందని ఇది చూపదు).

నియత ధృవీకరణ అనేది ప్రోగ్రామ్ యొక్క నియత నమూనా నియత స్పెసిఫికేషన్‌తో సరిపోలుతుందో లేదో తనిఖీ చేయడం ద్వారా సాఫ్ట్‌వేర్ ఖచ్చితత్వాన్ని అంచనా వేసే విధానం. నియత నమూనా అనేది ప్రోగ్రామ్ యొక్క నైరూప్య గణిత ప్రాతినిధ్యం, అయితే నియత స్పెసిఫికేషన్ ప్రోగ్రామ్ యొక్క లక్షణాలను (అంటే, ప్రోగ్రామ్ అమలు గురించి తార్కిక నిర్ధారణలు) నిర్వచిస్తుంది.

ప్రాపర్టీలు గణిత పరంగా వ్రాయబడినందున, సిస్టమ్ యొక్క నియత (గణిత) నమూనా అనుమితి యొక్క తార్కిక నియమాలను ఉపయోగించి స్పెసిఫికేషన్‌ను సంతృప్తి పరుస్తుందని ధృవీకరించడం సాధ్యమవుతుంది. అందువల్ల, నియత ధృవీకరణ సాధనాలు సిస్టమ్ ఖచ్చితత్వం యొక్క 'గణిత రుజువు'ను ఉత్పత్తి చేస్తాయని చెబుతారు.

టెస్టింగ్ వలె కాకుండా, నమూనా డేటాతో అమలు చేయాల్సిన అవసరం లేకుండా _అన్ని_ అమలుల కోసం (అంటే, దానికి బగ్‌లు లేవు) స్మార్ట్ కాంట్రాక్ట్ అమలు నియత స్పెసిఫికేషన్‌ను సంతృప్తి పరుస్తుందని ధృవీకరించడానికి నియత ధృవీకరణను ఉపయోగించవచ్చు. ఇది డజన్ల కొద్దీ యూనిట్ టెస్ట్‌లను అమలు చేయడానికి వెచ్చించే సమయాన్ని తగ్గించడమే కాకుండా, దాచిన దుర్బలత్వాలను పట్టుకోవడంలో కూడా ఇది మరింత ప్రభావవంతంగా ఉంటుంది. అలా చెప్పినప్పటికీ, నియత ధృవీకరణ పద్ధతులు వాటి అమలు కష్టం మరియు ఉపయోగం ఆధారంగా ఒక స్పెక్ట్రమ్‌లో ఉంటాయి.

[స్మార్ట్ కాంట్రాక్ట్‌ల కోసం నియత ధృవీకరణ గురించి మరింత.](/developers/docs/smart-contracts/formal-verification)

## టెస్టింగ్ వర్సెస్ ఆడిట్‌లు మరియు బగ్ బౌంటీలు {#testing-vs-audits-bug-bounties}

పేర్కొన్న విధంగా, కఠినమైన టెస్టింగ్ కాంట్రాక్ట్‌లో బగ్‌లు లేవని అరుదుగా హామీ ఇస్తుంది; నియత ధృవీకరణ విధానాలు ఖచ్చితత్వం యొక్క బలమైన హామీలను అందించగలవు కానీ ప్రస్తుతం ఉపయోగించడం కష్టం మరియు గణనీయమైన ఖర్చులను కలిగి ఉంటాయి.

అయినప్పటికీ, స్వతంత్ర కోడ్ సమీక్షను పొందడం ద్వారా కాంట్రాక్ట్ దుర్బలత్వాలను పట్టుకునే అవకాశాన్ని మీరు మరింత పెంచుకోవచ్చు. [స్మార్ట్ కాంట్రాక్ట్ ఆడిట్‌లు](https://www.immunebytes.com/blog/what-is-a-smart-contract-audit/) మరియు [బగ్ బౌంటీలు](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) అనేవి మీ కాంట్రాక్ట్‌లను ఇతరులు విశ్లేషించేలా చేయడానికి రెండు మార్గాలు.

స్మార్ట్ కాంట్రాక్ట్‌లలో భద్రతా లోపాలు మరియు పేలవమైన అభివృద్ధి పద్ధతులను కనుగొనడంలో అనుభవజ్ఞులైన ఆడిటర్‌లచే ఆడిట్‌లు నిర్వహించబడతాయి. ఆడిట్‌లో సాధారణంగా టెస్టింగ్ (మరియు బహుశా నియత ధృవీకరణ) అలాగే మొత్తం కోడ్‌బేస్ యొక్క మాన్యువల్ సమీక్ష ఉంటుంది.

దీనికి విరుద్ధంగా, బగ్ బౌంటీ ప్రోగ్రామ్‌లో సాధారణంగా స్మార్ట్ కాంట్రాక్ట్‌లో దుర్బలత్వాన్ని కనుగొని డెవలపర్‌లకు వెల్లడించే వ్యక్తికి (సాధారణంగా [వైట్‌హ్యాట్ హ్యాకర్లు](<https://en.wikipedia.org/wiki/White_hat_(computer_security)>) అని వర్ణించబడతారు) ఆర్థిక బహుమతిని అందించడం ఉంటుంది. స్మార్ట్ కాంట్రాక్ట్‌లలో లోపాలను కనుగొనడంలో సహాయం చేయమని ఇతరులను అడగడం ఇందులో ఉంటుంది కాబట్టి బగ్ బౌంటీలు ఆడిట్‌ల మాదిరిగానే ఉంటాయి.

ప్రధాన వ్యత్యాసం ఏమిటంటే, బగ్ బౌంటీ ప్రోగ్రామ్‌లు విస్తృత డెవలపర్/హ్యాకర్ కమ్యూనిటీకి తెరిచి ఉంటాయి మరియు ప్రత్యేక నైపుణ్యాలు మరియు అనుభవంతో విస్తృత తరగతి ఎథికల్ హ్యాకర్లు మరియు స్వతంత్ర భద్రతా నిపుణులను ఆకర్షిస్తాయి. పరిమిత లేదా ఇరుకైన నైపుణ్యాన్ని కలిగి ఉండే బృందాలపై ప్రధానంగా ఆధారపడే స్మార్ట్ కాంట్రాక్ట్ ఆడిట్‌ల కంటే ఇది ప్రయోజనకరంగా ఉండవచ్చు.

## టెస్టింగ్ సాధనాలు మరియు లైబ్రరీలు {#testing-tools-and-libraries}

### యూనిట్ టెస్టింగ్ సాధనాలు {#unit-testing-tools}

- **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)** - _Solidity లో వ్రాయబడిన స్మార్ట్ కాంట్రాక్ట్‌ల కోసం కోడ్ కవరేజ్ సాధనం._

- **[Waffle](https://ethereum-waffle.readthedocs.io/en/latest/)** - _అధునాతన స్మార్ట్ కాంట్రాక్ట్ అభివృద్ధి మరియు టెస్టింగ్ కోసం ఫ్రేమ్‌వర్క్ (ethers.js ఆధారంగా)_.

- **[Remix Tests](https://github.com/ethereum/remix-project/tree/master/libs/remix-tests)** - _Solidity స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి సాధనం. కాంట్రాక్ట్ కోసం టెస్ట్ కేసులను రాయడానికి మరియు అమలు చేయడానికి ఉపయోగించే Remix IDE "Solidity Unit Testing" ప్లగిన్ క్రింద పనిచేస్తుంది._

- **[ఓపెన్‌జెప్పెలిన్ టెస్ట్ హెల్పర్స్](https://github.com/OpenZeppelin/openzeppelin-test-helpers)** - _ఎథీరియం స్మార్ట్ కాంట్రాక్ట్ టెస్టింగ్ కోసం అసెర్షన్ లైబ్రరీ. మీ కాంట్రాక్ట్‌లు ఆశించిన విధంగా ప్రవర్తిస్తున్నాయని నిర్ధారించుకోండి!_

- **[Brownie యూనిట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)** - _Brownie Pytest ను ఉపయోగిస్తుంది, ఇది కనీస కోడ్‌తో చిన్న టెస్ట్‌లను రాయడానికి మిమ్మల్ని అనుమతించే ఫీచర్-రిచ్ టెస్ట్ ఫ్రేమ్‌వర్క్, పెద్ద ప్రాజెక్ట్‌ల కోసం బాగా స్కేల్ అవుతుంది మరియు అత్యంత విస్తరించదగినది._

- **[Foundry Tests](https://github.com/foundry-rs/foundry/tree/master/crates/forge)** - _Foundry Forge ను అందిస్తుంది, ఇది సాధారణ యూనిట్ టెస్ట్‌లు, గ్యాస్ ఆప్టిమైజేషన్ తనిఖీలు మరియు కాంట్రాక్ట్ ఫజ్జింగ్‌ను అమలు చేయగల వేగవంతమైన మరియు సౌకర్యవంతమైన ఎథీరియం టెస్టింగ్ ఫ్రేమ్‌వర్క్._

- **[Hardhat Tests](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** - _ethers.js, Mocha మరియు Chai ఆధారంగా స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి ఫ్రేమ్‌వర్క్._

- **[ApeWorx](https://docs.apeworx.io/ape/stable/userguides/testing.html)** - _ఎథీరియం వర్చువల్ మెషీన్‌ను లక్ష్యంగా చేసుకునే స్మార్ట్ కాంట్రాక్ట్‌ల కోసం Python-ఆధారిత అభివృద్ధి మరియు టెస్టింగ్ ఫ్రేమ్‌వర్క్._

- **[Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** - _ఉత్తమ వినియోగదారు అనుభవం మరియు పనితీరు కోసం pytest మరియు Anvil ను ఉపయోగించి, బలమైన డీబగ్గింగ్ సామర్థ్యాలు మరియు క్రాస్-చైన్ టెస్టింగ్ మద్దతుతో యూనిట్ టెస్టింగ్ మరియు ఫజ్జింగ్ కోసం Python-ఆధారిత ఫ్రేమ్‌వర్క్._

### ప్రాపర్టీ-ఆధారిత టెస్టింగ్ సాధనాలు {#property-based-testing-tools}

#### స్టాటిక్ అనాలిసిస్ సాధనాలు {#static-analysis-tools}

- **[స్లిదర్](https://github.com/crytic/slither)** - _దుర్బలత్వాలను కనుగొనడానికి, కోడ్ గ్రహణశక్తిని పెంచడానికి మరియు స్మార్ట్ కాంట్రాక్ట్‌ల కోసం అనుకూల విశ్లేషణలను రాయడానికి Python-ఆధారిత Solidity స్టాటిక్ అనాలిసిస్ ఫ్రేమ్‌వర్క్._

- **[Ethlint](https://ethlint.readthedocs.io/en/latest/)** - _Solidity స్మార్ట్ కాంట్రాక్ట్ ప్రోగ్రామింగ్ భాష కోసం శైలి మరియు భద్రతా ఉత్తమ పద్ధతులను అమలు చేయడానికి లింటర్._

- **[Cyfrin Aderyn](https://cyfrin.io/tools/aderyn)** - _Web3 స్మార్ట్ కాంట్రాక్ట్ భద్రత మరియు అభివృద్ధి కోసం ప్రత్యేకంగా రూపొందించబడిన Rust-ఆధారిత స్టాటిక్ ఎనలైజర్._

- **[Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** - _దుర్బలత్వం మరియు కోడ్ నాణ్యత డిటెక్టర్‌లు, కోడ్ నుండి ఉపయోగకరమైన సమాచారాన్ని సేకరించడానికి ప్రింటర్‌లు మరియు అనుకూల సబ్‌మాడ్యూల్‌లను రాయడానికి మద్దతుతో Python-ఆధారిత స్టాటిక్ అనాలిసిస్ ఫ్రేమ్‌వర్క్._

- **[Slippy](https://github.com/fvictorio/slippy)** - _Solidity కోసం సరళమైన మరియు శక్తివంతమైన లింటర్._

#### డైనమిక్ అనాలిసిస్ సాధనాలు {#dynamic-analysis-tools}

- **[ఎకిడ్నా](https://github.com/crytic/echidna/)** - _ప్రాపర్టీ-ఆధారిత టెస్టింగ్ ద్వారా స్మార్ట్ కాంట్రాక్ట్‌లలో దుర్బలత్వాలను గుర్తించడానికి వేగవంతమైన కాంట్రాక్ట్ ఫజ్జర్._

- **[Diligence Fuzzing](https://consensys.net/diligence/fuzzing/)** - _స్మార్ట్ కాంట్రాక్ట్ కోడ్‌లో ప్రాపర్టీ ఉల్లంఘనలను గుర్తించడానికి ఉపయోగపడే ఆటోమేటెడ్ ఫజ్జింగ్ సాధనం._

- **[మాంటికోర్](https://manticore.readthedocs.io/en/latest/index.html)** - _EVM బైట్‌కోడ్‌ను విశ్లేషించడానికి డైనమిక్ సింబాలిక్ ఎగ్జిక్యూషన్ ఫ్రేమ్‌వర్క్._

- **[Mythril](https://github.com/ConsenSysDiligence/mythril)** - _టెయింట్ అనాలిసిస్, కాంకోలిక్ అనాలిసిస్ మరియు కంట్రోల్ ఫ్లో చెకింగ్ ఉపయోగించి కాంట్రాక్ట్ దుర్బలత్వాలను గుర్తించడానికి EVM బైట్‌కోడ్ అసెస్‌మెంట్ సాధనం._

- **[Diligence Scribble](https://consensys.net/diligence/scribble/)** - _Scribble అనేది స్పెసిఫికేషన్ లాంగ్వేజ్ మరియు రన్‌టైమ్ వెరిఫికేషన్ సాధనం, ఇది Diligence Fuzzing లేదా MythX వంటి సాధనాలతో కాంట్రాక్ట్‌లను స్వయంచాలకంగా టెస్ట్ చేయడానికి మిమ్మల్ని అనుమతించే ప్రాపర్టీలతో స్మార్ట్ కాంట్రాక్ట్‌లను ఉల్లేఖించడానికి మిమ్మల్ని అనుమతిస్తుంది._

## సంబంధిత ట్యుటోరియల్స్ {#related-tutorials}

- [విభిన్న టెస్టింగ్ ఉత్పత్తుల అవలోకనం మరియు పోలిక](/developers/tutorials/guide-to-smart-contract-security-tools/) \_
- [స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి ఎకిడ్నాను ఎలా ఉపయోగించాలి](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/)
- [స్మార్ట్ కాంట్రాక్ట్ బగ్‌లను కనుగొనడానికి మాంటికోర్‌ను ఎలా ఉపయోగించాలి](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
- [స్మార్ట్ కాంట్రాక్ట్ బగ్‌లను కనుగొనడానికి స్లిదర్‌ను ఎలా ఉపయోగించాలి](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
- [టెస్టింగ్ కోసం Solidity కాంట్రాక్ట్‌లను ఎలా మాక్ చేయాలి](/developers/tutorials/how-to-mock-solidity-contracts-for-testing/)
- [Foundry ని ఉపయోగించి Solidity లో యూనిట్ టెస్ట్‌లను ఎలా అమలు చేయాలి](https://www.rareskills.io/post/foundry-testing-solidity)

## మరింత చదవడానికి {#further-reading}

- [ఎథీరియం స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి లోతైన గైడ్](https://iamdefinitelyahuman.medium.com/an-in-depth-guide-to-testing-ethereum-smart-contracts-2e41b2770297)
- [ఎథీరియం స్మార్ట్ కాంట్రాక్ట్‌లను ఎలా టెస్ట్ చేయాలి](https://betterprogramming.pub/how-to-test-ethereum-smart-contracts-35abc8fa199d)
- [డెవలపర్‌ల కోసం MolochDAO యొక్క యూనిట్ టెస్టింగ్ గైడ్](https://github.com/MolochVentures/moloch/tree/4e786db8a4aa3158287e0935dcbc7b1e43416e38/test#moloch-testing-guide)
- [రాక్‌స్టార్ లాగా స్మార్ట్ కాంట్రాక్ట్‌లను ఎలా టెస్ట్ చేయాలి](https://forum.openzeppelin.com/t/test-smart-contracts-like-a-rockstar/1001)

## ట్యుటోరియల్స్: ఎథీరియంపై స్మార్ట్ కాంట్రాక్ట్ టెస్టింగ్ {#tutorials}

- [స్థానిక, బహుళ-క్లయింట్ టెస్ట్‌నెట్‌లో dApp ని ఎలా అభివృద్ధి చేయాలి మరియు టెస్ట్ చేయాలి](/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/) _– స్థానిక టెస్ట్‌నెట్‌కు స్మార్ట్ కాంట్రాక్ట్‌ను డిప్లాయ్ చేయడం మరియు టెస్ట్‌లను నిర్వహించడం యొక్క వాక్‌త్రూ._
- [టెస్టింగ్ కోసం Solidity స్మార్ట్ కాంట్రాక్ట్‌లను ఎలా మాక్ చేయాలి](/developers/tutorials/how-to-mock-solidity-contracts-for-testing/) _– మాక్ డేటాను ఎలా ఉపయోగించాలి మరియు యూనిట్ టెస్టింగ్‌ను ఎలా అమలు చేయాలి అనే దానిపై ఇంటర్మీడియట్ ట్యుటోరియల్._
- [స్మార్ట్ కాంట్రాక్ట్‌లను టెస్ట్ చేయడానికి ఎకిడ్నాను ఎలా ఉపయోగించాలి](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) _– ఫజ్జింగ్ మరియు స్మార్ట్ కాంట్రాక్ట్ టెస్టింగ్‌కు అధునాతన విధానం._