‫آزﻣﻮن ﻧﺮم اﻓﺰار – ﻓﺼﻞ‪ 5‬ﺑﺨﺶ ‪2-5‬‬

‫آآزﻣﺎﻳﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ ﺑﺮاي ﮔﺮاﻣﺮﻫﺎي‬

‫ﻣﺒﺘﻨﻲ ﺑﺮ ﺑﺮﻧﺎﻣﻪ‬

‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‬
‫ﺷﻬﺮﻗﺪس‬
‫واﺣﺪ ﺷ ﻗﺪ‬
‫اﺳﻼﻣﻲ – ا ﺪ‬
‫داﻧﺸﮕﺎه آزاد ا ﻼ‬
‫داﻧﺸﮕﺎ‬
 ‫آزﻣﺎﻳﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻫﺎ‬

‫• آزﻣﺎﻳﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ از اﺑﺘﺪا ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﻃﺮاﺣﻲ ﺷﺪ و اﻏﻠﺐ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﻪ ﻛﺎر ﻣﻲ رود‪.‬‬

‫• ﻣﻌﻴﺎرﻫﺎي ‪ BNF‬ﺑﻴﺸﺘﺮ ﺑﺮاي آزﻣﺎﻳﺶ ﻛﺎﻣﭙﺎﻳﻠﺮﻫﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪.‬‬

‫– آزﻣﺎﻳﺶ ﭙ‬
‫ﻛﺎﻣﭙﺎﻳﻠﺮﻫﺎ ﺑﺴﻴﺎر ﭘﭘﻴﭽﻴﺪه اﺳﺖ‪.‬‬
‫– ﻣﻌﻴﺎرﻫﺎي ‪ BNF‬ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﺗﻮﻟﻴﺪ ﺑﺮﻧﺎﻣﻪ ﺑﺮاي آزﻣﺎﻳﺶ ﻫﻤﻪ اﻣﻜﺎﻧﺎت زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻛﻤﻚ ﻛﻨﺪ‪.‬‬
‫– اﻳﻦ ﻳﻚ ﻛﺎرﺑﺮد ﺧﻴﻠﻲ ﺧﺎص اﺳﺖ ﻛﻪ درﺑﺎره اش در اﻳﻦ درس وارد ﺟﺰﺋﻴﺎت ﺑﻴﺸﺘﺮي ﻧﻤﻲ ﺷﻮﻳﻢ‪.‬‬

‫• ﻣﻌﻴﺎرﻫﺎي آزﻣﺎﻳﺶ ﺟﻬﺶ ﺑﻴﺸﺘﺮ ﺑﺮاي آزﻣﺎﻳﺶ واﺣﺪ )‪ (unit testing‬و آزﻣﺎﻳﺶ ﻳﻜﭙﺎرﭼﻪ‬
‫ﺳﺎزي )‪ (integration testing‬ﻛﻼﺳﻬﺎ ﺑﻪ ﻛﺎر ﻣﻲ رود‪.‬‬

‫‪2‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﮔﺮاﻣﺮﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ﺑﺮﻧﺎﻣﻪ‬

‫• ﻛﺎرﺑﺮد اوﻟﻴﻪ و وﺳﻴﻊ ﺗﺮﻳﻦ ﻛﺎرﺑﺮد از آزﻣﺎﻳﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ‪ ،‬ﺗﻐﻴﻴﺮ دادن ﺑﺮﻧﺎﻣﻪ ﻫﺎ اﺳﺖ‪.‬‬

‫• اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ‪ ،‬ﻳﻚ رﺷﺘﻪ ﭘﺎﻳﻪ )ﻛﻪ ﻫﻤﺎن ﺑﺮﻧﺎﻣﻪ ﺗﺤﺖ ﺗﺴﺖ اﺳﺖ( را ﺗﻐﻴﻴﺮ ﻣﻲ دﻫﻨﺪ ﺗﺎ‬
‫ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺟﻬﺸﮕﺮ را اﻳﺠﺎد ﻛﻨﻨﺪ‪.‬‬

‫• ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺟﻬﺸﮕﺮ ﺑﺎﻳﺪ ﺑﻪ درﺳﺘﻲ ﻛﺎﻣﭙﺎﻳﻞ ﺷﻮﻧﺪ )رﺷﺘﻪ ﻣﻌﺘﺒﺮ ﺑﺎﺷﻨﺪ(‪.‬‬

‫• ﺟﻬﺸﮕﺮﻫﺎ آزﻣﻮن ﻧﻴﺴﺘﻨﺪ‪ ،‬وﻟﻲ ﺑﺮاي ﻳﺎﻓﺘﻦ آزﻣﻮﻧﻬﺎ ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ‪.‬‬

‫• وﻗﺘﻲ ﺟﻬﺸﮕﺮﻫﺎ ﺗﻌﺮﻳﻒ ﺷﺪﻧﺪ‪ ،‬ﺑﺎﻳﺪ آزﻣﻮﻧﻬﺎﻳﻲ را ﺑﻴﺎﺑﻴﻢ ﻛﻪ ﻣﻮﺟﺐ ﺧﺮاﺑﻲ در اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺷﻮد‪.‬‬
‫• و اﻳﻦ ﻳﻌﻨﻲ ﻛﺸﺘﻦ ﺟﻬﺸﮕﺮﻫﺎ‪.‬‬

‫‪3‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻛﺸﺘﻦ ﺟﻬﺸﮕﺮﻫﺎ‬
‫اﮔﺮ ‪ m ∈ M‬ﺟﻬﺸﮕﺮي ﺑﺮاي ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪) P‬ﺑﻪ ﻋﻨﻮان رﺷﺘﻪ ﭘﺎﻳﻪ(‪ ،‬و ‪t‬‬
‫ﻳﻚ آزﻣﻮن ﺑﺎﺷﺪ‪ ،‬ﻣﻲﮔﻮﻳﻴﻢ ‪ m ،t‬را ﻣﻲ ﻛُﺸﺪ اﮔﺮ و ﻓﻘﻂ اﮔﺮ ﺧﺮوﺟﻲ ‪t‬‬
‫ﺑﺎﺷﺪ‪.‬‬ ‫روي ‪ P‬ﺎﺑﺎ ﺧﺮوﺟﻲ آآن روي ‪ m‬ﺎ‬
‫ﻣﺘﻔﺎوت ﺎﺷ‬

‫ﺧﻮاﻫﻨﺪ‬
‫ﻮي ﻮ ﻫ‬
‫ﺑﺴﻴﺎرر ﻗﻮي‬
‫ي ﺑﺑﻪ دﺳﺖ آﻣﺪه ﺑ ﻴ‬
‫آزﻣﻮﻧﻬﺎي‬
‫ﻲ ﺷﺪه ﺑﺑﺎﺷﻨﺪ‪ ،‬ز ﻮ ﻬ‬
‫ﻃﺮاﺣﻲ‬
‫ﻮﺑﻲ ﺮ‬
‫ي ﺟﻬﺶ ﺑﺑﻪ ﺧﻮﺑﻲ‬ ‫• اﮔﺮﺮ ﭘﺮ ﻮرﻫ‬
‫اﭘﺮاﺗﻮرﻫﺎي‬
‫ﺑﻮد‪.‬‬

‫ﺗﻌﺮﻳﻒ ﻛﻛﺮد‪.‬‬
‫را ﺗ ﻒ‬‫ﻣﺨﺘﻠﻔﻲ ا‬
‫اﭘﺮاﺗﻮرﻫﺎي ﺨﺘﻠﻔ‬
‫ﺑﺎﻳﺪ ا اﺗ ﺎ‬
‫ﻣﺘﻔﺎوت‪ ،‬ﺎ ﺪ‬
‫اﻫﺪاف ﺘﻔﺎ ت‬
‫ﻣﺨﺘﻠﻒ و ا ﺪاف‬
‫زﺑﺎﻧﻬﺎي ﺨﺘﻠﻒ‬ ‫• ا‬
‫ﺑﺮاي ز ﺎﻧ ﺎ‬

‫ﻲ دﻫﺪ‪.‬‬
‫ﺶ اداﻣﻪ ﻣﻲ‬
‫آزﻣﻮﻧﮕﺮﺮ ﺑﺑﻪ آزﻣﺎﻳﺶ‬
‫ﺷﻮﻧﺪ‪ ،‬ﻮ‬
‫ﺟﻬﺸﮕﺮﻫﺎ ﻛﺸﺘﻪ ﻮ‬ ‫• ﺗﺎ ووﻗﺘﻲ‬
‫ﻲ ﻛﻪ ﻫﻤﻪ ﺟﻬ ﺮ‬
‫ﺟﻬﺸﮕﺮ ﻣﺮده )‪ :(dead mutant‬ﺟﻬﺸﮕﺮي ﻛﻪ ﻳﻚ آزﻣﻮن آن را ﻛﺸﺘﻪ اﺳﺖ‪.‬‬ ‫–‬
‫ﺟﻬﺸﮕﺮ ﻣﺮده ﺑﻪ دﻧﻴﺎ آﻣﺪه )‪ :(stillborn mutant‬ﺟﻬﺸﮕﺮي ﻛﻪ از ﻧﻈﺮ ﻧﺤﻮي ﺻﺤﻴﺢ ﻧﻴﺴﺖ‪.‬‬ ‫–‬
‫ن ررا ﺑﺑﻜﺸﺪ‪.‬‬
‫ﺗﻮاﻧﺪ آن‬
‫ﻲ ﻮ‬‫ﻲ ﻣﻲ‬
‫آزﻣﻮﻧﻲ‬ ‫ﻳﻬﻲ )‪ :(trivial mutant‬ﺗﻘﺮﻳﺒ‬
‫ﺮﻳﺒﺎً ﻫﺮﺮ ز ﻮ‬ ‫ﺟﻬﺸﮕﺮﺮ ﺑﺑﺪﻳﻬﻲ‬
‫ﺟﻬ‬ ‫–‬
‫ﺟﻬﺸﮕﺮ ﻣﻌﺎدل )‪ :(equivalent mutant‬ﻫﻴﭻ آزﻣﻮﻧﻲ ﻧﻤﻲ ﺗﻮاﻧﺪ آن را ﺑﻜﺸﺪ )ﻣﻌﺎدل ﺑﺮﻧﺎﻣﻪ اﺻﻠﻲ اﺳﺖ(‪.‬‬ ‫–‬

‫‪4‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﮔﺮاﻣﺮﻫﺎي ﻣﺒﺘﻨﻲ ﺑﺮ ﺑﺮﻧﺎﻣﻪ‬
‫ﻣﺘﺪ اوﻟﻴﻪ‬ ‫ﻣﺘﺪ ﺑﺎ ﺟﺎﺳﺎزي ﭼﻨﺪ ﺟﻬﺸﮕﺮ‬

‫))‪int Min ((int A, int B‬‬ ‫)‪int Min (int A, int B‬‬ ‫ﻣﺘﻐﻴﺮ ﺑﺑﻪ‬
‫ﺟﺎﻳﮕﺬاري ﻳﻳﻚ ﻴﺮ‬
‫ﺟ ﻳ ري‬
‫{‬ ‫{‬ ‫ﺟﺎي دﻳﮕﺮي‬
‫;‪int minVal‬‬ ‫;‪int minVal‬‬
‫;‪minVal = A‬‬
‫;‪minVal = A‬‬ ‫ﺗﻐﻴﻴﺮ ﻋﻤﻠﮕﺮ‬
‫)‪if (B < A‬‬ ‫;‪∆ 1 minVal = B‬‬
‫)‪if (B < A‬‬
‫{‬ ‫اﻳﺠﺎد ﺧﺮاﺑﻲ آﻧﻲ در زﻣﺎن اﺟﺮا ﺑﻪ‬
‫)‪∆ 2 if (B > A‬‬
‫;‪minVal = B‬‬ ‫ﻣﺤﺾ رﺳﻴﺪن ﺑﻪ اﻳﻦ دﺳﺘﻮر‬
‫))‪∆ 3 if ((B < minVal‬‬
‫}‬
‫{‬
‫;)‪return (minVal‬‬ ‫;‪minVal = B‬‬
‫اﻳﺠﺎد ﺧﺮاﺑﻲ آﻧﻲ در زﻣﺎن اﺟﺮا ﺑﻪ‬
‫ﺷﺮط آن ﻛﻪ ‪ B==0‬ﺷﻮد‪ .‬در ﻏﻴﺮ‬
‫‪} // end Min‬‬ ‫‪∆4‬‬ ‫;)( ‪Bomb‬‬ ‫اﻳﻦ ﺻﻮرت ﻛﺎري ﻧﻤﻲ ﻛﻨﺪ‪.‬‬
‫‪∆5‬‬ ‫‪minVal‬‬
‫;‪i V l = A‬‬
‫‪A‬‬
‫‪ 6‬ﺟﻬﺸﮕﺮ ﻛﻪ ﻫﺮ ﻳﻚ‪،‬‬ ‫‪∆6‬‬ ‫;)‪minVal = failOnZero (B‬‬
‫ﻧﺸﺎن دﻫﻨﺪه ﺑﺮﻧﺎﻣﻪ‬ ‫}‬
‫ﻣﺠﺰاﻳﻲ ااﺳﺖ‪.‬‬
‫ا‬ ‫;)‪return (minVal‬‬
‫‪} // end Min‬‬

‫‪5‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻣﻌﻴﺎرﻫﺎي ﭘﻮﺷﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ‬
‫ﭘﻮﺷﺶ ﺟﻬﺶ )‪:(MC) (Mutation Coverage‬‬
‫ﺑﺮاي ﻫﺮ ﺟﻬﺸﮕﺮ ‪ TR ،m ∈ M‬دﻗﻴﻘﺎً داراي ﻳﻚ ﻧﻴﺎزﻣﻨﺪي اﺳﺖ‪ :‬ﻛﺸﺘﻦ ‪.m‬‬

‫• ﻳﺎدآوري ﻣﺪل ‪ RIP‬از ﻓﺼﻞ ‪:1‬‬

‫دﺳﺘﺮﺳﻲ‬
‫ﻲ‬ ‫ﺮ‬ ‫ﻣﻮرد‬
‫ﻧﻘﺺ‪ ،‬ﻮر‬
‫ي ﺺ‬ ‫داراي‬
‫ﻋﺒﺎرت ر‬
‫ﺷﻮد ﻛﻪ ﺒ ر‬
‫ﻲ ﻮ‬‫ﻮﺟﺐ ﻣﻲ‬
‫ﻮن ﻣﻮﺟﺐ‬ ‫‪ :(Reachability‬ز‬
‫آزﻣﻮن‬ ‫ﻳﺮي )‪y‬‬ ‫– دﺳﺘﺮس‬
‫ﺮس ﭘﭘﺬﻳﺮي‬
‫ﻗﺮار ﮔﻴﺮد )در ﺟﻬﺶ‪ :‬ﻋﺒﺎرت ﺟﻬﺶ ﻳﺎﻓﺘﻪ(‪.‬‬

‫– آﻟﻮده ﺳﺎزي )‪ :(Infection‬آزﻣﻮن ﻣﻮﺟﺐ ﻣﻲ ﺷﻮد ﻛﻪ ﻋﺒﺎرت داراي ﻧﻘﺺ ﻣﻨﺠﺮ ﺑﻪ ﻳﻚ ﺣﺎﻟﺖ اﺷﺘﺒﺎه‬
‫ﺷﻮد‪.‬‬

‫ﺧﺮوﺟﻲ اﺷﺘﺒﺎه‬ ‫– اﻧﺘﺸﺎر )‪ :(Propagation‬ﺣﺎﻟﺖ اﺷﺘﺒﺎه ﺑﻪ ﺧﺮوﺟ‬

‫ﺧﺮوﺟﻲ ﻣﻨﺘﺸﺮ ﺷﺪه و ﻣﻨﺠﺮ ﺑﻪ ﻣﺸﺎﻫﺪه ﺧﺮوﺟ‬
‫ﻣﻲﺷﻮد‪.‬‬

‫• ﻣﺪل ‪ RIP‬ﻣﻨﺠﺮ ﺑﻪ دو ﮔﻮﻧﻪ ﭘﻮﺷﺶ ﺟﻬﺶ ﻣﻲ ﺷﻮد‪ :‬ﻛﺸﺘﻦ ﻗﻮي ﺟﻬﺸﮕﺮﻫﺎ و ﻛﺸﺘﻦ ﺿﻌﻴﻒ ﺟﻬﺸﮕﺮﻫﺎ‬
‫‪6‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻣﻌﻴﺎرﻫﺎي ﭘﻮﺷﺶ ﻣﺒﺘﻨﻲ ﺑﺮ ﻧﺤﻮ‪...‬‬
‫• ‪ (1‬ﻛﺸﺘﻦ ﻗﻮي ﺟﻬﺸﮕﺮﻫﺎ‬
‫• اﮔﺮ ‪ m ∈ M‬ﺟﻬﺸﮕﺮي ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ‪ ،P‬و ‪ t‬ﻳﻚ آزﻣﻮن ﺑﺎﺷﺪ‪ ،‬ﻣﻲﮔﻮﻳﻴﻢ ‪ m ،t‬را ﺑﻪ ﻃﻮر ﻗﻮي‬
‫روي ‪ m‬ﺘﻔﺎوت‬
‫ﻣﺘﻔﺎوت ﺑﺎﺷﺪ‪.‬‬ ‫روي ‪ P‬ﺑﺎ ﺧ وﺟ‬
‫ﺧﺮوﺟﻲ آن وي‬ ‫ﺧﺮوﺟﻲ ‪ t‬وي‬
‫اﮔﺮ ﺧ وﺟ‬
‫اﮔﺮ و ﻓﻘﻂ اﮔ‬
‫ﻛﺸﺪ اﮔ‬
‫ﻣﻲﻛُﺸﺪ‬

‫• ‪ (2‬ﻛﺸﺘﻦ ﺿﻌﻴﻒ ﺟﻬﺸﮕﺮﻫﺎ‬

‫• اﮔﺮ ‪ m ∈ M‬ﺟﻬﺸﮕﺮي ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ‪ P‬ﺑﺎﺷﺪ ﻛﻪ ﻣﺤﻞ ‪ l‬از آن ﺑﺮﻧﺎﻣﻪ را ﺗﻐﻴﻴﺮ داده ﺑﺎﺷﺪ‪ ،‬و ‪t‬‬
‫ﺖ اﺟﺮاي ‪P‬‬ ‫ﺪ ااﮔﺮﺮ و ﻓﻘﻂ ااﮔﺮﺮ ﺣﺎﻟﺖ‬
‫ﻲ ﻛُﺸﺪ‬
‫ﻴﻒ ﻣﻲ‬ ‫ﻮﻳﻴﻢ ‪ m ،t‬را ﺑﺑﻪ ﻃﻮر‬
‫ﻮر ﺿﻌﻴﻒ‬ ‫ﻲﮔﻮﻳﻴﻢ‬
‫ﺑﺎﺷﺪ‪ ،‬ﻣﻲ‬
‫ﻮن ﺑ ﺪ‬‫آزﻣﻮن‬
‫ﻳﻚ آز‬
‫ﺑﻼﻓﺎﺻﻠﻪ ﺑﻌﺪ از ‪ l‬ﺑﺎ اﺳﺘﻔﺎده از ‪ t‬ﻣﺘﻔﺎوت ﺑﺎ ﺣﺎﻟﺖ اﺟﺮاي ‪ m‬ﺑﻼﻓﺎﺻﻠﻪ ﺑﻌﺪ از ‪ l‬ﺑﺎ اﺳﺘﻔﺎده از ‪t‬‬
‫ﺑﺎﺷﺪ‪.‬‬

‫– در واﻗﻊ‪ ،‬ﻛﺸﺘﻦ ﺿﻌﻴﻒ‪ ،‬دﺳﺘﺮس ﭘﺬﻳﺮي و آﻟﻮده ﺳﺎزي را ﺑﺮآورده ﻣﻲ ﻛﻨﺪ وﻟﻲ اﻧﺘﺸﺎر را ﺧﻴﺮ‪.‬‬

‫‪7‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﺟﻬﺶ ﺿﻌﻴﻒ‬
‫ﭘﻮﺷﺶ ﺟﻬﺶ ﺿﻌﻴﻒ )‪:(WMC) (Weak Mutation Coverage‬‬
‫ﺑﺮاي ﻫﺮ ﺟﻬﺸﮕﺮ ‪ TR ،m ∈ M‬دﻗﻴﻘﺎً داراي ﻳﻚ ﻧﻴﺎزﻣﻨﺪي اﺳﺖ‪ :‬ﻛﺸﺘﻦ ‪ m‬ﺑﻪ‬
‫ﺿﻌﻴﻒ‪.‬‬
‫ﻃﻮر ﺿﻌ ﻒ‬
‫ﻃ‬

‫• ﺟﻬﺶ ﺿﻌﻴﻒ‪ ،‬از آن ﺟﻬﺖ ﺑﻪ اﻳﻦ ﺷﻜﻞ ﻧﺎﻣﮕﺬاري ﺷﺪه ﻛﻪ ﻛﺸﺘﻦ ﺟﻬﺸﮕﺮﻫﺎ در آن آﺳﺎﻧﺘﺮ اﺳﺖ و ﺑﻪ‬
‫ﺗﺤﻠﻴﻞ ﻛﻤﺘﺮي ﻫﻢ ﻧﻴﺎز دارد‪.‬‬

‫• ﺑﺮﺧﻲ ﺟﻬﺸﮕﺮﻫﺎ را ﻣﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﺿﻌﻴﻒ ﻛﺸﺖ‪ ،‬وﻟﻲ ﻧﻤﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﻗﻮي ﻛﺸﺖ )داراي ﺧﺎﺻﻴﺖ‬
‫اﻧﺘﺸﺎر ﻧﻴﺴﺘﻨﺪ(!‬

‫• در ﻋﻤﻞ‪ ،‬ﺗﻔﺎوت آﻧﻬﺎ ﺑﺴﻴﺎر ﻛﻢ اﺳﺖ‪.‬‬

‫‪8‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻣﺜﺎل از ﺟﻬﺶ )ﻗﻮي(‬
‫;‪minVal = A‬‬ ‫• ﺟﻬﺸﮕﺮ ‪ 1‬در ﻣﺜﺎل )(‪ Min‬ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ‪:‬‬
‫;‪∆ 1 minVal = B‬‬
‫)‪if (B < A‬‬
‫;‪minVal = B‬‬
‫• ﻣﺸﺨﺼﺎت ﻛﺎﻣﻞ آزﻣﻮﻧﻲ ﻛﻪ ﺑﺘﻮاﻧﺪ ﺟﻬﺸﮕﺮ ‪ 1‬را ﺑﻜﺸﺪ ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫• ‪ (1‬ﺷﺮط دﺳﺘﺮس ﭘﺬﻳﺮي‪true :‬‬

‫)ﻫﻤﻴﺸﻪ ﺑﺮﻗﺮار اﺳﺖ؛ ﻫﻤﻮاره ﺑﻪ اﻳﻦ ﻋﺒﺎرت ﻣﻲ رﺳﻴﻢ(‬ ‫•‬
‫• ‪ (2‬ﺷﺮط آﻟﻮده ﺳﺎزي‪A ≠ B :‬‬
‫ﺷﻮد(‬
‫ﮔﺰ ﻛﺸﺘﻪ ﻧﻧﻤﻲ ﺷ د‬
‫ﺖ و ﻫﻫﺮﮔﺰ‬
‫اﺻﻠﻲ ااﺳﺖ‬
‫ﺑﺮﻧﺎﻣﻪ ا ﻠ‬
‫ﻣﻌﺎدل ﻧﺎ ﻪ‬
‫ﺟﻬﺸﮕﺮ‪ ،‬ﺎدل‬
‫ﺑﺎﺷﻨﺪ‪ ،‬ﺸﮕ‬ ‫اﮔﺮ ‪ A‬و ‪ B‬ا‬
‫ﺑﺮاﺑﺮ ﺎﺷﻨﺪ‬ ‫)اﮔ‬ ‫•‬
‫• ‪ (3‬ﺷﺮط اﻧﺘﺸﺎر‪) (B < A) = false :‬اﺟﺮاي ﺑﺮﻧﺎﻣﻪ از اﻧﺘﺴﺎب ﺑﻌﺪ از دﺳﺘﻮر ‪ if‬ﺑﭙﺮد(‬
‫)اﮔﺮ ‪ false‬ﻧﺒﺎﺷﺪ‪ ،‬ﺑﺎز ﻫﻢ آﻧﭽﻪ ﺑﻪ ﺧﺮوﺟﻲ ﻣﻲ رﺳﺪ‪ ،‬ﻣﻌﺎدل ﺑﺮﻧﺎﻣﻪ اﺻﻠﻲ ﺧﻮاﻫﺪ ﺑﻮد(‬ ‫•‬

‫)‪true ∧ (A ≠ B) ∧ ((B < A) = false‬‬ ‫• ﻣﺸﺨﺼﺎت ﻛﺎﻣﻞ آزﻣﻮن‪:‬‬

‫)‪≡ (A ≠ B) ∧ (B ≥A‬‬
‫)‪≡ (B > A‬‬

‫ﺑﻨﺎ ﺑﺮ اﻳﻦ آزﻣﻮﻧﻲ ﻣﺎﻧﻨﺪ )‪ (A = 5, B = 7‬ﺟﻬﺸﮕﺮ ‪ 1‬را »ﻗﻮﻳﺎً« ﺧﻮاﻫﺪ ﻛﺸﺖ‪.‬‬

‫‪9‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻣﺜﺎل از ﺟﻬﺶ )ﺿﻌﻴﻒ(‬
‫;‪minVal = A‬‬ ‫• ﺑﺎز ﻫﻢ ﺑﺮاي ﺟﻬﺸﮕﺮ ‪ 1‬در ﻣﺜﺎل )(‪:Min‬‬
‫;‪∆ 1 minVal = B‬‬
‫)‪if (B < A‬‬
‫;‪minVal = B‬‬
‫• ﮔﻔﺘﻴﻢ ﻣﺸﺨﺼﺎت ﻛﺎﻣﻞ آزﻣﻮﻧﻲ ﻛﻪ ﺑﺘﻮاﻧﺪ ﺟﻬﺸﮕﺮ ‪ 1‬را ﺑﻜﺸﺪ ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫• ‪ (1‬ﺷﺮط دﺳﺘﺮس ﭘﺬﻳﺮي‪true :‬‬

‫)ﻫﻤﻴﺸﻪ ﺑﺮﻗﺮار اﺳﺖ؛ ﻫﻤﻮاره ﺑﻪ اﻳﻦ ﻋﺒﺎرت ﻣﻲ رﺳﻴﻢ(‬ ‫•‬
‫• ‪ (2‬ﺷﺮط آﻟﻮده ﺳﺎزي‪A ≠ B :‬‬
‫ﺷﻮد(‬
‫ﮔﺰ ﻛﺸﺘﻪ ﻧﻧﻤﻲ ﺷ د‬
‫ﺖ و ﻫﻫﺮﮔﺰ‬
‫اﺻﻠﻲ ااﺳﺖ‬
‫ﺑﺮﻧﺎﻣﻪ ا ﻠ‬
‫ﻣﻌﺎدل ﻧﺎ ﻪ‬
‫ﺟﻬﺸﮕﺮ‪ ،‬ﺎدل‬
‫ﺑﺎﺷﻨﺪ‪ ،‬ﺸﮕ‬ ‫اﮔﺮ ‪ A‬و ‪ B‬ا‬
‫ﺑﺮاﺑﺮ ﺎﺷﻨﺪ‬ ‫)اﮔ‬ ‫•‬

‫)‪true ∧ (A ≠ B‬‬ ‫• ﻣﺸﺨﺼﺎت ﻛﺎﻣﻞ آزﻣﻮن‪:‬‬

‫)‪≡ (A ≠ B‬‬

‫ﺑﻨﺎ ﺑﺮ اﻳﻦ آزﻣﻮﻧﻲ ﻣﺎﻧﻨﺪ )‪) (A = 2, B =1‬و اﻟﺒﺘﻪ آزﻣﻮن اﺳﻼﻳﺪ ﻗﺒﻞ ﻳﻌﻨﻲ )‪ ((A = 5, B = 7‬ﺟﻬﺸﮕﺮ ‪ 1‬را‬
‫»ﺑﻪ ﻃﻮر ﺿﻌﻴﻒ« ﺧﻮاﻫﺪ ﻛﺸﺖ‪.‬‬

‫*‪/‬واﺿﺢ اﺳﺖ ﻛﻪ آزﻣﻮﻧﻲ ﻛﻪ ﺑﺘﻮاﻧﺪ ﺟﻬﺸﮕﺮي را ﺑﻪ ﻃﻮر ﻗﻮي ﺑﻜﺸﺪ‪ ،‬ﻣﻲ ﺗﻮاﻧﺪ آن را ﺑﻪ ﻃﻮر ﺿﻌﻴﻒ ﻫﻢ ﺑﻜﺸﺪ‪*\.‬‬
‫‪10‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻣﺜﺎل از ﺟﻬﺸﮕﺮ ﻣﻌﺎدل‬
‫;‪minVal = A‬‬ ‫• ﺟﻬﺸﮕﺮ ‪ 3‬در ﻣﺜﺎل )(‪ Min‬ﺑﻪ اﻳﻦ ﺷﻜﻞ اﺳﺖ‪:‬‬
‫)‪if (B < A‬‬
‫)‪∆ 3 if (B < minVal‬‬

‫• ﺷﺮط آﻟﻮده ﺳﺎزي‪(B < A) != (B < minVal) :‬‬

‫• وﻟﻲ ﻋﺒﺎرت ﻗﺒﻠﻲ ‪ minVal = A‬ﺑﻮد‪ .‬اﮔﺮ ﺟﺎﻳﮕﺬاري ﻛﻨﻴﻢ ﺧﻮاﻫﻴﻢ داﺷﺖ‪:‬‬
‫)‪(B < A) != (B < A‬‬

‫• واﺿﺢ اﺳﺖ ﻛﻪ ﻫﻴﭻ آزﻣﻮﻧﻲ ﻧﻤﻲ ﺗﻮاﻧﺪ آن را ﺑﻜﺸﺪ‬

‫ﺑﻜﺸﺪ!!‬

‫‪11‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﺟﻬﺶ ﻗﻮي در ﺑﺮاﺑﺮ ﺟﻬﺶ ﺿﻌﻴﻒ‬
‫ﺑﺮﻧﺎﻣﻪ ﺗﺸﺨﻴﺺ زوج ﺑﻮدن ﻳﻚ ﻋﺪد‬
‫)‪1 boolean isEven (int X‬‬
‫{ ‪2‬‬ ‫دﺳﺘﺮس ﭘﺬﻳﺮي‪X < 0 :‬‬
‫‪3‬‬ ‫)‪if (X < 0‬‬
‫‪4‬‬ ‫;‪X = 0 - X‬‬ ‫آﻟﻮدﮔﻲ‪X != 0 :‬‬
‫‪∆4‬‬ ‫;‪X = 0‬‬
‫‪5‬‬ ‫‪if (float) (X/2) == ((float) X) / 2.0‬‬ ‫آزﻣﻮﻧﻲ ﻣﺜﻞ )‪ (X = -6‬ﺟﻬﺸﮕﺮ ‪4‬‬
‫‪6‬‬ ‫;)‪return (true‬‬ ‫را ﺑﺎ ﺟﻬﺶ ﺿﻌﻴﻒ ﺧﻮاﻫﺪ ﻛﺸﺖ‪.‬‬
‫‪7‬‬ ‫‪else‬‬
‫اﻧﺘﺸﺎر‪ :‬ﺑﺎﻳﺪ اﺛﺮ آﻟﻮدﮔﻲ را ﺑﻪ ﺧﺮوﺟﻲ ﺑﺮﺳﺎﻧﻴﻢ‪ .‬اﮔﺮ ﺧﺮوﺟﻲ ‪true‬‬
‫‪8‬‬ ‫;)‪return (false‬‬ ‫ﺑﺎﺷﺪ‪ ،‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ ﻛﻪ ﺻﻔﺮ زوج اﺳﺖ‪ ،‬ﺧﺮوﺟﻲ درﺳﺘﻲ اﺳﺖ‪ .‬ﭘﺲ‬
‫‪9‬‬ ‫}‬ ‫ﺧﺮوﺟﻲ ﺑﺎﻳﺪ ‪ false‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺷﺮط ‪ if‬ﻫﻢ ﺑﺎﻳﺪ ‪ false‬ﺑﺎﺷﺪ‪.‬‬

‫)‪((float) ((0-X)/2) == ((float) 0-X) / 2.0‬‬

‫)‪!= ((float) (0/2) == ((float) 0) / 2.0‬‬
‫ﻳﻌﻨﻲ ‪ X‬ززوج ﻧ ﺎﺷ‬
‫ﻧﺒﺎﺷﺪ‪.‬‬
‫ﭘﺲ )‪ (X = -6‬ﺟﻬﺸﮕﺮ را ﺑﺎ ﺟﻬﺶ ﻗﻮي ﻧﻤﻲﻛﺸﺪ‪.‬‬
‫‪12‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫آزﻣﺎﻳﺶ ﺑﺮﻧﺎﻣﻪ ﻫﺎ ﺑﺎ ﺟﻬﺶ‬
‫ﺑﺮﻧﺎﻣﻪ‬ ‫ﻣﺘﺪ آزﻣﻮن‬ ‫اﻳﺠﺎد‬ ‫اﺟﺮاي ﺗﺸﺨﻴﺺ‬ ‫ﺗﻮﻟﻴﺪ ﻣﻮارد‬ ‫اﺟﺮاي ‪T‬‬
‫ورودي‬ ‫ﺟﻬﺸﮕﺮﻫﺎ‬ ‫دﻫﻨﺪه ﻣﻌﺎدل‬ ‫آزﻣﻮن‬ ‫روي ‪P‬‬

‫ﺗﻌﺮﻳﻒ‬ ‫اﺟﺮاي ﺟﻬﺸﮕﺮﻫﺎ‪:‬‬

‫آﺳﺘﺎﻧﻪ‬
‫آ ﺎ‬ ‫ﺷﻤﺎ‬
‫‪‬ﻤﺎ‬ ‫•ﻣﺒﺘﻨ‬
‫ﻣﺒﺘﻨﻲ ﺑﺑﺮ ﺷ‬
‫ﮔﺎﻣﻬﺎي‬
‫ﺧﻮدﻛﺎر‬ ‫•ﺿﻌﻴﻒ‬
‫ﺧﻴﺮ‬ ‫•اﻧﺘﺨﺎﺑﻲ‬

‫ﺣﺬف ﻣﻮارد‬
‫ﺑﻪ آﺳﺘﺎﻧﻪ‬
‫ﻧﺎﻣﺆﺛﺮﺮ‬
‫آزﻣﻮن ﺆ‬
‫ﻮ‬
‫ﺪ ؟‬
‫رﺳﻴﺪﻳﻢ؟‬

‫اﺻﻼح‬ ‫ﺧﻴﺮ‬
‫ﻴﺮ‬ ‫)‪P (T‬‬
‫‪P‬‬ ‫ﺖ‬
‫درﺳﺖ‬ ‫ﻠﻪ‬
‫ﺑﻠﻪ‬
‫اﺳﺖ؟‬
‫‪13‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﭼﺮا ﺟﻬﺶ ﻛﺎر ﻣﻲ ﻛﻨﺪ؟‬
‫ﻗﻀﻴﻪ ﺑﻨﻴﺎدي آزﻣﺎﻳﺶ ﺟﻬﺶ‬
‫وﺟﻮد‬
‫ﺟﻬﺸﮕﺮﻫﺎ و ﻮ‬
‫ﻣﺠﻤﻮﻋﻪ اي از ﻬ ﺮ‬
‫ﻮ‬ ‫ﻲ ﺑﺑﺎﺷﺪ‪ ،‬ﻣﻌﻤﻮﻮ ًﻻ‬
‫اﻓﺰار داراي ﻧﻘﺼﻲ‬
‫ﺮم ﺰ‬‫اﮔﺮﺮ ﻧﺮم‬
‫دارﻧﺪ ﻛﻪ ﺗﻨﻬﺎ ﺑﺎ ﻣﻮرد آزﻣﻮﻧﻲ ﻣﻲ ﺗﻮاﻧﻨﺪ ﻛﺸﺘﻪ ﺷﻮﻧﺪ ﻛﻪ آن ﻧﻘﺺ را ﻧﻴﺰ‬
‫ﺗﺸﺨﻴﺺ ﻣﻲ دﻫﺪ‪.‬‬
‫• اﻳﻦ ﻣﻮﺿﻮع‪ ،‬ﻣﻄﻠﻖ ﻧﻴﺴﺖ!‬

‫ﻫﺪاﻳﺖ ﻣﻲ ﻛﻨﺪ‪.‬‬
‫ﻣﻮﺛﺮ ﻫﺪا ﺖ‬
‫ﺑﺴﻴﺎر ﺛ‬
‫آزﻣﻮﻧﻬﺎي ﺎ‬
‫ﻣﺠﻤﻮﻋﻪ ااي از آز ﻧ ﺎ‬
‫ﻪ‬ ‫را ﻪ‬
‫ﺑﻪ‬ ‫آزﻣﻮﻧﮕﺮ ا‬
‫ﺟﻬﺸﮕﺮﻫﺎ آز ﻧﮕ‬
‫ﺸﮕ ﻫﺎ‬ ‫•‬

‫ﻲ ﺑﺮاي ﺟﻬﺶ‬
‫ﺶ‬ ‫ﺺ و ﻣﺠﻤﻮﻋﻪ اي از آزﻣﻮﻧﻬﺎي ﻛﺎﻓﻲ‬
‫ﻦ ﻳﻚ ﻧﻘﺺ‬
‫ﺶ ﺑﺮاﻧﮕﻴﺰ‪ ،‬ﻳﺎﻓﺘﻦ‬
‫ﭼﺎﻟﺶ‬ ‫• ﻳﻚ ﻣﺴﺎﻟﻪ ﺑﺴﻴﺎر ﭼ‬
‫اﺳﺖ ﻛﻪ آن ﻧﻘﺺ را ﭘﻴﺪا ﻧﻜﻨﻨﺪ‪.‬‬

‫ﺑﺴﺘﮕﻲ دارد‪.‬‬
‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑ ﺘﮕ‬
‫ﭼﻴﺰ ﺑﻪ اﭘ اﺗﻮرﻫﺎي‬
‫ﻫﻤﻪ ﭼ ﺰ‬ ‫• اﻟ ﺘﻪ‬
‫اﻟﺒﺘﻪ ﻫ ﻪ‬

‫‪14‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﻃﺮاﺣﻲ اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ‬
‫• در ﺳﻄﺢ ﻣﺘﺪ‪ ،‬اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي زﺑﺎﻧﻬﺎي ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺒﻴﻪ ﻫﻤﻨﺪ‪.‬‬

‫• اﻳﻦ اﭘﺮاﺗﻮرﻫﺎ ﻳﻜﻲ از دو ﻛﺎر زﻳﺮ را اﻧﺠﺎم ﻣﻲ دﻫﻨﺪ‪:‬‬

‫• ﺗﻘﻠﻴﺪ اﺷﺘﺒﺎه ﻫﺎي راﻳﺞ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن )ﻣﺜﻼً ﺗﻐﻴﻴﺮ ﻧﺎم ﻣﺘﻐﻴﺮ(‬
‫ﻣﺘﻐﻴﺮي ‪ 0‬ﺷ د‬
‫ﺷﻮد(‬ ‫ﻣﻘﺪار ﺘﻐ ي‬
‫ﻛﻨﻴﻢ ﻘﺪا‬
‫ﻛﺎري ﻛﻨ‬
‫ﻣﺜﻼ ﻛﺎ ي‬
‫آزﻣﻮن ) ﺜﻼً‬
‫راﻳﺞ آز ن‬
‫اﺑﺘﻜﺎري اﻳ‬
‫روﺷﻬﺎي اﺑﺘﻜﺎ ي‬ ‫• ا ﺘﻔﺎده‬
‫اﺳﺘﻔﺎده از ﺷﻬﺎي‬

‫• ﻣﺤﻘﻘﺎن اﭘﺮاﺗﻮرﻫﺎي زﻳﺎدي را ﻃﺮاﺣﻲ ﻛﺮده اﻧﺪ و ﺳﭙﺲ ﺑﻪ ﻃﻮر ﺗﺠﺮﺑﻲ ﻣﻔﻴﺪﺗﺮﻳﻦ آﻧﻬﺎ را‬
‫اﻧﺘﺨﺎب ﻛﺮده اﻧﺪ‪.‬‬
‫اﭘﺮاﺗﻮر ﻣﺆﺛﺮ ﺟﻬﺶ‬
‫ﻣﺠﻤﻮﻋﻪ ااي از‬
‫ﻪ‬ ‫ﺟﻬﺸﮕﺮ ﻛﻪ ﺎﺑﺎ‬
‫ﻳﻚ ﺳﺮي ﺸﮕ‬ ‫ﻛﺸﺘﻦ ﻚ‬ ‫ﺑﺮاي ﻛﺸﺘ‬‫آزﻣﻮﻧﻬﺎﻳﻲ ﻛﻪ ا‬
‫اﮔﺮ آز ﻧ ﺎ‬
‫اﮔ‬
‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﻣﺜﻼً }… ‪ O = {o1, o2,‬اﻳﺠﺎد ﺷﺪه اﻧﺪ‪ ،‬ﺑﺘﻮاﻧﻨﺪ ﺟﻬﺸﮕﺮﻫﺎي‬
‫اﻳﺠﺎد ﺷﺪه ﺗﻮﺳﻂ ﻫﻤﻪ اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ دﻳﮕﺮ را ﻫﻢ ‪-‬ﺑﺎ اﺣﺘﻤﺎل ﺑﺎﻻ‪ -‬ﺑﻜﺸﻨﺪ‪،‬‬
‫آﻧﮕﺎه ‪ O‬ﻣﺠﻤﻮﻋﻪ اي ﻣﺆﺛﺮ از اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬
‫‪15‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي ﺟﺎوا‬
‫‪: (ABS –– Absolute‬‬
‫‪Ab l t Value‬‬
‫‪V l Insertion‬‬
‫‪I‬‬ ‫ﻣﻄﻠﻖ ) ‪ti‬‬
‫‪ .1‬درج ﻗﻗﺪر ﻄﻠ‬
‫ﻫﺮ ﻋﺒﺎرت )و زﻳﺮ ﻋﺒﺎرت( ﺣﺴﺎﺑﻲ را ﺑﺎ ﺗﻮاﺑﻊ )(‪ ،negAbs() ،abs‬و )(‪ failOnZero‬ﺗﻐﻴﻴﺮ دﻫﻴﺪ‪.‬‬

‫ﻣﺘﺪ )(‪ failOnZero‬اﭘﺮاﺗﻮر ﺟﻬﺶ ﻣﺨﺼﻮﺻﻲ اﺳﺖ ﻛﻪ اﮔﺮ ﭘﺎراﻣﺘﺮ آن ﺻﻔﺮ ﺑﺎﺷﺪ‪ ،‬ﻣﻮﺟﺐ ﺧﺮاﺑﻲ ﻣﻲ ﺷﻮد و در ﻏﻴﺮ اﻳﻦ‬
‫ﺻﻮرت ﻛﺎري اﻧﺠﺎم ﻧﻤﻲ دﻫﺪ‪ .‬اﻳﻦ ﻳﻌﻨﻲ آزﻣﻮﻧﮕﺮ ﺳﻌﻲ ﻛﻨﺪ ﻫﺮ ﻣﺘﻐﻴﺮ ﻳﺎ ﻋﺒﺎرت ﺣﺴﺎﺑﻲ را ﺑﺎ ﺻﻔﺮ ﻣﻘﺪار دﻫﻲ ﻛﻨﺪ‪.‬‬

‫ﺣﺴﺎﺑﻲ )‪: (AOR –– Arithmetic Operator Replacemen‬‬

‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑ‬
‫‪ .2‬ﺟﺎﻳﮕﺰﻳﻨ‬
‫ﻫﺮ ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑﻲ ‪ / ،* ،- ،+‬و ‪ %‬ﻫﺮ ﺑﺎر ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﻇﺎﻫﺮ ﺷﺪه اﺳﺖ ﺑﺎ ﻫﺮ ﻳﻚ از ﻋﻤﻠﮕﺮﻫﺎي ﺣﺴﺎﺑﻲ دﻳﮕﺮ و‬
‫ﺷﻮد‪.‬‬
‫ﻲ ﻮ‬‫ﺰﻳﻦ ﻣﻲ‬ ‫)(‪ rightOp‬ﺟ ﻳ‬
‫ﺟﺎﻳﮕﺰﻳﻦ‬ ‫)(‪ leftOp‬و )(‪g p‬‬
‫ي )(‪f p‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎي‬
‫ﺮ‬ ‫ﻋﻼوه‪ ،‬ﺑﺑﺎ‬
‫ﺑﺑﻪ و‬
‫ﻣﺘﺪ )(‪ leftOp‬ﻋﻤﻠﻮﻧﺪ ﺳﻤﺖ ﭼﭗ ﻳﻚ ﻋﺒﺎرت ﺣﺴﺎﺑﻲ و )(‪ rightOp‬ﻋﻤﻠﻮﻧﺪ ﺳﻤﺖ راﺳﺖ آن را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‪.‬‬

‫ﻄﻪ اي )‪: (ROR –– Relational Operator Replacement‬‬

‫راﺑﻄﻪ‬
‫ﻋﻤﻠﮕﺮ ا‬
‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋ ﻠﮕ‬
‫‪ .3‬ﺟﺎ ﮕﺰ ﻨ‬
‫ﻫﺮ ﻋﻤﻠﮕﺮ راﺑﻄﻪ اي )≠ ‪ (<, ≤, >, ≥, =,‬ﻫﺮ ﺑﺎر ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﻇﺎﻫﺮ ﺷﺪه اﺳﺖ ﺑﺎ ﻫﺮ ﻳﻚ از ﻋﻤﻠﮕﺮﻫﺎي‬
‫راﺑﻄﻪاي دﻳﮕﺮ و ﺑﻪ ﻋﻼوه‪ ،‬ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎي )(‪ falseOp‬و )(‪ trueOp‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪.‬‬

‫ﻣﺘﺪ )(‪ falseOp‬ﻣﻘﺪار ‪ false‬و )(‪ trueOp‬ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ‪.‬‬

‫‪16‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي ﺟﺎوا‪...‬‬
‫‪ .4‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮ ﺷﺮﻃﻲ )‪: (COR –– Conditional Operator Replacement‬‬
‫ﻫﺮ ﻋﻤﻠﮕﺮ ﻣﻨﻄﻘﻲ )‪ xor ،or ،and‬و ‪ ( ...‬ﻫﺮ ﺑﺎر ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﻇﺎﻫﺮ ﺷﺪه اﺳﺖ ﺑﺎ ﻫﺮ ﻳﻚ از ﻋﻤﻠﮕﺮﻫﺎي‬
‫ﻣﻨﻄﻘﻲ دﻳﮕﺮ و ﺑﻪ ﻋﻼوه‪ ،‬ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎي )(‪ leftOp() ،falseOp() ،trueOp‬و )(‪ rightOp‬ﺟﺎﻳﮕﺰﻳﻦ‬
‫ﻣﻲﺷﻮد‪.‬‬

‫•‬ ‫|‬ ‫‪= OR‬‬

‫‪A‬‬ ‫‪B A|B‬‬ ‫‪A&B A^B !A‬‬ ‫•‬ ‫&‬ ‫‪= AND‬‬
‫‪false false false‬‬ ‫‪false false true‬‬ ‫•‬ ‫^‬ ‫‪= XOR‬‬
‫‪true false true‬‬ ‫‪false true false‬‬ ‫•‬ ‫!‬ ‫‪= NOT‬‬
‫‪false true true‬‬ ‫‪false true true‬‬ ‫•‬ ‫||‬ ‫ﺑﺎ ﻣﺤﺎﺳﺒﻪ ﻣﻴﺎﻧﺒﺮ ‪= OR‬‬
‫‪true true true‬‬ ‫‪true false false‬‬ ‫•‬ ‫&&‬ ‫ﺑﺎ ﻣﺤﺎﺳﺒﻪ ﻣﻴﺎﻧﺒﺮ ‪=AND‬‬
‫•‬ ‫==‬ ‫ﺗﺴﺎوي =‬
‫•‬ ‫=!‬ ‫ﻧﺎﻣﺴﺎوي =‬

‫‪17‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي ﺟﺎوا‪...‬‬
‫‪ .5‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮ ﺷﻴﻔﺖ )‪: (SOR –– Shift Operator Replacement‬‬
‫ﻋﻤﻠﮕﺮﻫﺎي ﺷ ﻔﺖ‬
‫ﺷﻴﻔﺖ‬ ‫اﺳﺖ ﺑﺎ ﻫﻫﺮ ﻳﻚ از ﻋ ﻠﮕ ﻫﺎي‬
‫ﻇﺎﻫﺮ ﺷﺪه ا ﺖ‬ ‫ﺷﻴﻔﺖ )<<‪ ،>> ،‬و >>>( ﻫﻫﺮ ﺑﺎر ﻛﻪ در ﺑﺑﺮﻧﺎﻣﻪ‬
‫ﻧﺎﻣﻪ ﻇﺎﻫ‬ ‫ﻋﻤﻠﮕﺮ ﺷ ﻔﺖ‬
‫ﻫﻫﺮ ﻋ ﻠﮕ‬
‫دﻳﮕﺮ و ﺑﻪ ﻋﻼوه‪ ،‬ﺑﺎ ﻋﻤﻠﮕﺮ)(‪ leftOp‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲﺷﻮد‪.‬‬

‫‪20>>2 = 5‬‬ ‫ﻣﺜﺎل‪:‬‬

‫ﺷﻴﻔﺖ ﺑﻪ راﺳﺖ = >>‬
‫‪ 20‬در ﺳﻴﺴﺘﻢ دودوﻳﻲ =‬
‫ﺷﻴﻔﺖ ﺑﻪ ﭼﭗ = <<‬
‫‪00000000000000000000000000010100‬‬
‫ﺷﻴﻔﺖ ﺑﻪ راﺳﺖ ﺑﺪون ﻋﻼﻣﺖ = >>>‬ ‫ﻫﻤﻪ ﺑﻴﺘﻬﺎ را دو ﺗﺎ ﺑﻪ راﺳﺖ ﺷﻴﻔﺖ دﻫﻴﺪ‪:‬‬
‫‪00000000000000000000000000000101‬‬
‫ﻛﻪ ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪(2*2^2+0*2^1+1*2^0) 5‬‬

‫‪ .6‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮ ﻣﻨﻄﻘﻲ )‪: (LOR –– Logical Operator Replacement‬‬

‫ﻫﺮ ﻋﻤﻠﮕﺮ ﻣﻨﻄﻘﻲ )‪ and‬ﺑﻴﺘﻲ )&(‪ or ،‬ﺑﻴﺘﻲ )|(‪ ،‬و ‪ xor‬ﺑﻴﺘﻲ )^(( ﻫﺮ ﺑﺎر ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﻇﺎﻫﺮ ﺷﺪه اﺳﺖ ﺑﺎ ﻫﺮ‬
‫ﻋﻤﻠﮕﺮﻫﺎي )(‪ leftOp‬و )(‪ rightOp‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻣﻲﺷ د‬
‫ﺷﻮد‪.‬‬ ‫ﻋﻼوه‪ ،‬ﺑﺎ ﻋ ﻠﮕ ﻫﺎي‬
‫دﻳﮕﺮ و ﺑﻪ ﻋﻼوه‬
‫ﻣﻨﻄﻘﻲ دﻳﮕ‬
‫ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘ‬
‫ﻳﻚ از ﻋ ﻠﮕ ﻫﺎي‬

‫‪18‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي ﺟﺎوا‪...‬‬
‫‪ .7‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮ اﻧﺘﺴﺎب )‪: (ASR –– Assignment Operator Replacement‬‬
‫ﻫﺮ ﻋﻤﻠﮕﺮ اﻧﺘﺴﺎب )=>>> ‪ (=,+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=,‬ﻫﺮ ﺑﺎر ﻛﻪ در‬
‫ﺑﺮﻧﺎﻣﻪ ﻇﺎﻫﺮ ﺷﺪه اﺳﺖ ﺑﺎ ﻫﺮ ﻳﻚ از ﻋﻤﻠﮕﺮﻫﺎي اﻧﺘﺴﺎب دﻳﮕﺮ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲﺷﻮد‪.‬‬
‫ﻣﺜﻼً ‪ x+=y :‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪x=x+y‬‬ ‫‪ x oper= y‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪x = x oper y‬‬

‫ﻳﻜﺎﻧﻲ )‪: (UOI –– Unary Operator Insertion‬‬

‫ﻋﻤﻠﮕﺮ ﻜﺎﻧ‬
‫‪ .8‬درج ﻠﮕ‬
‫ﻫﺮ ﻋﻤﻠﮕﺮ ﻳﻜﺎﻧﻲ )ﺗﻚ ﻋﻤﻠﻮﻧﺪ( )‪ +‬ﺣﺴﺎﺑﻲ‪ - ،‬ﺣﺴﺎﺑﻲ‪ ! ،‬ﺷﺮﻃﻲ‪ ~ ،‬ﻣﻨﻄﻘﻲ( ﻗﺒﻞ از ﻫﺮ ﻋﺒﺎرت ﻣﻨﺎﺳﺐ )از ﻧﻮع‬
‫درﺳﺖ( درج ﻣﻣﻲ ﺷﻮد‪.‬‬
‫ﻋﻤﻠﮕﺮ ﻳﻜﺎﻧﻲ ~ ﻣﻜﻤﻞ ﺑﻴﺘﻲ ﻣﻲ ﮔﻴﺮد )ﺗﺒﺪﻳﻞ ﺻﻔﺮ ﺑﻪ ﻳﻚ و ﺑﺮﻋﻜﺲ( و ﻓﻘﻂ روي ﻣﻘﺎدﻳﺮ ﺻﺤﻴﺢ )‪ (int‬اﺳﺘﻔﺎده‬
‫ﻣﻲﺷﻮد‪ .‬ﻫﻤﻮاره اﻳﻦ راﺑﻄﻪ ﺑﺮﻗﺮار اﺳﺖ‪~x==(-x)-1 :‬‬

‫‪ .9‬ﺣﺬف ﻋﻤﻠﮕﺮ ﻳﻜﺎﻧﻲ )‪: (UOD –– Unary Operator Deletion‬‬

‫ﺬف ﻣﻲ ﺷﺷﻮد‪.‬‬ ‫ﺷﺮﻃﻲ‪ ~ ،‬ﻄﻘ‬
‫ﻣﻨﻄﻘﻲ( ﺣﺬف‬ ‫ﺣﺴﺎﺑﻲ‪ ! ،‬ﺷ ﻃ‬
‫ﺣﺴﺎﺑﻲ‪ - ،‬ﺎ‬
‫ﻋﻤﻠﻮﻧﺪ( ))‪ +‬ﺎ‬
‫ﻳﻜﺎﻧﻲ )ﺗﻚ ﻠ ﻧﺪ‬
‫ﻋﻤﻠﮕﺮ ﻜﺎﻧ‬
‫ﻫﺮ ﻠﮕ‬

‫‪19‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ ﺑﺮاي ﺟﺎوا‪...‬‬

‫‪ .10‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻣﺘﻐﻴﺮ ﻋﺪدي )‪: (SVR –– Scalar Variable Replacement‬‬

‫ﻫﺮ ارﺟﺎع ﺑﻪ ﻫﺮ ﻣﺘﻐﻴﺮ ﺑﺎ ﻫﻤﻪ ﻣﺘﻐﻴﺮﻫﺎي دﻳﮕﺮ‪ ،‬ﻛﻪ داراي ﻧﻮع ﻣﻨﺎﺳﺐ ﺑﻮده و در ﺣﻴﻄﻪ ﻓﻌﻠﻲ اﻋﻼن ﺷﺪه‬
‫ﺑﺎﺷﻨﺪ‪ ،‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪.‬‬

‫‪ .11‬ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﺒﺎرت ﺑﻤﺐ )‪: (BSR –– Bomb Statement Replacement‬‬

‫ﻫﺮ ﻋﺒﺎرت ﺑﺎ ﺗﺎﺑﻊ ﻣﺨﺼﻮص )(‪ Bomb‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲ ﺷﻮد‪.‬‬
‫ﺗﺎﺑﻊ )(‪ Bomb‬ﺑﻪ ﻣﺤﺾ اﺟﺮا‪ ،‬اﻳﺠﺎد ﺧﺮاﺑﻲ ﻣﻲ ﻛﻨﺪ؛ ﺑﻨﺎ ﺑﺮ اﻳﻦ ﻣﻲ ﺗﻮان از آن ﺑﺮاي ﭼﻚ ﻛﺮدن رﺳﻴﺪن ﺑﻪ ﻫﺮ ﻋﺒﺎرت‬
‫ﻴﻢ‪.‬‬ ‫;)(‪ Bomb‬ﺟﻬﺶ ﻣﻲ‬
‫ﻲ دﻫﻴﻢ‬ ‫ﻋﺒﺎرت ;)(‬
‫ﻞِ ;;‪ ، x=a*b‬آن ررا ﺑﺑﻪ ﺒ ر‬
‫ﻲ ﻣﺜﻞ‬
‫ﻋﺒﺎرﺗﻲ‬
‫ي ﺒر‬ ‫ﺑﺮاي‬
‫ﻛﺮد‪ .‬ﻣﺜﻼً ﺑﺮ‬
‫اﺳﺘﻔﺎده ﺮ‬

‫‪20‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﺧﻼﺻﻪ اﭘﺮاﺗﻮرﻫﺎي ﺟﻬﺶ‬
‫ﻋﻤﻠﻜﺮد‬ ‫ﻛﺪ‬ ‫ﺷﻤﺎره‬ ‫ﻋﻤﻠﻜﺮد‬ ‫ﻛﺪ‬ ‫ﺷﻤﺎره‬

‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮﻫﺎي اﻧﺘﺴﺎب ‪+=, -=,‬‬ ‫‪ASR‬‬ ‫‪7‬‬ ‫و‬ ‫ﻋﻤﻠﮕﺮ )(‪negAbs() ،Abs‬‬ ‫درج‬ ‫‪ABS‬‬ ‫‪1‬‬
‫‪* /=,‬‬
‫‪*=,‬‬ ‫‪/ %‬‬ ‫‪%=, &=,‬‬
‫‪& |=,‬‬ ‫‪| ^=,‬‬
‫‪^ <<=,‬‬
‫<<‬ ‫)‪(Assignment‬‬ ‫ﺣﺴﺎﺑﻲ‬
‫ﻋﺒﺎرت ﺎ‬ ‫)(‪ failOnZero‬اي‬
‫ﺑﺮاي ﻫﻫﺮ ﻋ ﺎ ت‬ ‫)‪(Absolute‬‬
‫=>>> ‪ >>=,‬ﺑﺎ ﻫﻢ‬ ‫اﻧﺘﺴﺎب‬ ‫ﻗﺪر ﻣﻄﻠﻖ‬
‫درج ﻋﻤﻠﮕﺮﻫﺎي ﻳﻜﺎﻧﻲ )‪ +‬ﺣﺴﺎﺑﻲ‪- ،‬‬ ‫‪UOI‬‬ ‫‪8‬‬ ‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮﻫﺎي ﺣﺴﺎﺑﻲ ‪ / ،* ،- ،+‬و ‪%‬‬ ‫‪AOR‬‬ ‫‪2‬‬
‫ﺣﺴﺎﺑﻲ‪ ! ،‬ﺷﺮﻃﻲ‪ ~ ،‬ﻣﻨﻄﻘﻲ( ﻗﺒﻞ از ﻫﺮ‬ ‫)‪(Unary Insert‬‬ ‫ﺑﺎ ﻫﻢ و ﺑﺎ )(‪ leftOp‬و )(‪rightOp‬‬ ‫)‪( Arithmetic‬‬
‫ﻋﺒﺎرت ﻣﻨﺎﺳﺐ‬ ‫درج ﻳﻜﺎﻧﻲ‬ ‫ﺣﺴﺎﺑﻲ‬
‫ﺣﺬف ﻫﺮ ﻋﻤﻠﮕﺮ ﻳﻜﺎﻧﻲ )‪ +‬ﺣﺴﺎﺑﻲ‪- ،‬‬ ‫‪UOD‬‬ ‫‪9‬‬ ‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮﻫﺎي راﺑﻄﻪ اي ≠ ‪<, ≤, >, ≥, =,‬‬ ‫‪ROR‬‬ ‫‪3‬‬
‫ﺣﺴﺎﺑﻲ‪ ! ،‬ﺷﺮﻃﻲ‪ ~ ،‬ﻣﻨﻄﻘﻲ(‬ ‫)‪(Unary Delete‬‬ ‫ﺑﺎ ﻫﻢ و ﺑﺎ )(‪ trueOp‬و )(‪falseOp‬‬ ‫)‪(Relational‬‬
‫ﺣﺬف ﻳﻜﺎﻧﻲ‬ ‫راﺑﻄﻪ اي‬
‫ﻣﺘﻐﻴﺮﻫﺎي‬
‫ﻫﻤﻪ ﺘﻐ ﺎ‬‫ﻣﺘﻐﻴﺮ ﺎﺑﺎ ﻪ‬
‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻫﺮ ﺘﻐ‬
‫ﺎﮕ ﻨ‬ ‫‪SVR‬‬ ‫‪1‬‬
‫‪10‬‬ ‫ﺷﺮﻃﻲ ‪ xor ،or ،and‬و ‪...‬‬
‫ﻋﻤﻠﮕﺮﻫﺎي ﺷ ﻃ‬
‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻠﮕ ﺎ‬
‫ﺎﮕ‬ ‫‪COR‬‬ ‫‪4‬‬
‫ﻣﻨﺎﺳﺐ دﻳﮕﺮ‬ ‫)‪(Variable‬‬ ‫ﺑﺎ ﻫﻢ و ﺑﺎ )(‪ leftOp‬و )(‪ rightOp‬و )(‪trueOp‬‬ ‫)‪(Conditional‬‬
‫ﻣﺘﻐﻴﺮ‬ ‫و )(‪falseOp‬‬ ‫ﺷﺮﻃﻲ‬
‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻫﺮ ﻋﺒﺎرت ﺑﺎ دﺳﺘﻮر )(‪Bomb‬‬ ‫‪BSR‬‬ ‫‪11‬‬ ‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮﻫﺎي ﺷﻴﻔﺖ <<‪ ،>> ،‬و >>>‬ ‫‪SOR‬‬ ‫‪5‬‬
‫)‪(Bomb‬‬ ‫ﺑﺎ ﻫﻫﻢ و ﺑﺎ )(‪leftOp‬‬ ‫)‪(Shift‬‬
‫ﺑﻤﺐ‬ ‫ﺷﻴﻔﺖ‬
‫ﺟﺎﻳﮕﺰﻳﻨﻲ ﻋﻤﻠﮕﺮﻫﺎي ﻣﻨﻄﻘﻲ ‪ and‬ﺑﻴﺘﻲ )&(‪or ،‬‬ ‫‪LOR‬‬ ‫‪6‬‬
‫ﺑﻴﺘﻲ )|(‪ ،‬و ‪ xor‬ﺑﻴﺘﻲ )^(‬ ‫)‪(Logical‬‬
‫ﺑﺎ ﻫﻢ و ﺑﺎ )(‪ leftOp‬و )(‪rightOp‬‬ ‫ﻣﻨﻄﻘﻲ‬

‫‪21‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫راﺑﻄﻪ در ﺑﺮ داﺷﺘﻦ ﺑﺎ ﺳﺎﻳﺮ ﻣﻌﻴﺎرﻫﺎ‬
‫• ﺟﻬﺶ ﻗﻮﻳﺘﺮﻳﻦ و ﮔﺮاﻧﺘﺮﻳﻦ ﻣﻌﻴﺎر آزﻣﺎﻳﺶ ﻣﺤﺴﻮب ﻣﻲ ﺷﻮد‪.‬‬

‫• ﺳﺎﻳﺮ ﻣﻌﻴﺎرﻫﺎ را در ﺑﺮ دارد )اﻟﺒﺘﻪ ﺑﺎ ﺟﻬﺶ ﺿﻌﻴﻒ(‬

‫– ﭘﻮﺷﺶ ﮔﺮه‬
‫– ﭘﻮﺷﺶ ﻳﺎل‬
‫– ﭘﻮﺷﺶ ﻛﻼز‬
‫– ﭘﻮﺷﺶ ‪GACC‬‬
‫– ﭘﻮﺷﺶ ‪CACC‬‬
‫– ﭘﻮﺷﺶ ﻫﻤﻪ ﺗﻌﺎرﻳﻒ )‪ (all-defs‬در ﺟﺮﻳﺎن داده‬

‫‪22‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬
 ‫ﭘﭘﺎﻳﺎن ﺟﻠﺴﻪ ﻧﻬﻢ‬

‫‪23‬‬ ‫ﺻﺪﻳﻘﻪ ﺧﻮﺷﻨﻮﻳﺲ‪ -‬داﻧﺸﮕﺎه آزاد اﺳﻼﻣﻲ واﺣﺪ ﺷﻬﺮﻗﺪس‬ ‫آزﻣﻮن ﻧﺮم اﻓﺰار )ﻓﺼﻞ ‪(5‬‬