ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಜನರೇಷನ್: ಘಟಕ, ಇಂಟರ್ಫೇಸ್ ಮತ್ತು ಆಟೋಮೇಷನ್ ಪರೀಕ್ಷೆಗಳು

ಲಾಭಗಳು:

• ಪರೀಕ್ಷಾ ಪಿರಮಿಡ್ ಮತ್ತು ಕವರ್ ಮಿತಿ ಮತ್ತು ದೋಷ ಸಂದರ್ಭಗಳು ಮತ್ತು ಸಂತೋಷದ ಸನ್ನಿವೇಶಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯೊಂದಿಗೆ ಘಟಕ, ಏಕೀಕರಣ ಮತ್ತು UI ಪರೀಕ್ಷೆಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಸಾಮರ್ಥ್ಯ
• ಖಾಲಿ/ಅನುಪಯುಕ್ತ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಉಬ್ಬುವ ಕವರೇಜ್ ಅನ್ನು ಹೊರಹಾಕುವ ಸಾಮರ್ಥ್ಯವು ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ವಾಸ್ತವವಾಗಿ ನಡವಳಿಕೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ
• ಪರೀಕ್ಷೆಯು ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕೋಡ್ ಏನು ಮಾಡಬೇಕೆಂದು AI ಗೆ ಹೇಳುವ ಮೂಲಕ ದೋಷವನ್ನು ಸರಿಪಡಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ

ಕೋಡ್ ಬರೆಯುವುದು ಅರ್ಧದಷ್ಟು ಕೆಲಸ; ಕೋಡ್ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಸಾಬೀತುಪಡಿಸುವುದು ಉಳಿದ ಅರ್ಧವಾಗಿದೆ. ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ನೂರಾರು ವಿಭಿನ್ನ ಸಾಧನಗಳು, ಪರದೆಯ ಗಾತ್ರಗಳು, ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಆವೃತ್ತಿಗಳು ಮತ್ತು ಬಳಕೆದಾರರ ನಡವಳಿಕೆಗಳನ್ನು ಎದುರಿಸುತ್ತವೆ. ಇವೆಲ್ಲವನ್ನೂ ಕೈಯಾರೆ ಪರೀಕ್ಷಿಸುವುದು ಅಸಾಧ್ಯ; ಅದಕ್ಕಾಗಿಯೇ ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆ (ಕೋಡ್ ಟೆಸ್ಟಿಂಗ್ ಕೋಡ್ - ಮಾನವ ಕ್ಲಿಕ್ ಇಲ್ಲದೆ ನಡೆಯುವ ಪರೀಕ್ಷೆ) ಮೊಬೈಲ್ ಗುಣಮಟ್ಟದ ಬೆನ್ನೆಲುಬಾಗಿದೆ. ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವಲ್ಲಿ AI ನಂಬಲಾಗದಷ್ಟು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಏಕೆಂದರೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು ನಿಖರವಾಗಿ ಅದು ಇಷ್ಟಪಡುವ ಮಾದರಿಯ ಕೆಲಸವಾಗಿದೆ: ನಿರ್ದಿಷ್ಟ ಒಳಹರಿವುಗಳಿಗಾಗಿ ನಿರ್ದಿಷ್ಟ ನಡವಳಿಕೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು. ಈ ಘಟಕದಲ್ಲಿ, AI ನೊಂದಿಗೆ ಘಟಕ ಪರೀಕ್ಷೆ, ಇಂಟರ್ಫೇಸ್ ಪರೀಕ್ಷೆ ಮತ್ತು ಯಾಂತ್ರೀಕೃತಗೊಂಡ ವೇಗವನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಾವು ಕಲಿಯುತ್ತೇವೆ, ಆದರೆ ಮಾನವ ಕಣ್ಣುಗಳ ಮೂಲಕ ಪರೀಕ್ಷೆಯ ಗುಣಮಟ್ಟವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೇವೆ.

ಪಿರಮಿಡ್ ಪರೀಕ್ಷೆ: ಏನು ಪರೀಕ್ಷಿಸಬೇಕು ಮತ್ತು ಎಷ್ಟು

ಆರೋಗ್ಯಕರ ಪರೀಕ್ಷಾ ತಂತ್ರವು ಪಿರಮಿಡ್ ಅನ್ನು ಹೋಲುತ್ತದೆ. ಆಧಾರವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ (ಒಂದೇ ಕಾರ್ಯ ಅಥವಾ ವರ್ಗವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸುವ ತ್ವರಿತ ಪರೀಕ್ಷೆ); ಅವು ವೇಗವಾಗಿ ಮತ್ತು ಅಗ್ಗವಾಗಿವೆ. ಮಧ್ಯದಲ್ಲಿ ಕಡಿಮೆ ಏಕೀಕರಣ ಪರೀಕ್ಷೆ (ಬಹು ಭಾಗಗಳು ಹೇಗೆ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸುವುದು). ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕನಿಷ್ಠ UI/ಎಂಡ್-ಟು-ಎಂಡ್ ಪರೀಕ್ಷೆ ಇರುತ್ತದೆ (ಬಳಕೆದಾರರು ಮಾಡಿದಂತೆ ಪರದೆಯ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವ ಮೂಲಕ ಪರೀಕ್ಷೆಯನ್ನು ಮಾಡಲಾಗುತ್ತದೆ); ಅವು ವಾಸ್ತವಿಕ ಆದರೆ ನಿಧಾನ ಮತ್ತು ದುರ್ಬಲವಾಗಿರುತ್ತವೆ. AI ಪ್ರತಿ ಪದರದಲ್ಲಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ಹೆಚ್ಚಿನ ಮೌಲ್ಯವು ತಳದಲ್ಲಿದೆ: ವ್ಯವಹಾರ ತರ್ಕದ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಪರೀಕ್ಷಾ ಪ್ರಕಾರ

ವ್ಯಾಪ್ತಿ

ವೇಗ

AI ದಕ್ಷತೆ

ಘಟಕ ಪರೀಕ್ಷೆ

ಏಕ ಕಾರ್ಯ/ವರ್ಗ

ಅತ್ಯಂತ ವೇಗವಾಗಿ

ತುಂಬಾ ಹೆಚ್ಚು

ಏಕೀಕರಣ

ಇಂಟರ್ಲೇಯರ್

ಮಧ್ಯಮ

ಹೆಚ್ಚು

UI / ಅಂತ್ಯದಿಂದ ಅಂತ್ಯ

ಎಲ್ಲಾ ಪರದೆಯ ಸ್ಟ್ರೀಮ್

ನಿಧಾನ

ಮಧ್ಯಮ (ದುರ್ಬಲವಾದ)

ಸಲಹೆ: "ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಲು" AI ಗೆ ಹೇಳುವಾಗ, ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕೇಳಿ: ಖಾಲಿ ಇನ್‌ಪುಟ್, ಶೂನ್ಯ, ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ, ಅತಿ ದೊಡ್ಡ ಮೌಲ್ಯ, ನೆಟ್‌ವರ್ಕ್ ದೋಷ. AI ಸುಲಭವಾಗಿ ಸಂತೋಷದ ಮಾರ್ಗವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ; ನಿಜವಾದ ತಪ್ಪುಗಳು ಗಡಿಗಳಲ್ಲಿ ಅಡಗಿಕೊಳ್ಳುತ್ತವೆ ಮತ್ತು ನೀವು ಬಯಸದಿದ್ದರೆ ಹೊರಗೆ ಹಾರಿಹೋಗುತ್ತವೆ.

AI ಯೊಂದಿಗೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವ ಹಂತಗಳು

1. ಪರೀಕ್ಷಿಸಬೇಕಾದ ನಡವಳಿಕೆಯನ್ನು ವಿವರಿಸಿ. "ಈ ಕಾರ್ಯವು ಈ ಇನ್‌ಪುಟ್‌ಗೆ ಈ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀಡಬೇಕು."
2. ಚೌಕಟ್ಟನ್ನು ಸೂಚಿಸಿ. Android ನಲ್ಲಿ JUnit + MockK, iOS ನಲ್ಲಿ XCTest, UI ಗಾಗಿ Espresso (Android) ಅಥವಾ XCUITest (iOS).
3. ಮಿತಿಯ ರಾಜ್ಯಗಳನ್ನು ಕೇಳಿ. ಸಂತೋಷದ ಸನ್ನಿವೇಶ + ದೋಷ + ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು.
4. ಅಣಕು ವಸ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸಿ. ನೆಟ್‌ವರ್ಕ್ ಮತ್ತು ಡೇಟಾಬೇಸ್‌ನಂತಹ ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಪರೀಕ್ಷೆಗಾಗಿ ಅನುಕರಿಸಲಾಗುತ್ತದೆ (ಅಣಕು - ನಿಜವಾದ ಸೇವೆಯ ಬದಲಿಗೆ ನಿಯಂತ್ರಿತ ಅಣಕು).
5. ಪರೀಕ್ಷೆಯನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ಪರಿಶೀಲಿಸಿ. ಪರೀಕ್ಷೆಯು ಉತ್ತೀರ್ಣವಾಗಿದೆಯೇ, ಅದು ನಿಜವಾಗಿಯೂ ಅರ್ಥಪೂರ್ಣವಾದುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆಯೇ?

ಐದನೇ ಹಂತವು ನಿರ್ಣಾಯಕವಾಗಿದೆ. AI ಕೆಲವೊಮ್ಮೆ "ಯಾವಾಗಲೂ ಹಾದುಹೋಗುವ" ಅನುಪಯುಕ್ತ ಪರೀಕ್ಷೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ; ಉದಾಹರಣೆಗೆ, ಯಾವುದನ್ನೂ ಪರಿಶೀಲಿಸದ ಅಥವಾ ತನ್ನದೇ ಆದ ನಕಲಿ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸುವ ಪರೀಕ್ಷೆ. ಉತ್ತೀರ್ಣ ಪರೀಕ್ಷೆ ಮತ್ತು ಅಮೂಲ್ಯವಾದ ಪರೀಕ್ಷೆಯು ವಿಭಿನ್ನ ವಿಷಯಗಳಾಗಿವೆ.

ಎಚ್ಚರಿಕೆ: AI ಉತ್ಪಾದಿಸಬಹುದಾದ ಕಾರಣ ಪರೀಕ್ಷೆಯು ಸರಿಯಾಗಿದೆ ಎಂದು ಅರ್ಥವಲ್ಲ. ಕೆಲವೊಮ್ಮೆ AI ಕೋಡ್‌ನ ಪ್ರಸ್ತುತ (ಬಹುಶಃ ದೋಷಪೂರಿತ) ನಡವಳಿಕೆಯನ್ನು "ಸರಿ" ಎಂದು ಒಪ್ಪಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುತ್ತದೆ. ಅಂತಹ ಪರೀಕ್ಷೆಯು ದೋಷವನ್ನು ಹಿಡಿಯುವ ಬದಲು ಅದನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ. ಪರೀಕ್ಷೆಯು ಏನನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸುತ್ತೀರಿ; AI ಏನು ಮಾಡಬೇಕೆಂದು ಹೇಳಿ, ಕೋಡ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅಲ್ಲ.

ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯ ಅಳತೆ ಮತ್ತು ತಪ್ಪು

ಪರೀಕ್ಷಾ ಕವರೇಜ್ (ಪರೀಕ್ಷೆಗಳಿಂದ ಎಷ್ಟು ಶೇಕಡಾ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತದೆ) ಉಪಯುಕ್ತ ಆದರೆ ತಪ್ಪುದಾರಿಗೆಳೆಯುವ ಮೆಟ್ರಿಕ್ ಆಗಿದೆ. 90% ಕವರೇಜ್ 90% ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ; ಆದರೆ ಆ ಸಾಲುಗಳು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗಿಲ್ಲ. ಒಂದು ರೇಖೆಯನ್ನು ನಡೆಸುವ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಪರಿಶೀಲಿಸದ ಪರೀಕ್ಷೆಯು ವ್ಯಾಪ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಆದರೆ ಭದ್ರತೆಯನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ. ಗುರಿಯು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಗಳಲ್ಲ, ಆದರೆ ಅರ್ಥಪೂರ್ಣ ಮೌಲ್ಯೀಕರಣವಾಗಿದೆ. ನೀವು AI ಯೊಂದಿಗೆ ತ್ವರಿತವಾಗಿ ಅಳೆಯಬಹುದು, ಆದರೆ ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಮೂರು ಸಣ್ಣ ಪ್ರಕರಣಗಳು

ಪ್ರಕರಣ 1 - ಗಡಿ ಪರಿಸ್ಥಿತಿಯನ್ನು ಹಿಡಿಯಲಾಗಿದೆ. ಬ್ಯಾಂಕಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಹಣ ವರ್ಗಾವಣೆ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಗಳಿಗಾಗಿ AI ಅನ್ನು ಕೇಳಲಾಯಿತು ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ "ಋಣಾತ್ಮಕ ಮೊತ್ತ" ಮತ್ತು "ಸಮತೋಲನಕ್ಕಿಂತ ಹೆಚ್ಚು" ಸನ್ನಿವೇಶಗಳನ್ನು ಸೇರಿಸಲಾಯಿತು. ಋಣಾತ್ಮಕ ಮೊತ್ತದೊಂದಿಗೆ ವರ್ಗಾವಣೆಯನ್ನು ನಿರ್ಬಂಧಿಸಲಾಗಿಲ್ಲ ಎಂದು ಪರೀಕ್ಷೆಯು ಬಹಿರಂಗಪಡಿಸಿತು; ಇದು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಪ್ರಮುಖ ಭದ್ರತಾ ದುರ್ಬಲತೆಯಾಗಿದೆ. ಒಂದು ಸಾಲಿನ ನಿಯಂತ್ರಣವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಮುಚ್ಚಲಾಗಿದೆ. ಪಾಠ: ಗಡಿ ಪರೀಕ್ಷೆಗಳು ಅತ್ಯಮೂಲ್ಯ ಪರೀಕ್ಷೆಗಳಾಗಿವೆ.

ಪ್ರಕರಣ 2 - ನಕಲಿ ಪರೀಕ್ಷೆ. AI ನಿಂದ ತಯಾರಿಸಲಾದ 40 ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳೊಂದಿಗೆ ಕವರೇಜ್ ಅನ್ನು 85% ಗೆ ಹೆಚ್ಚಿಸಲು ಒಂದು ತಂಡವು ನಿರಾಳವಾಯಿತು. ತಪಾಸಣೆಯ ಸಮಯದಲ್ಲಿ, ಹೆಚ್ಚಿನ ಪರೀಕ್ಷೆಗಳು ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಿಲ್ಲ ಎಂದು ಕಂಡುಬಂದಿದೆ, ಅವರು ಕಾರ್ಯವನ್ನು ಕರೆದರು ಮತ್ತು assertTrue(true) ಎಂದು ಬರೆದರು. ವ್ಯಾಪ್ತಿ ಹೆಚ್ಚಿದ್ದರೂ ರಕ್ಷಣೆ ಶೂನ್ಯವಾಗಿತ್ತು. ಪರೀಕ್ಷೆಗಳನ್ನು ಕೂಲಂಕುಷವಾಗಿ ಪರಿಶೀಲಿಸಲಾಗಿದೆ ಮತ್ತು ನೈಜ ಮೌಲ್ಯೀಕರಣಗಳೊಂದಿಗೆ ಪುನಃ ಬರೆಯಲಾಗಿದೆ. ಪಾಠ: ಕವರೇಜ್ ಸಂಖ್ಯೆಗಳು ಸುಳ್ಳು ಮಾಡಬಹುದು.

ಪ್ರಕರಣ 3 - UI ಪರೀಕ್ಷೆಯನ್ನು ವೇಗಗೊಳಿಸಲಾಗಿದೆ. ಇ-ಕಾಮರ್ಸ್ ತಂಡವು 20 ನಿಮಿಷಗಳಲ್ಲಿ AI ಜೊತೆಗೆ ಆಡ್-ಟು-ಕಾರ್ಟ್ ಹರಿವಿನ XCUITest ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆದಿದೆ; ಕೈಯಿಂದ ಬರೆದರೆ ಅರ್ಧ ದಿನ ಬೇಕು. AI ಊಹಿಸಿದ ಪರದೆಯ ಅಂಶ ಗುರುತಿಸುವಿಕೆಗಳು; ತಂಡವು ಅವುಗಳನ್ನು ನೈಜ ಕೋಡ್‌ನೊಂದಿಗೆ ಹೊಂದಿಸಿ ಮತ್ತು ಅವುಗಳನ್ನು ಸರಿಪಡಿಸಿತು. ಡ್ರಾಫ್ಟ್ ವೇಗವು ನೈಜವಾಗಿದೆ, ಆದರೆ ಗುರುತಿಸುವಿಕೆಯ ಪರಿಶೀಲನೆಯು ಮಾನವ ಕೆಲಸವಾಗಿದೆ.

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್: "ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಿರಿ."

ಶಕ್ತಿಯುತ ಪ್ರಾಂಪ್ಟ್: "JUnit5 + MockK ನೊಂದಿಗೆ ಈ Kotlin ಕಾರ್ಯಕ್ಕಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ತಯಾರಿಸಿ. ಕಾರ್ಯ: ಹಣ ವರ್ಗಾವಣೆ (ಮೊತ್ತ, ಮೂಲ, ಗುರಿ). ಪರೀಕ್ಷಿಸಲು ನಡವಳಿಕೆಗಳು (ಕೋಡ್ ಏನು ಮಾಡಬೇಕು):- ಮಾನ್ಯ ವರ್ಗಾವಣೆ ಯಶಸ್ವಿಯಾಗಬೇಕು- ಋಣಾತ್ಮಕ ಅಥವಾ ಶೂನ್ಯ ಮೊತ್ತವನ್ನು ತಿರಸ್ಕರಿಸಬೇಕು- ಸಮತೋಲನಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೊತ್ತವನ್ನು ತಿರಸ್ಕರಿಸಬೇಕು- ಪ್ರತಿಯೊಂದೂ ಪರೀಕ್ಷೆಯ ದೋಷವನ್ನು ತಿರಸ್ಕರಿಸಬೇಕು. ವಿವರಣಾತ್ಮಕ, ಬಾಹ್ಯ ಸೇವೆಯನ್ನು ಅಪಹಾಸ್ಯ ಮಾಡಿ, ಖಾಲಿ ಸಮರ್ಥನೆಯನ್ನು ಬರೆಯಬೇಡಿ.

ನಕಲು ಮಾಡಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್‌ಗಳು

ಘಟಕ ಪರೀಕ್ಷಾ ಟೆಂಪ್ಲೇಟ್: "[ಭಾಷೆ] ಈ ಕಾರ್ಯಕ್ಕಾಗಿ [JUnit/XCTest] ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಿ. ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ: [ಏನು ಮಾಡಬೇಕು]. ಸೇರಿಸಿ: ಸಂತೋಷದ ಸನ್ನಿವೇಶ, ಶೂನ್ಯ ಇನ್‌ಪುಟ್, ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು, ದೋಷ ಪ್ರಕರಣ. ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ಏಕ ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲಿ; ಅರ್ಥಪೂರ್ಣ ಸಮರ್ಥನೆಯನ್ನು ಬಳಸಿ; ಅಣಕು. [ಕೋಡ್]"

UI ಪರೀಕ್ಷಾ ಟೆಂಪ್ಲೇಟ್: "[Espresso/XCUITest] ಜೊತೆಗೆ ಕೆಳಗಿನ ಫ್ಲೋನ UI ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಿರಿ: [ಬಳಕೆದಾರರ ಹರಿವು ಹಂತ ಹಂತವಾಗಿ]. ಪ್ರವೇಶಿಸುವಿಕೆ ಐಡಿಯೊಂದಿಗೆ ಪರದೆಯ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ, ಪಠ್ಯದ ಬದಲಿಗೆ ಐಡಿಯನ್ನು ಬಳಸಿ. ಕಾಯುವ ತಂತ್ರವನ್ನು ಸೇರಿಸಿ. ಎಲಿಮೆಂಟ್ ಐಡಿಗಳನ್ನು ನಿಜವಾದ ಕೋಡ್‌ಗೆ ಹೊಂದಿಸಲು ನನಗೆ ನೆನಪಿಸಿ."

ಪರೀಕ್ಷಾ ಆಡಿಟ್ ಟೆಂಪ್ಲೇಟ್:"ಈ ಪರೀಕ್ಷೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ:1) ಅವರು ವಾಸ್ತವವಾಗಿ ಔಟ್‌ಪುಟ್/ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತಾರೆಯೇ ಅಥವಾ ಅವು ಶೂನ್ಯವೇ?2) ಅವರು ಮಿತಿ ಪ್ರಕರಣಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತಾರೆಯೇ?3) ಅವರು ಕೋಡ್ ಅನ್ನು ಸರಿಪಡಿಸುತ್ತಾರೆಯೇ ಅಥವಾ ಸರಿಯಾದ ನಡವಳಿಕೆಯನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಾರೆಯೇ? ದುರ್ಬಲ ಪರೀಕ್ಷೆಗಳನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡಿ ಮತ್ತು ಬಲಪಡಿಸುತ್ತಾರೆ. [ಪರೀಕ್ಷೆಗಳು]"

ಕವರೇಜ್ ಆಪ್ಟಿಮೈಸೇಶನ್ ಟೆಂಪ್ಲೇಟ್: "ಈ ವರ್ಗದ ಪರೀಕ್ಷಿಸದ ಭಾಗಗಳನ್ನು ಗುರುತಿಸಿ ಮತ್ತು ಅರ್ಥಪೂರ್ಣ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೂಚಿಸಿ. ಕವರೇಜ್‌ಗಳ ಸಂಖ್ಯೆ ಮಾತ್ರವಲ್ಲದೆ ನಿಜವಾದ ಅಪಾಯವಿರುವ ಮಾರ್ಗಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ. [ಕೋಡ್]"

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಸಂತೋಷದ ಸನ್ನಿವೇಶವನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ. ದೋಷಗಳನ್ನು ಮಿತಿ ಸ್ಥಿತಿಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ; ಅವರನ್ನು ಮುಕ್ತವಾಗಿ ಕೇಳಿ.
• ಖಾಲಿ/ಅನುಪಯುಕ್ತ ಪರೀಕ್ಷೆಯನ್ನು ಸ್ವೀಕರಿಸುವುದು. ಅಸೆರ್ಟ್ಟ್ರೂ(ನಿಜ) ಪ್ರಕಾರದ ಪರೀಕ್ಷೆಗಳು ವ್ಯಾಪ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ ಮತ್ತು ಯಾವುದೇ ರಕ್ಷಣೆಯನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ.
• ಕೋಡ್ ಏನು ಮಾಡುತ್ತಿದೆ ಎಂಬುದನ್ನು AI ಪರಿಶೀಲಿಸುತ್ತದೆ. ಕೋಡ್ ಏನು ಮಾಡಬೇಕೆಂದು ಪರೀಕ್ಷೆಯು ನಿರೀಕ್ಷಿಸಬೇಕು; ಇಲ್ಲದಿದ್ದರೆ ಅದು ದೋಷವನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ.
• ಉದ್ದೇಶಕ್ಕಾಗಿ ಸ್ಕೋಪ್ ಸಂಖ್ಯೆಯನ್ನು ತಪ್ಪಾಗಿ ಗ್ರಹಿಸುವುದು. 90% ಕವರೇಜ್ ಎಂದರೆ 90% ನಿಖರತೆ ಎಂದಲ್ಲ.
• UI ಪರೀಕ್ಷೆಯಲ್ಲಿ ಪಠ್ಯಕ್ಕೆ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತಿದೆ. ಪಠ್ಯ ಬದಲಾದಾಗ ಪರೀಕ್ಷೆಯು ಮುರಿದುಹೋಗುತ್ತದೆ; ಸ್ಥಿರ ಗುರುತಿಸುವಿಕೆ (ಐಡಿ) ಬಳಸಿ.
• ಅಣಕುಗಳನ್ನು ತಪ್ಪಾಗಿ ಹೊಂದಿಸುವುದು. ನಿಜವಾದ ಸೇವೆಯನ್ನು ಕರೆಯುವ "ಘಟಕ ಪರೀಕ್ಷೆ" ನಿಧಾನವಾಗಿ ಮತ್ತು ದುರ್ಬಲವಾಗಿರುತ್ತದೆ.

ಸಾರಾಂಶದಲ್ಲಿ

ಪರೀಕ್ಷೆಯು ಮೊಬೈಲ್ ಗುಣಮಟ್ಟದ ಬೆನ್ನೆಲುಬಾಗಿದೆ, ಮತ್ತು ಈ ಪ್ರದೇಶದಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆಯಲ್ಲಿ AI ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. ಪರೀಕ್ಷಾ ಪಿರಮಿಡ್ ಅನ್ನು ಅನುಸರಿಸಿ: ಅನೇಕ ಘಟಕಗಳು, ಮಧ್ಯಮ ಏಕೀಕರಣ, ಕಡಿಮೆ UI ಪರೀಕ್ಷೆ. ಸಂತೋಷದ ಸನ್ನಿವೇಶ ಮತ್ತು ಮಿತಿ ಪ್ರಕರಣಗಳು ಮತ್ತು ದೋಷ ಮಾರ್ಗಗಳಿಗಾಗಿ AI ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕೇಳಿ. ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ವಾಸ್ತವವಾಗಿ ಒಂದು ನಡವಳಿಕೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ; ಖಾಲಿ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಉಬ್ಬಿಕೊಂಡಿರುವ ಕವರೇಜ್ ತಪ್ಪುದಾರಿಗೆಳೆಯುವಂತಿವೆ. ಬಹು ಮುಖ್ಯವಾಗಿ, ಕೋಡ್ ಏನು ಮಾಡಬೇಕೆಂದು AI ಗೆ ತಿಳಿಸಿ, ಅದು ಏನು ಮಾಡುತ್ತಿಲ್ಲ, ಆದ್ದರಿಂದ ಪರೀಕ್ಷೆಯು ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತದೆ, ಅದನ್ನು ಸರಿಪಡಿಸುವುದಿಲ್ಲ.

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ವ್ಯವಹಾರ ತರ್ಕ ಕಾರ್ಯಕ್ಕಾಗಿ "ಯುನಿಟ್ ಟೆಸ್ಟ್ ಟೆಂಪ್ಲೇಟ್" ಅನ್ನು ಬಳಸಿಕೊಂಡು AI ನಿಂದ ಪರೀಕ್ಷೆಗಳನ್ನು ವಿನಂತಿಸಿ (ಉದಾ. ರಿಯಾಯಿತಿ ಲೆಕ್ಕಾಚಾರ ಅಥವಾ ಫಾರ್ಮ್ ಮೌಲ್ಯೀಕರಣ) ಮತ್ತು ಮಿತಿ ಪ್ರಕರಣಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿ (ಶೂನ್ಯ, ಋಣಾತ್ಮಕ, ತುಂಬಾ ದೊಡ್ಡದು). ರಚಿಸಿದ ಪರೀಕ್ಷೆಗಳನ್ನು ರನ್ ಮಾಡಿ, ನಂತರ ಅದೇ ಪರೀಕ್ಷೆಗಳನ್ನು "ಟೆಸ್ಟ್ ಆಡಿಟ್ ಟೆಂಪ್ಲೇಟ್" ನೊಂದಿಗೆ ಆಡಿಟ್ ಮಾಡಿ. ಕನಿಷ್ಠ ಒಂದು ದುರ್ಬಲ ಪರೀಕ್ಷೆಯನ್ನು ಹುಡುಕಿ, ಅದನ್ನು ಬಲಪಡಿಸಿ ಮತ್ತು ಪರೀಕ್ಷೆಗಳು ಕಾರ್ಯದ ನಿಜವಾದ ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಿ (ಸಣ್ಣ ದೋಷವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ).

ಪರಿಶೀಲನಾಪಟ್ಟಿ

• [ ] ನಾನು ಪರೀಕ್ಷಾ ಪಿರಮಿಡ್‌ಗೆ ಸೂಕ್ತವಾದ ಪದರವನ್ನು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇನೆ (ಆದ್ಯತಾ ಘಟಕ)
• [ ] ನಾನು ಸಂತೋಷದ ಸನ್ನಿವೇಶದ ಜೊತೆಗೆ ಮಿತಿ ಮತ್ತು ದೋಷದ ಪ್ರಕರಣಗಳನ್ನು ಬಯಸುತ್ತೇನೆ
• [ ] ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ಅರ್ಥಪೂರ್ಣವಾದ ಸಮರ್ಥನೆಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾನು ಪರಿಶೀಲಿಸಿದ್ದೇನೆ
• [ ] ನಾನು AI ಗೆ ಕೋಡ್ ಏನು ಮಾಡಬೇಕೆಂದು ಹೇಳಿದೆ, ಅದು ಏನು ಮಾಡುತ್ತದೆ ಎಂದು ಅಲ್ಲ
• [ ] ನಾನು ವಾಸ್ತವಿಕ ಅಪಾಯದ ಮಾರ್ಗಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದೆ, ವ್ಯಾಪ್ತಿಗಳ ಸಂಖ್ಯೆಯಲ್ಲ
• [ ] ನಾನು UI ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸ್ಥಿರ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಬಳಸಿದ್ದೇನೆ, ನಾನು ಪಠ್ಯಕ್ಕೆ ಬಂಧಿಸಲಿಲ್ಲ