ఆశించే ఒక స్క్రిప్ట్ ప్రకారం ఇతర ఇంటరాక్టివ్ కార్యక్రమాలు మాట్లాడే కార్యక్రమం. స్క్రిప్ట్ తర్వాత, ఎక్స్పెక్టరు ఒక కార్యక్రమంలో ఏది చేయగలదో తెలుసుకోగలదు మరియు సరైన స్పందన ఏమిటో తెలుసుకోవాలి. ఒక వివరణాత్మక భాష డైలాగ్ దర్శకత్వం కోసం శాఖలు మరియు ఉన్నత-స్థాయి నియంత్రణ నిర్మాణాలను అందిస్తుంది. అదనంగా, వినియోగదారు నియంత్రణలోకి రావడం మరియు నేరుగా స్క్రిప్ట్కు నియంత్రణను తిరిగి పొందడం ద్వారా నేరుగా సంకర్షణ చేయవచ్చు.
ఎక్స్పెక్టెక్ అనేది ఎక్స్పెక్ట్ అండ్ టికె యొక్క మిశ్రమం. ఇది ఎక్స్పెక్ట్ మరియు TK కోరికల వలె ప్రవర్తిస్తుంది. ఆశించటం నేరుగా T లేదా T లేకుండా C లేదా C ++ లో ఉపయోగించవచ్చు.
Uucp, kermit మరియు ఇతర మోడెమ్ నియంత్రణ కార్యక్రమాలు ద్వారా ప్రాచుర్యం పొందిన సీక్వెన్సులను పంపే / ఆశించే ఆలోచన నుండి "ఆశించటం" అనే పేరు వచ్చింది. అయితే Uucp వలె కాకుండా, ఆశించినది సాధారణమైనది, తద్వారా అది ఏదైనా ప్రోగ్రామ్ మరియు పనిలో మనసులో ఉన్న వినియోగదారు స్థాయి ఆదేశం వలె అమలు చేయబడుతుంది. అదే సమయంలో అనేక కార్యక్రమాలు మాట్లాడవచ్చు.
ఏమి చేయగలరో ఆశించవచ్చు
ఉదాహరణకు, ఆశించే ఆదేశం చేయగల కొన్ని విషయాలు ఇక్కడ ఉన్నాయి:
- మీ కంప్యూటర్ను తిరిగి కాల్చడానికి మీ కంప్యూటర్ను సృష్టించండి, అందువల్ల మీరు కాల్ కోసం చెల్లించకుండా లాగ్ ఇన్ చేయవచ్చు.
- ఒక ఆట ప్రారంభించండి మరియు ఆప్టిమల్ ఆకృతీకరణ కనిపించకపోతే, అది మరలా మరలా పునఃప్రారంభించబడుతుంది), ఆపై మీకు నియంత్రణను అప్పగించండి.
- Fsck రన్ మరియు దాని ప్రశ్నలకు ప్రతిస్పందనగా, ముందుగా నిర్ణయించిన ప్రమాణాల ఆధారంగా, "అవును" లేదా "లేదు" లేదా మీకు నియంత్రణను ఇవ్వండి.
- మరొక నెట్వర్క్కి కనెక్ట్ అవ్వండి మరియు స్వయంచాలకంగా మీ మెయిల్ను తిరిగి అందుకోండి అందువల్ల ఇది మీ స్థానిక సిస్టమ్కు మొదట పంపినట్లుగా కనిపిస్తుంది.
- ఎన్విరాన్మెంట్ వేరియబుల్స్, కరెంట్ డైరెక్టరీ లేదా రాంగ్లైన్, టెల్నెట్, టిప్, su, లేదా chgrp
షెల్ ఈ పనులను ఎందుకు చేయలేకపోతుందనే అనేక కారణాలు ఉన్నాయి. అన్ని ఆశించే తో సాధ్యమే.
సాధారణంగా, ప్రోగ్రాం మరియు వినియోగదారు మధ్య పరస్పర చర్య అవసరమయ్యే ఏదైనా ప్రోగ్రామ్ను అమలు చేయడానికి ఉపయోగపడుతుంది. అవసరమైన అన్ని పరస్పర programmatically కలిగి ఉంటుంది. ఆశించే కార్యక్రమం నియంత్రణను నిలిపివేయకుండా వినియోగదారుకు నియంత్రణను కూడా ఇవ్వవచ్చు. అదేవిధంగా, వినియోగదారు ఎప్పుడైనా స్క్రిప్ట్కు నియంత్రణను తిరిగి పొందవచ్చు.
వాడుక
నిర్వహించడానికి ఆదేశాల జాబితా కోసం cmdfile చదువుతాము. # మద్దతివ్వగల వ్యవస్థలపై అనుమానాస్పదంగా ఉండవచ్చు! లిపి స్క్రిప్ట్ ను ఎక్జిక్యూటబుల్గా గుర్తించి స్క్రిప్టులో మొదటి పంక్తిని చేస్తూ:
#! usr / local / bin / expect -f
వాస్తవానికి, జీవితాలను ఆశించే ఎక్కడ ఖచ్చితంగా మార్గం వివరించాలి. / usr / local / bin ఒక ఉదాహరణ.
-C ఫ్లాగ్ స్క్రిప్ట్లో ఏదైనా ముందు అమలు చేయవలసిన ఆదేశాన్ని ప్రస్తావిస్తుంది. షెల్ విచ్ఛిన్నం చేయకుండా నిరోధించడానికి ఆదేశం కోట్ చేయాలి. ఈ ఐచ్చికము చాలా సార్లు వాడవచ్చు. పలు ఆదేశాలను సెమికోలన్లతో వేరు చేసి ఒకే-సితో అమలు చేయవచ్చు. ఆదేశాలు కనిపించే క్రమంలో అమలు చేయబడతాయి. Expectk ను వాడుతున్నప్పుడు, ఈ ఐచ్ఛికం -command గా తెలుపబడుతుంది.
-D జెండా కొన్ని విశ్లేషణ అవుట్పుట్ను ప్రారంభిస్తుంది, ఇది ప్రధానంగా ఆశించే మరియు సంకర్షణ వంటి ఆదేశాల అంతర్గత కార్యాచరణను నివేదిస్తుంది. ఈ ఫ్లాగ్ ఒక ఎక్స్ప్ట్ స్క్రిప్ట్ ప్రారంభంలో "exp_internal 1" వలె అదే ప్రభావాన్ని కలిగి ఉంటుంది, అంతేకాక ఆశించిన సంస్కరణ ముద్రించబడుతుంది.
-D ఫ్లాగ్ ఇంటరాక్టివ్ డీబగ్గర్ను ప్రారంభిస్తుంది. పూర్ణాంకం విలువ అనుసరించాలి. విలువ సున్నా కానిది లేదా ఒక ^ సి నొక్కినప్పుడు లేదా బ్రేక్పాయింట్ని కొట్టినట్లయితే లేదా ఇతర తగిన డీబగ్గర్ ఆదేశం స్క్రిప్ట్లో కనిపిస్తే డీబగ్గర్ తదుపరి Tcl విధానానికి ముందు నియంత్రణలోకి వస్తుంది. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికము పేర్కొనబడింది -డీబగ్ చేయండి.
-F ఫ్లాగ్ ఆదేశాలను చదివిన ఒక ఫైల్ను ఇష్టపడుతోంది. # ఉపయోగించినప్పుడు ఇది ఉపయోగకరంగా ఉన్నందున జెండా కూడా ఐచ్ఛికం! సంజ్ఞామానం, కాబట్టి ఇతర వాదనలు ఆదేశ పంక్తిలో సరఫరా చేయబడతాయి. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికం -ఫైల్ గా పేర్కొనబడింది.
అప్రమేయంగా, కమాండ్ ఫైలు మెమొరీ లోకి చదవబడుతుంది మరియు దాని మొత్తంలో అమలు అవుతుంది. ఇది ఒక సమయంలో ఒక లైన్ ఫైల్లను చదవడానికి అప్పుడప్పుడూ అవసరం. ఏకపక్ష ఫైళ్ళను ఈ విధంగా నిర్వహించటానికి, -b జెండాని వాడండి. Expectk ను ఉపయోగిస్తున్నప్పుడు, ఈ ఐచ్ఛికం -బఫర్గా పేర్కొనబడింది.
స్ట్రింగ్ "-" ఒక ఫైల్ పేరుగా సరఫరా చేయబడితే, ప్రామాణిక ఇన్పుట్ బదులుగా చదవబడుతుంది. వాస్తవానికి "-" అనే ఫైల్ నుండి చదవటానికి "./-" ఉపయోగించండి.
-I ఫ్లాగ్ కారణమవుతుంది ఆదేశాలకు ఇంటరాక్టివ్గా ప్రాంప్ట్ చేయడమే కాకుండా ఫైల్ను చదవటానికి బదులుగా. నిష్క్రమణ ఆదేశం లేదా EOF ద్వారా ప్రాంప్ట్ చేయబడుతుంది. కమాండ్ ఫైల్ లేదా -c ఉపయోగించబడకపోతే -i ఫ్లాగ్ ఊహిస్తుంది. Expectk ను వాడుతున్నప్పుడు, ఈ ఐచ్చికము -ఇంటర్నటివ్ గా తెలుపబడును.
- ఎంపికల ముగింపుని డీలిమిట్ చేయడానికి ఉపయోగించవచ్చు. మీ లిపికి ఎక్స్ప్రెస్ ద్వారా వ్యాఖ్యానించకుండా ఒక ఐచ్ఛికం వంటి ఆర్గ్యుమెంట్ను మీరు పాస్ చేయాలనుకుంటే ఇది ఉపయోగపడుతుంది. ఈ ఉపయోగకరమైన # లో ఉంచవచ్చు! ఎక్స్పెక్ట్ ద్వారా ఏవిధమైన ఫ్లాగ్లాగ్ అన్వయింపును నివారించడానికి. ఉదాహరణకు, ఈ కింది వాల్యూమ్లో స్క్రిప్ట్ పేరుతో అసలు వాదనలు ఉంటాయి argv .
#! usr / local / bin / expect -
వాదనలు జోడించడం ఉన్నప్పుడు సాధారణ getopt (3) మరియు అమలు (2) కన్వెన్షన్లు గమనించండి గమనించండి #! లైన్.
$ Exp_library / expect.rc ఫైలు -N జెండా ఉపయోగించకపోతే, స్వయంచాలకంగా అందించబడుతుంది. (Expectk ని వాడుతున్నప్పుడు, ఈ ఐచ్ఛికం -NORC గా పేర్కొనబడింది.) వెంటనే దీని తర్వాత, -n. జెండా ఉపయోగించబడకపోతే, ఫైల్ ~ ~ / .expect.rc స్వయంచాలకంగా మూలం అవుతుంది. ఎన్విరాన్మెంట్ వేరియబుల్ DOTDIR నిర్వచించబడితే, అది ఒక డైరెక్టరీగా పరిగణించబడుతుంది మరియు అక్కడ నుండి ఎక్స్పెక్టరేట్. Expectk ను ఉపయోగించినప్పుడు, ఈ ఐచ్చికం -norc గా పేర్కొనబడింది.ఈ సోర్సింగ్ ఏ-సి ఫ్లాగ్లను అమలు చేసిన తర్వాత మాత్రమే జరుగుతుంది.
-v కారణమవుతుంది దాని వెర్షన్ సంఖ్య మరియు నిష్క్రమణ ప్రింట్ భావిస్తున్నారు. దీర్ఘ జెండా పేర్లను ఉపయోగించే ఎక్స్పెక్టక్లో సంబంధిత జెండా, -వెర్షన్.
Optional args ఒక జాబితాలో నిర్మించబడ్డాయి మరియు varv అనే పేరుతో నిల్వ చేయబడతాయి. argc సున్నా పొడవున ప్రారంభించబడుతుంది.
స్క్రిప్ట్ లేదా బైనరీ పేరు స్క్రిప్ట్ ఉపయోగించబడకపోతే Argv0 నిర్వచించబడింది. ఉదాహరణకు, క్రింది స్క్రిప్ట్ పేరు మరియు మొదటి మూడు వాదనలు ముద్రిస్తుంది:
send_user "$ argv0 lrange $ argv 0 2 n"
ఆదేశాలు
టూల్ కమాండ్ లాంగ్వేజ్ను ఉపయోగించుకోవచ్చని ఆశించండి. TCL నియంత్రణ ప్రవాహాన్ని అందిస్తుంది (ఉంటే, విరామం కోసం), వ్యక్తీకరణ మూల్యాంకనం మరియు పునరావృత ప్రక్రియ నిర్వచనం వంటి అనేక ఇతర లక్షణాలు. ఇక్కడ ఉపయోగించిన ఆదేశాలు కానీ నిర్వచించబడలేదు (సెట్, ఉంటే, ఎగ్నిషన్) టికెసి ఆదేశాలు. అదనపు ఆదేశాలను మద్దతిస్తుంది. పేర్కొనకపోతే తప్ప, ఆదేశాలు ఖాళీ స్ట్రింగ్ను తిరిగి పంపుతాయి.
కమాండ్లు అక్షర క్రమంలో జాబితా చేయబడ్డాయి, తద్వారా అవి త్వరగా ఉంటున్నాయి. అయినప్పటికీ, ఆ క్రమంలో, స్పాన్ యొక్క వర్ణనలను చదవడం, పంపడం, ఆశించడం మరియు పరస్పర చర్య చేయడం ద్వారా కొత్త వినియోగదారులు ప్రారంభించడం సులభం కావచ్చు.
దగ్గరగా -slave -onexec 0 | 1 -i spawn_id
ప్రస్తుత ప్రక్రియకు కనెక్షన్ను మూసివేస్తుంది. చాలా ఇంటరాక్టివ్ ప్రోగ్రామ్లు EOF ను వారి స్టాండ్ మరియు నిష్క్రమణలో గుర్తించాయి; అందువలన Close సాధారణంగా ప్రక్రియను చంపడానికి సంతృప్తి పరుస్తుంది. పేరు- spin_id కు అనుగుణంగా మూసివేసే ప్రక్రియను -i ఫ్లాగ్ ప్రకటించింది.
ప్రస్తుత ప్రక్రియ నిష్క్రియాత్మకమైనప్పుడు మరియు సంపూర్ణంగా సన్నిహితంగా ఉన్నప్పుడు గుర్తించి, పరస్పరం సంభవిస్తుంది, కానీ మీరు ప్రక్రియను చంపినట్లయితే, "exec" $ pid ను చంపి, మీరు స్పష్టంగా దగ్గరగా కాల్ చేయాలి.
స్పాన్ ఐ id మూసివేయబడినా లేదా ప్రక్రియ అతివ్యాప్తి చేయబడినా లేదో -onxec జెండా నిర్ణయిస్తుంది. ఒక స్పాన్ ఐడిని తెరిచి ఉంచడానికి, విలువ 0 ను ఉపయోగించండి. ఏ కొత్త ప్రక్రియల్లో స్పాన్ మూసివేయబడిన సున్నా-కాని పూర్ణసంఖ్య విలువను బలవంతం చేస్తుంది.
స్పాన్ ఐడితో అనుబంధించబడిన బానిసను స్లావ్ జెండా మూసిస్తుంది. కనెక్షన్ మూసివేయబడినప్పుడు, బానిస అది ఇంకా తెరిస్తే స్వయంచాలకంగా మూసివేయబడుతుంది.
కనెక్షన్ నిశ్శబ్దంగా లేదా స్పష్టంగా మూసివేయబడినా, మీరు కెర్నల్ ప్రాసెస్ స్లాట్ను క్లియర్ చేయడానికి వేచి ఉండండి. ప్రాసెస్ కనెక్షన్ మూసివేయడం వలన అది నిష్క్రమించడానికి కారణం లేనందున సమీప ఆదేశం వేచి ఉండదు.
డీబగ్ -now 0 | 1
మీరు Tcl డీబగ్గర్ని ప్రకటనలు మరియు సెట్ బ్రేక్ పాయింట్స్ ద్వారా వెళ్ళడానికి అనుమతిస్తుంది.
డీబగ్గర్ రన్ చేయకపోతే వాదనలు లేకుండా, ఒక 1 తిరిగి ఉంటే, లేకపోతే 0 తిరిగి వస్తుంది.
1 వాదనతో డీబగ్గర్ ప్రారంభమైంది. 0 వాదనతో డీబగ్గర్ నిలిపివేయబడింది. ఒక 1 వాదన ముందే -ఇతర జెండా చేస్తే, డీబగ్గర్ వెంటనే ప్రారంభమవుతుంది. లేకపోతే, డీబగ్గర్ తదుపరి Tcl స్టేట్మెంట్తో ప్రారంభించబడుతుంది.
డీబగ్ ఆదేశం ఏ ఉచ్చులను మార్చదు. -D జెండాతో ఆశించటం మొదలు పెట్టండి.
డిస్కనెక్ట్ కమాండ్ టెర్మినల్ నుండి ఫోర్క్డ్ ప్రాసెస్ను డిస్కనెక్ట్ చేస్తుంది. ఇది నేపథ్యంలో కొనసాగుతూనే ఉంది. ప్రక్రియ తన సొంత ప్రక్రియ సమూహం ఇవ్వబడుతుంది. ప్రామాణిక I / O ను / dev / null కు మళ్ళించబడుతుంది.
నేపథ్యంలో స్క్రిప్ట్ను కొనసాగించడం కొనసాగించడానికి క్రింది భాగం ఉపసంహరించుకుంటుంది.
{ఫోర్క్ ఉంటే! = 0} డిస్కనెక్ట్ నిష్క్రమించండి. . .
కింది స్క్రిప్ట్ పాస్ వర్డ్ ను చదువుతుంది మరియు ప్రతి సారి ఇది నడుపుతున్న ప్రతిసారీ పాస్ వర్డ్ ను డిమాండ్ చేసే ఒక ప్రోగ్రామ్ను నడుపుతుంది. స్క్రిప్ట్ పాస్ వర్డ్ ను అందిస్తుంది, తద్వారా మీరు దానిని ఒకసారి మాత్రమే టైప్ చేయాలి.
send_user "password? " expect_user -re "(. *) n" {{fork = {fork = = "{నిద్ర 3600; కొనసాగించు} స్పాన్ priv_prog ను డిస్కనెక్ట్ చేస్తాను. 1, స్ట్రింగ్) r ". . . నిష్క్రమణ
షెల్ ఎసిన్క్రోనస్ ప్రాసెస్ విశేషణం (&) పై డిస్కనెక్ట్ను ఉపయోగించడం అనేది ఒక ప్రయోజనం, అనగా ముందుగా టెర్మినల్ పారామితులను టెలికమ్యూనికేషన్స్ సేవ్ చేయగలదు మరియు తర్వాత వాటిని కొత్త ptys కు వర్తిస్తాయి. & తో, టెర్మినల్ అప్పటికే డిస్కనెక్ట్ అయినందున టెర్మినల్ యొక్క పారామితులను చదవటానికి అవకాశం లేదు.
నిష్క్రమించండి -ఓట్లు స్థితి
కారణాలు నిష్క్రమించడానికి లేదా అలా చేయటానికి సిద్ధం కావాలని ఆశించటం.
ది -onexit జెండా తదుపరి వాదనను నిష్క్రమించే హ్యాండ్లర్గా ఉపయోగించుకుంటుంది. ఒక వాదన లేకుండా, ప్రస్తుత నిష్క్రమణ హ్యాండ్లర్ తిరిగి పొందబడుతుంది.
ది -noexit జెండా కారణాలు అన్ఏక్ష్పెక్ట్డ్ నిష్క్రమించడానికి సిద్ధం కాని వాస్తవానికి ఆపరేటింగ్ సిస్టమ్కు నియంత్రణను తిరిగి స్వీకరిస్తుంది. యూజర్ నిర్వచించిన నిష్క్రమణ హ్యాండ్లర్ అలాగే ఎక్స్ప్ట్ యొక్క సొంత అంతర్గత హ్యాండ్లర్లు అమలు. ఇకపై ఆదేశాలను అమలు చేయరాదు. మీరు ఇతర TCL పొడిగింపులతో ఆశించేలా ఉంటే ఇది ఉపయోగకరంగా ఉంటుంది. ప్రస్తుత ఇంటర్ప్రెటర్ (మరియు TK పర్యావరణంలో ప్రధాన విండో ఉంటే) ఇతర TCL ఎక్స్టెన్షన్స్ను శుభ్రపరుస్తుంది కాబట్టి ఉంటాయి. ఆశించినట్లయితే నిష్క్రమణ (అయితే ఇది సంభవించవచ్చు) తిరిగి పిలవబడుతుంది, హ్యాండ్లర్లు తిరిగి మారరు.
నిష్క్రమించేటప్పుడు, స్పాన్డ్ ప్రక్రియలకు అన్ని కనెక్షన్లు మూసివేయబడతాయి. మూసివేయడం ప్రక్రియ ద్వారా EOF గా గుర్తించబడుతుంది. నిష్క్రమణ సాధారణ _exit (2) విధానం ఏమి మించి ఇతర చర్యలు తీసుకోవు. అందువలన, EOF కోసం తనిఖీ చేయని ప్రక్రియలు అమలులో కొనసాగవచ్చు. (ఉదాహరణకు, ఎటువంటి సంకేతాలు ఏవంటాయో గుర్తించదగ్గ విషయాలను గుర్తించటం చాలా ముఖ్యమైనవి, కానీ ఇవి సిస్టమ్-ఆధారమైనవి, సాధారణంగా నిష్క్రమణ (3) కింద డాక్యుమెంట్ చేయబడతాయి.) అమలు చేయబడుతున్న స్ప్రెడ్డ్ ప్రక్రియలు init ద్వారా వారసత్వంగా ఉంటాయి.
స్థితి (లేదా 0 పేర్కొనకపోతే) నిష్క్రమణ స్థితిగా తిరిగి వస్తుంది అన్ఏక్ష్పెక్ట్డ్ . నిష్క్రమణ స్క్రిప్ట్ ముగింపు చేరుకున్నట్లయితే పరిపూర్ణంగా అమలు చేయబడుతుంది.
exp_continue -continue_timer
కమాండ్ exp_continue అనుమతిస్తుంది ఆశించే దానికదే సాధారణముగా తిరిగి వచ్చేటప్పుడు కాకుండా అమలు చేయడాన్ని కొనసాగిస్తుంది. అప్రమేయంగా exp_continue సమయం ముగిసింది టైమర్ పునఃఅమర్పులకు. ది -continue_timer జెండా పునఃప్రారంభం నుండి టైమర్ నిరోధిస్తుంది. (చూడండి ఆశించే మరిన్ని వివరములకు.)
exp_internal -f ఫైల్ విలువ
డయాగ్నొస్టిక్ సమాచారం అంతర్గతంగా పంపడానికి మరింత ఆదేశాలను కలిగిస్తుంది అన్ఏక్ష్పెక్ట్డ్ stderr ఉంటే విలువ సున్నా కానిది. ఈ అవుట్పుట్ నిలిపివేయబడింది విలువ 0. డయాగ్నొస్టిక్ సమాచారంలో ప్రతి పాత్రను పొందింది మరియు నమూనాలను వ్యతిరేకంగా ప్రస్తుత అవుట్పుట్కు సరిపోయే ప్రతి ప్రయత్నం కూడా ఉంటుంది.
ఐచ్ఛికం ఫైలు సరఫరా చేయబడుతుంది, అన్ని సాధారణ మరియు డీబగ్గింగ్ అవుట్పుట్ ఆ ఫైల్కు వ్రాయబడుతుంది (సంబంధం లేకుండా విలువ విలువ ). ఏదైనా మునుపటి విశ్లేషణ అవుట్పుట్ ఫైల్ మూసివేయబడింది.
ది -info ఫ్లాగ్ కారణంచేత, ఇటీవలి సమాచారం కాని వాదనలు యొక్క వివరణను తిరిగి ఇవ్వడానికి exp_internal కారణమవుతుంది.
exp_open args -i spawn_id
అసలైన స్పాన్ ఐడికి సంబంధించిన TCL ఫైల్ ఐడెంటిఫైయర్ను తిరిగి అందిస్తుంది. అప్పుడు ఫైల్ ఐడెంటిఫైయర్ను టిక్క్ యొక్క తెరవబడినట్లుగా ఉపయోగించవచ్చు ఓపెన్ ఆదేశం. (స్పాన్ ఐడి ఇకపై ఉపయోగించకూడదు వేచి అమలు చేయరాదు.
ది -leaveopen జెండా ఆపివేసే ఆదేశాల ద్వారా యాక్సెస్ కోసం స్పాన్ ఐడిని తెరిచేస్తుంది. ఒక వేచి స్పాన్ id లో అమలు చేయాలి.
exp_pid -i spawn_id
ప్రస్తుతం ఉత్పత్తి చేయబడిన ప్రాసెస్కు సంబంధించిన ప్రాసెస్ ఐడిని తిరిగి పంపుతుంది. ఉంటే -i జెండా ఉపయోగించబడుతుంది, ఇచ్చిన స్పాన్ ఐడికి పిడి తిరిగి ఉంటుంది.
exp_send
ఒక మారుపేరు పంపడానికి .
exp_send_error
ఒక మారుపేరు send_error .
exp_send_log
ఒక మారుపేరు send_log .
exp_send_tty
ఒక మారుపేరు send_tty .
exp_send_user
ఒక మారుపేరు send_user .
exp_version -exit వెర్షన్
స్క్రిప్టు ప్రస్తుత వెర్షన్ ఎక్స్పెక్ట్కు అనుగుణంగా ఉందని నిర్ధారించడానికి ఉపయోగపడుతుంది.
వాదనలు లేకుండా, ప్రస్తుత వెర్షన్ అన్ఏక్ష్పెక్ట్డ్ తిరిగి ఉంది. ఈ సంస్కరణ అప్పుడు మీ స్క్రిప్ట్లో ఎన్కోడ్ చేయబడవచ్చు. మీరు ఇటీవలి సంస్కరణల లక్షణాలను ఉపయోగించడం లేదని మీకు తెలిస్తే, మీరు ముందు వెర్షన్ను పేర్కొనవచ్చు.
సంస్కరణలు చుక్కలు వేరు చేయబడిన మూడు సంఖ్యలను కలిగి ఉంటాయి. మొదటిది ప్రధాన సంఖ్య. సంస్కరణలకు వ్రాసిన స్క్రిప్ట్లు అన్ఏక్ష్పెక్ట్డ్ వేరే ప్రధాన సంఖ్య దాదాపు ఖచ్చితంగా పనిచేయదు. exp_version ప్రధాన సంఖ్యలు సరిపోకపోతే లోపాన్ని తిరిగి పంపుతుంది.
రెండవది చిన్న సంఖ్య. ప్రస్తుత సంస్కరణ కంటే ఎక్కువ చిన్న సంఖ్యతో సంస్కరణకు వ్రాసిన స్క్రిప్ట్లు కొన్ని కొత్త లక్షణాలపై ఆధారపడి ఉంటాయి మరియు అమలు చేయకపోవచ్చు. exp_version ప్రధాన సంఖ్యలు సరిపోలితే లోపం ఏర్పరుస్తుంది, కానీ స్క్రిప్ట్ చిన్న సంఖ్య రన్ కంటే ఎక్కువ అన్ఏక్ష్పెక్ట్డ్ .
మూడోది సంస్కరణ పోలికలో ఎటువంటి పాత్ర పోషిస్తున్న సంఖ్య. అయితే, అది పెరిగినప్పుడు అన్ఏక్ష్పెక్ట్డ్ అదనపు పంపిణీ లేదా ఆప్టిమైజేషన్ వంటి సాఫ్ట్వేర్ పంపిణీ ఏ విధంగానూ మార్చబడుతుంది. ఇది ప్రతి కొత్త మైనర్ వెర్షన్ మీద 0 కు రీసెట్ చేయబడుతుంది.
తో -exit జెండా, అన్ఏక్ష్పెక్ట్డ్ వెర్షన్ను గడువు ముగిసినట్లయితే లోపం ముద్రిస్తుంది మరియు నిష్క్రమిస్తుంది.
-ఓట్లు pat1 body1 … -ఓట్లు పాట్ శరీర
నమూనాలలో ఒకదానిని ఒక స్పాన్డ్ ప్రక్రియ యొక్క అవుట్పుట్తో సరిపోయే వరకు, పేర్కొన్న కాల వ్యవధి గడువు ముగిసే వరకు లేదా ముగింపు-ఫైల్ కనిపిస్తుంది. తుది శరీరం ఖాళీగా ఉంటే, అది తొలగించబడవచ్చు.
ఇటీవలి నుండి నమూనాలు expect_before కమాండ్ ఏ ఇతర నమూనాలు ముందు పరిపూర్ణంగా ఉపయోగిస్తారు. ఇటీవలి నుండి నమూనాలు expect_after కమాండ్ ఏ ఇతర నమూనాల తర్వాత పరిపూర్ణంగా ఉపయోగిస్తారు.
మొత్తం వాదనలు ఉంటే ఆశించే స్టేట్మెంట్కు ఒకటి కన్నా ఎక్కువ లైన్ అవసరం, ప్రతి వాదనను ఒక బాక్సులాష్తో ముగించకుండా ఉండటానికి అన్ని వాదనలు ఒకే విధంగా ఉంటాయి. ఈ సందర్భంలో, సాధారణ TCL ప్రత్యామ్నాయాలు జంట కలుపులు ఉన్నప్పటికీ జరుగుతాయి.
ఒక నమూనా కీవర్డ్ ఉంటే EOF , సంబంధిత శరీరం చివరిలో ఫైలు అమలు అవుతుంది. ఒక నమూనా కీవర్డ్ ఉంటే సమయం ముగిసినది , సంబంధిత శరీరం గడువు ముగిసిన తరువాత అమలు అవుతుంది. గడువు ముగిసే కీవర్డ్ ఉపయోగించనట్లయితే, గడువు ముగింపులో ఒక అవ్యక్త శూన్య చర్య అమలు అవుతుంది. డిఫాల్ట్ గడువు వ్యవధి 10 సెకన్లు అయితే సెట్ చేయబడవచ్చు, ఉదాహరణకి 30 వ కమాండ్ "సెట్ టైమ్అవుట్ 30". అనంత సమయం ముగిసే విలువ -1 ద్వారా నిర్దేశించబడుతుంది. ఒక నమూనా కీవర్డ్ ఉంటే డిఫాల్ట్ , సంబంధిత శరీరం గడువు ముగింపు లేదా ముగింపు-ఫైల్లో అమలు అవుతుంది.
ఒక నమూనా సరిపోతుంది ఉంటే, అప్పుడు సంబంధిత శరీరం అమలు. ఆశించే శరీర ఫలితాన్ని (లేదా ఏ నమూనా సరిపోని అయినా ఖాళీ స్ట్రింగ్) తిరిగి వస్తుంది. బహుళ నమూనాలు సరిపోయే సందర్భంలో, మొదటి కనిపించే ఒక శరీరం ఎంచుకోవడానికి ఉపయోగిస్తారు.
ప్రతిసారీ కొత్త అవుట్ పుట్ వస్తుంది, అవి ప్రతి క్రమంలో వారు జాబితా చేయబడిన క్రమంలో పోలి ఉంటాయి. అందువల్ల, ఒక ప్రాంప్ట్ వంటి కనిపించే హామీనిచ్చిన చివరి నమూనాను తయారు చేయడం ద్వారా మీరు ఒక మ్యాచ్ లేకపోవటం కోసం పరీక్షించవచ్చు. ఎటువంటి ప్రాంప్ట్ లేని సందర్భాల్లో, మీరు ఉపయోగించాలి సమయం ముగిసినది (మీరు మానవీయంగా పరస్పరంగా ఉంటే).
పద్ధతులు మూడు విధాలుగా పేర్కొనబడ్డాయి. అప్రమేయంగా, నమూనాలను Tcl యొక్క మాదిరిగా పేర్కొనబడతాయి స్ట్రింగ్ మ్యాచ్ ఆదేశం. (ఇలాంటి నమూనాలు C- షెల్ రెగ్యులర్ వ్యక్తీకరణలను సాధారణంగా "గ్లోబ్" నమూనాలుగా సూచిస్తాయి). ది -gl పోలికను పోల్చుకోవచ్చు, లేకపోతే ఇది సరిపోలవచ్చు ఆశించే జెండాలు చేయడం నుండి. "-" తో ప్రారంభమయ్యే ఏదైనా నమూనా ఈ విధంగా భద్రపరచబడాలి. ("-" తో ప్రారంభమయ్యే అన్ని తీగలను భవిష్యత్ ఎంపికల కోసం కేటాయించారు.)
ఉదాహరణకు, క్రింది భాగం విజయవంతమైన లాగిన్ కోసం చూస్తుంది. (గమనించండి గర్భస్రావము స్క్రిప్ట్లో మరెక్కడైనా నిర్వచించిన విధానం అని భావించబడుతుంది.)
{బిజీయి {బిజీలు} బిజీగా ఉంచుతుందా? exp_continue} విఫలమైనది "చెల్లని సంకేతపదము" గడువు ముగియడము రద్దుచేయబడింది
నాలుగవ నమూనాలో ఉల్లేఖనాలు అవసరం ఎందుకంటే ఇది ఖాళీని కలిగి ఉంటుంది, ఇది చర్య నుండి నమూనాను వేరు చేస్తుంది.అదే చర్యతో ఉన్న పద్ధతులు (3 వ మరియు 4 వ వంటివి) మళ్లీ చర్యలను జాబితా చేయవలసి ఉంటుంది. ఇది regexp- శైలి నమూనాలను ఉపయోగించడం ద్వారా నివారించవచ్చు (క్రింద చూడండి). గ్లోబ్-శైలి నమూనాలను రూపొందించడానికి మరింత సమాచారం Tcl మాన్యువల్లో లభిస్తుంది.
Regexp- శైలి నమూనాలు Tcl యొక్క నిర్వచించిన సింటాక్స్ను అనుసరిస్తాయి regexp ("రెగ్యులర్ ఎక్స్ప్రెషన్" కు సంక్షిప్త) ఆదేశం. జెండాతో regexp నమూనాలు ప్రవేశపెడతారు -re . మునుపటి ఉదాహరణ ఒక regexp ఉపయోగించి తిరిగి వ్రాయబడుతుంది:
{బిజీయి {బిజీలు} బిజీగా ఉంచుతుందా? exp_continue} -re "విఫలమైంది | చెల్లని సంకేతపదం
రెండు రకాలైన నమూనాలు "ఉద్భవించాయి". దీని అర్థం, మొత్తం స్ట్రింగ్తో సరిపోలడం లేదు, కానీ స్ట్రింగ్లో ఎక్కడైనా మ్యాచ్ను ముగించవచ్చు మరియు ముగించవచ్చు (అన్నిటికీ సరిపోలినంత వరకు). స్ట్రింగ్ యొక్క ఆరంభానికి సరిపోలడానికి ^ ను ఉపయోగించుము మరియు చివరికి $ ఆటకు సరిపోలడం. స్ట్రింగ్ యొక్క ముగింపుకు మీరు వేచి ఉండకపోతే, స్ట్రింగ్ యొక్క మధ్యలో మీ ప్రతిస్పందనలు సులభంగా ముగుస్తాయి, ఎందుకంటే అవి తెరిచిన ప్రక్రియ నుండి ప్రతిధ్వనిస్తాయి. ఇప్పటికీ సరైన ఫలితాలను ఉత్పత్తి చేస్తున్నప్పుడు, అవుట్పుట్ అసహజంగా కనిపిస్తుంది. అందువల్ల, $ స్ట్రింగ్ యొక్క చివర ఉన్న పాత్రలను సరిగ్గా వివరిస్తే మీరు ఉపయోగించడం ప్రోత్సహిస్తుంది.
చాలామంది సంపాదకులలో, ^ మరియు $ వరుసగా వరుసల ప్రారంభం మరియు చివరికి సరిపోలడం గమనించండి. అయినప్పటికీ, ఆశించకుండా లైన్ ఆధారిత కాదు, ఈ అక్షరాలు ప్రస్తుతం సరిపోలే బఫర్ ఆశించిన డేటా యొక్క ప్రారంభ మరియు ముగింపు (పంక్తులు వ్యతిరేకంగా) సరిపోలడం. (అలాగే, "సిస్టమ్ అజీర్తి" పై ఈ క్రింది గమనిక చూడండి)
ది -ex జెండా ఒక "ఖచ్చితమైన" స్ట్రింగ్గా సరిపోయేలా నమూనాను కలిగిస్తుంది. *, ^, Etc యొక్క వివరణ లేదు (సాధారణ TCL సమావేశాలు ఇప్పటికీ పరిశీలించబడాలి). ఖచ్చితమైన నమూనాలు ఎల్లప్పుడూ ఉద్దీపనము.
ది -nocase జెండా అవుట్పుట్ యొక్క పెద్ద అక్షరాలను వారు చిన్న అక్షరాలుగా సరిపోల్చడానికి కారణమవుతుంది. నమూనా ప్రభావితం కాదు.
అవుట్పుట్ చదివినప్పుడు, 2000 కంటే ఎక్కువ బైట్లు ముందుగా బైట్లు "మర్చిపోయి" చేయగలవు. ఈ ఫంక్షన్తో మార్చవచ్చు match_max . (అతి పెద్ద విలువలు నమూనా matcher వేగాన్ని తగ్గించగలవు గమనించండి.) ఉంటే patlist ఉంది full_buffer , సంబంధిత శరీరం అమలు ఉంటే match_max బైట్లు స్వీకరించబడ్డాయి మరియు ఇతర నమూనాలు సరిపోలేదు. లేదో లేదో full_buffer కీవర్డ్ ఉపయోగిస్తారు, మర్చిపోయి అక్షరాలు expect_out (బఫర్) వ్రాయబడ్డాయి.
ఉంటే patlist కీవర్డ్ శూన్య , మరియు nulls అనుమతించబడతాయి (ద్వారా remove_nulls ఆదేశం), ఒకే ASCII 0 సరిపోలినట్లయితే సంబంధిత శరీరం అమలు అవుతుంది. గ్లోబ్ లేదా రీజెక్స్ నమూనాల ద్వారా 0 బైట్లు సరిపోలడం సాధ్యం కాదు.
ఒక నమూనాను (లేదా eof లేదా full_buffer) సరిపోల్చడానికి, సరిపోలే మరియు గతంలో సరిపోలని అవుట్పుట్ వేరియబుల్లో సేవ్ అవుతుంది expect_out (బఫర్) . 9 regexp substring matches వరకు వేరియబుల్స్ లో సేవ్ చేయబడతాయి expect_out (1, స్ట్రింగ్) ద్వారా expect_out (9, స్ట్రింగ్) . ఉంటే -సూచీలు జెండా ఒక నమూనా, ప్రారంభ మరియు ముగింపు సూచికల ముందు ఉపయోగించబడుతుంది (తగిన రూపంలో lrange ) యొక్క 10 తీగలను వేరియబుల్స్లో నిల్వ చేస్తారు expect_out (X, ప్రారంభం) మరియు expect_out (X, ముగింపు) ఇక్కడ X ఒక అంకె, బఫర్లో పదార్ధ స్థానానికి అనుగుణంగా ఉంటుంది. 0 మొత్తం నమూనాతో సరిపోయే తీగలను సూచిస్తుంది మరియు గ్లోబ్ నమూనాలు అలాగే రీగెక్స్ నమూనాలతో ఉత్పత్తి చేయబడుతుంది. ఉదాహరణకు, ఒక ప్రక్రియ "abcdefgh n" యొక్క ఉత్పత్తిని ఉత్పత్తి చేస్తే, ఫలితంగా:
ఆశ "cd"
ఈ క్రింది ప్రకటనలు అమలు చేయబడినట్లు:
set_out (0, స్ట్రింగ్) cd set expect_out (బఫర్) abcd
మరియు "efgh n" అవుట్పుట్ బఫర్లో మిగిలిపోతుంది. ఒక ప్రక్రియ అవుట్పుట్ "abbbcabkkkka n" ను ఉత్పత్తి చేస్తే, ఫలితంగా:
ఆశలు -ఇవి "బి (బి *). * (k +)"
ఈ క్రింది ప్రకటనలు అమలు చేయబడినట్లు:
(1, ముగింపు) 2 సెట్ expect_out (1, ముగింపు) 3 సెట్ expect_out (1, స్ట్రింగ్) bb setcout (0, స్ట్రింగ్) 1 సెట్ expect_out (0, ముగింపు) 10 సెట్ expect_out (0, స్ట్రింగ్) bbbcabkkkk సెట్ expect_out (2, ప్రారంభం) 10 సెట్ expect_out (2, ముగింపు) 10 సెట్ expect_out (2, స్ట్రింగ్) k సెట్ expect_out (బఫర్) abbbcabkkkk
మరియు "a n" అవుట్పుట్ బఫర్లో మిగిలిపోతుంది. ప్రక్రియ "*" (మరియు -ఆర్ ". *") అవుట్పుట్ బఫర్ను ప్రక్రియ నుండి ఏ అవుట్పుట్ను చదవకుండానే ఫ్లష్ చేస్తుంది.
సాధారణంగా, సరిపోలిన అవుట్పుట్ ఎక్స్పెక్ట్స్ అంతర్గత బఫర్ల నుండి విస్మరించబడుతుంది. ఇది నమూనాతో ఉపసర్గ ద్వారా దీనిని నిరోధించవచ్చు -notransfer జెండా. ఈ జెండా ముఖ్యంగా ప్రయోగాత్మకంగా ఉపయోగకరంగా ఉంటుంది (మరియు ప్రయోగాలు చేస్తున్నప్పుడు సౌలభ్యం కోసం "-కాదు" కు సంక్షిప్తీకరించబడుతుంది).
సరిపోలే అవుట్పుట్తో అనుబంధించబడిన స్పాన్ id (లేదా eof లేదా full_buffer) లో నిల్వ చేయబడుతుంది expect_out (spawn_id) .
ది -సమయం ముగిసినది జెండా ప్రస్తుత అంచె ఆదేశం కింది విలువను గడువు ముగింపు వేరియబుల్ యొక్క విలువను ఉపయోగించి బదులుగా గడువుగా ఉపయోగించుకుంటుంది.
అప్రమేయంగా, నమూనాలు ప్రస్తుత విధానంలో అవుట్పుట్కు వ్యతిరేకంగా సరిపోతాయి, అయినప్పటికీ -i జెండా పేర్కొన్న spawn_id జాబితా నుండి అవుట్పుట్ ఏ కింది విధానాలకు వ్యతిరేకంగా సరిపోతుంది (తదుపరి వరకు -i ). Spawn_id జాబితా స్పాన్_ఐడ్ యొక్క తెల్లని విభజన జాబితాగా లేదా స్పాన్_ఐడ్స్ యొక్క జాబితాను సూచించే వేరియబుల్గా ఉండాలి.
ఉదాహరణకు, ఈ క్రింది ఉదాహరణ ప్రస్తుత ప్రాసెస్ నుండి "కనెక్ట్" కోసం వేచి ఉంటుంది లేదా $ proc2 పేరుతో ఉన్న spawn_id నుండి "బిజీ", "విఫలమైంది" లేదా "చెల్లని పాస్వర్డ్" ను వేచి ఉంటుంది.
{-i $ proc2 బిజీగా {n} బిజీని ఉంచుతుంది n; exp_continue} -re "విఫలమైంది | చెల్లని సంకేతపదం
ప్రపంచ వేరియబుల్ యొక్క విలువ any_spawn_id అన్ని ఇతర పేర్లతో పిలుస్తారు ఏ spawn_ids కు నమూనాలను మ్యాచ్ ఉపయోగించవచ్చు -i ప్రస్తుత జెండాలు ఆశించే ఆదేశం. నుండి spawn_id -i అనుబంధ నమూనా లేని పతాకం (అనగా, వెంటనే మరొకదాని తరువాత -i ) అదే విధంగా ఇతర నమూనాలకి అందుబాటులో ఉంటుంది ఆశించే కమాండ్ సంబంధం any_spawn_id.
ది -i జెండా కూడా ప్రపంచ వేరియబుల్ పేరును కలిగి ఉంటుంది, ఈ సందర్భంలో స్పాన్ ఐడిల జాబితా కోసం వేరియబుల్ చదువుతుంది. ఇది మారినప్పుడు వేరియబుల్ చదవబడుతుంది. కమాండ్ అమలులో ఉన్నప్పుడు I / O మూలాన్ని మార్చటానికి ఇది ఒక మార్గాన్ని అందిస్తుంది. ఈ విధంగా అందించబడిన స్పాన్ ఐడిలు "పరోక్ష" స్పాన్ ఐడిలు అంటారు.
వంటి చర్యలు విరామం మరియు కొనసాగించడానికి నియంత్రణ నిర్మాణాలు కారణం (అంటే, కోసం , proc ) సాధారణ మార్గంలో ప్రవర్తిస్తాయి. కమాండ్ exp_continue అనుమతిస్తుంది ఆశించే దానికదే సాధారణముగా తిరిగి వచ్చేటప్పుడు కాకుండా అమలు చేయడాన్ని కొనసాగిస్తుంది.
ఇది స్పష్టమైన ఉచ్చులు లేదా పదేపదే ఆశించే ప్రకటనలు లేకుండా ఉండటానికి ఉపయోగపడుతుంది. కింది ఉదాహరణ rlogin స్వయంచాలనం చేయడానికి ఒక భాగాన్ని భాగం. ది exp_continue రెండోదాన్ని వ్రాయకుండా ఉండటం మానివేస్తుంది ఆశించే rlogin సంకేతపదము కొరకు ప్రాంప్ట్ చేస్తే ప్రకటన (మళ్ళీ ప్రాంప్ట్ కొరకు చూడండి).
$ హోస్ట్: {expect_user -re "(. *) n" send_user " n" expect_out (1, string) r "stty" పంపించు {host: {password: {stty -echo send_user "password ($ వినియోగదారు కోసం) echo exp_continue} సరికాని {send_user "చెల్లని పాస్వర్డ్ లేదా ఖాతా n" నిష్క్రమణ} గడువు ముగిసింది {host_user "కనెక్షన్ గడువు ముగిసింది n" exit} eof {send_user "కనెక్షన్ హోస్ట్ విఫలమైంది: $ expect_out (బఫర్)" నిష్క్రమణ " తిరిగి $ prompt}
ఉదాహరణకు, కింది భాగం ఇప్పటికే పూర్తిగా ఆటోమేటెడ్ అయిన పరస్పర చర్యకు ఒక యూజర్ గైడ్కు సహాయపడవచ్చు. ఈ సందర్భంలో, టెర్మినల్ ముడి మోడ్లో ఉంచబడుతుంది. వినియోగదారు "+" ప్రెస్ చేస్తే, ఒక వేరియబుల్ పెరుగుతుంది. ఒకవేళ "p" నొక్కినట్లయితే, అనేక రిటర్న్లు ఈ ప్రక్రియకు పంపబడతాయి, బహుశా ఏదో విధంగా అది దెబ్బతీస్తాయి, మరియు "i" వినియోగదారుని ప్రక్రియతో ఇంటరాక్ట్ చేయడానికి, స్క్రిప్ట్ నుండి నియంత్రణను సమర్థవంతంగా దొంగిలిస్తుంది. ప్రతి సందర్భంలో, ది exp_continue ప్రస్తుత అనుమతిస్తుంది ఆశించే ప్రస్తుత చర్యను అమలు చేసిన తర్వాత నమూనా సరిపోలికను కొనసాగించడానికి.
stty raw -echo expect_after {-i $ user_spawn_id "p" {పంపించు r r r "; exp_continue} "+" {incr foo; exp_continue} "i" {ఇంటరాక్ట్; exp_continue} "నిష్క్రమించు" నిష్క్రమణ}
అప్రమేయంగా, exp_continue సమయం ముగిసింది టైమర్ పునఃఅమర్పులకు. టైమర్ పునఃప్రారంభించబడలేదు, ఉంటే exp_continue తో పిలుస్తారు -continue_timer జెండా.
expect_after expect_args
సమానంగా పనిచేస్తుంది expect_before తప్ప రెండు నుండి నమూనాలు ఆశించే మరియు expect_after సరిపోలవచ్చు, ఆ ఆశించే నమూనా ఉపయోగించబడుతుంది. చూడండి expect_before మరింత సమాచారం కోసం కమాండ్.
expect_background expect_args
అదే వాదనలు పడుతుందిఆశించే అయితే ఇది వెంటనే తిరిగి వస్తుంది. కొత్త ఇన్పుట్ వచ్చినప్పుడు నమూనాలు పరీక్షించబడతాయి. నమూనాసమయం ముగిసినది మరియుడిఫాల్ట్ అర్ధం ఉన్నాయిexpect_background మరియు నిశ్శబ్దంగా విస్మరించబడుతున్నాయి. లేకపోతే, ఆexpect_background కమాండ్ ఉపయోగిస్తుందిexpect_before మరియుexpect_after నమూనాలు కేవలం ఇష్టంఆశించే లేదు.
ఎప్పుడుexpect_background చర్యలు విశ్లేషించబడుతున్నాయి, అదే స్పాన్ id కోసం నేపథ్య ప్రాసెసింగ్ బ్లాక్ చేయబడుతుంది. చర్య పూర్తి అయినప్పుడు నేపధ్య ప్రాసెసింగ్ అన్బ్లాక్ అవుతుంది. బ్యాక్ గ్రౌండ్ ప్రాసెసింగ్ నిరోధించబడినప్పుడు, అది (ముందుభాగం)ఆశించే అదే స్పాన్ id లో.
ఒక అమలు చేయడానికి సాధ్యం కాదుఆశించే ఒకexpect_background అన్బ్లాక్ చేయబడింది.expect_background ఒక ప్రత్యేక స్పాన్ ఐడిని అదే స్పాన్ ఐడితో ఒక కొత్త ఆశించని రీతిలో ప్రకటించటం ద్వారా తొలగించబడుతుంది. ప్రకటించుకున్నారుexpect_background ఎటువంటి నమూనా ఇచ్చిన స్పాన్ ఐడిని నేపథ్యంలో నమూనాలతో సరిపోయే సామర్థ్యం నుండి తీసివేస్తుంది.
expect_before expect_args
అదే వాదనలు పడుతుందిఆశించే అయితే ఇది వెంటనే తిరిగి వస్తుంది. ఇటీవలి నుండి సరళి-చర్య జంటలుexpect_before అదే స్పాన్ ఐడిని ఏ కింది వాటికి పరిపూర్ణంగా జోడించబడతాయి
