ಲಾಭಗಳು:
- AI ಜೊತೆಗೆ ಯುನಿಟ್ ಪರೀಕ್ಷೆ, ಅಂಚಿನ ಪ್ರಕರಣಗಳು ಮತ್ತು ಕವರೇಜ್ ಗ್ಯಾಪ್ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಉತ್ಪಾದಿಸುವ ಸಾಮರ್ಥ್ಯ
- ಕೋಡ್ನ ಪ್ರಸ್ತುತ ನಡವಳಿಕೆಯಲ್ಲ, ನಿರ್ದಿಷ್ಟತೆಯ ಆಧಾರದ ಮೇಲೆ ಪರೀಕ್ಷಾ ನಿರೀಕ್ಷೆಗಳನ್ನು ಮುದ್ರಿಸುವ ಸಾಮರ್ಥ್ಯ
- ದೋಷಗಳನ್ನು ಚುಚ್ಚುವ ಮೂಲಕ ಪರೀಕ್ಷೆಯು ನಿಜವಾಗಿಯೂ ರಕ್ಷಿಸುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುವ ಸಾಮರ್ಥ್ಯ
ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು ಹೆಚ್ಚಿನ ಡೆವಲಪರ್ಗಳು ಮುಂದೂಡುವ ಅತ್ಯಂತ ಮೌಲ್ಯ-ಉತ್ಪಾದಿಸುವ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಕೋಡ್ ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಭವಿಷ್ಯದ ಬದಲಾವಣೆಗಳಿಗೆ ಜೀವಸೆಲೆಯಾಗಿದೆ ಎಂಬುದಕ್ಕೆ ಉತ್ತಮ ಪರೀಕ್ಷಾ ಸೂಟ್ ಪುರಾವೆಯಾಗಿದೆ. ಸಮಸ್ಯೆಯೆಂದರೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು ಪುನರಾವರ್ತಿತ ಮತ್ತು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ - ನಿಖರವಾಗಿ AI ಹೊಳೆಯುವ ರೀತಿಯ ಕೆಲಸ. ಆದರೆ ಒಂದು ಕ್ಯಾಚ್ ಇದೆ: AI ಸಾಮಾನ್ಯವಾಗಿ ಕೋಡ್ನ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ಅದು ಇರಬೇಕಾದ ನಡವಳಿಕೆಯಲ್ಲ. ಈ ವ್ಯತ್ಯಾಸವನ್ನು ನಿರ್ವಹಿಸುವುದು ಈ ಘಟಕದ ಮೂಲತತ್ವವಾಗಿದೆ.
ಈ ಘಟಕದಲ್ಲಿ, ನೀವು ಯೂನಿಟ್ ಪರೀಕ್ಷೆಯನ್ನು ಕಲಿಯುವಿರಿ (ಒಂದೇ ಕಾರ್ಯವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸುವ ಪರೀಕ್ಷೆ), ಎಡ್ಜ್ ಕೇಸ್ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು AI ಜೊತೆಗೆ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸುವುದು; ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯ ಅಂತರವನ್ನು ಮುಚ್ಚುವುದು; ಮತ್ತು AI ಪರೀಕ್ಷೆಗಳನ್ನು ಕುರುಡಾಗಿ ನಂಬುವುದು ಏಕೆ ಅಪಾಯಕಾರಿ.
ಪರೀಕ್ಷೆಯ ಎರಡು ಬದಿಗಳು: ಫಿಕ್ಸಿಂಗ್ ಬಿಹೇವಿಯರ್ ವಿರುದ್ಧ ಪರಿಶೀಲನೆ
ಪರೀಕ್ಷೆಯು ಎರಡು ವಿಭಿನ್ನ ಉದ್ದೇಶಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ. ಮೊದಲನೆಯದು ಪರಿಶೀಲನೆ: ಇದು ಕೋಡ್ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ಅದು ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ಎರಡನೆಯದು ರಿಗ್ರೆಶನ್ ರಕ್ಷಣೆ: ಇದು ಇಂದು ಕೋಡ್ನ ನಡವಳಿಕೆಯನ್ನು ಫ್ರೀಜ್ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಆಕಸ್ಮಿಕವಾಗಿ ಅದನ್ನು ನಾಳೆ ಬದಲಾಯಿಸಿದರೆ, ಪರೀಕ್ಷೆಯು ಮುರಿಯುತ್ತದೆ ಮತ್ತು ತಿಳಿಸುತ್ತದೆ.
AI ಎರಡನೆಯದು ತುಂಬಾ ಒಳ್ಳೆಯದು; ಇದು ಕೋಡ್ ಅನ್ನು ನೋಡುತ್ತದೆ ಮತ್ತು "ಇದು ಇದೀಗ ಏನು ಮಾಡುತ್ತಿದೆ" ಎಂದು ಪರೀಕ್ಷಿಸುವ ಪ್ರಕರಣಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಆದರೆ ಮೊದಲಿನಿಂದಲೂ ಕೋಡ್ ತಪ್ಪಾಗಿದ್ದರೆ, AI ಆ ತಪ್ಪು ನಡವಳಿಕೆಯನ್ನು "ಸರಿಯಾದ" ಎಂದು ಪಿನ್ ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ನೀವು AI ಉತ್ಪಾದಿಸುವ ಪ್ರತಿ ಪರೀಕ್ಷೆಯ ಸಮರ್ಥನೆಯನ್ನು ಪರಿಶೀಲಿಸಬೇಕು: "ಕೋಡ್ 42 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಪರೀಕ್ಷೆಯು 42 ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ" ಎಂದರೆ 42 ಸರಿಯಾದ ಉತ್ತರ ಎಂದು ಅರ್ಥವಲ್ಲ.
ಎಚ್ಚರಿಕೆ: AI ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾದರೆ, ಕೋಡ್ "ಕೆಲಸ ಮಾಡುತ್ತಿದೆ" ಎಂದು ಅರ್ಥವಲ್ಲ; ಇದರ ಅರ್ಥ "ಇದು AI ನಿರೀಕ್ಷಿಸಿದಂತೆ ವರ್ತಿಸುತ್ತದೆ". ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ನೋಡುವ ಮೂಲಕ ನಿರೀಕ್ಷೆ ಸರಿಯಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸುತ್ತೀರಿ.
ಹಂತ ಹಂತವಾಗಿ: AI ನೊಂದಿಗೆ ದೃಢವಾದ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು
- ಕೋಡ್ ಮಾತ್ರವಲ್ಲದೆ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ನೀಡಿ. "ಈ ಕಾರ್ಯವು ಇದನ್ನು ಮಾಡಬೇಕು" ಎಂಬ ಮಾಹಿತಿಯನ್ನು ನೀವು ಸೇರಿಸಿದರೆ, AI ಸರಿಯಾದ ನಿರೀಕ್ಷೆಯನ್ನು ಬರೆಯಬಹುದು; ನೀವು ಕೋಡ್ ಅನ್ನು ಒದಗಿಸಿದರೆ ಅದು ಪ್ರಸ್ತುತ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ.
- ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ಕೇಳಿ. ಖಾಲಿ, ಶೂನ್ಯ, ಶೂನ್ಯ, ಋಣಾತ್ಮಕ, ತುಂಬಾ ದೊಡ್ಡದು, ಕೆಟ್ಟ ಸ್ವರೂಪ, ಸಮನ್ವಯತೆ - ಸಂತೋಷದ ಹಾದಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿಕೊಳ್ಳಿ.
- ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟು ಮತ್ತು ಶೈಲಿಯನ್ನು ಸೂಚಿಸಿ. "ಪೈಟೆಸ್ಟ್ ಬಳಸಿ", "ಅರೇಂಜ್-ಆಕ್ಟ್-ಅಸರ್ಟ್ ಪ್ಯಾಟರ್ನ್", "ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ಒಂದು ವಿಷಯವನ್ನು ಪರೀಕ್ಷಿಸಲಿ" ಇತ್ಯಾದಿ.
- ನಿರೀಕ್ಷೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ (ಪ್ರತಿಪಾದನೆ). ಪ್ರತಿ ಪ್ರತಿಪಾದನೆಯು ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ನಿರ್ದಿಷ್ಟತೆಯೊಂದಿಗೆ ಹೋಲಿಕೆ ಮಾಡಿ.
- ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಅಂತರವನ್ನು ಮುಚ್ಚಿ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪರೀಕ್ಷೆಗಳನ್ನು ನೀಡಿ ಮತ್ತು "ಯಾವ ಶಾಖೆಗಳು ಮತ್ತು ಪ್ರಕರಣಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗಿಲ್ಲ?" ನಿಮ್ಮನ್ನು ಕೇಳುವಂತೆ ಮಾಡಿ; ನಂತರ ಉತ್ಪಾದಿಸಲಾದ ಹೆಚ್ಚುವರಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.
ಮೂರು ಮಿನಿ ಪ್ರಕರಣಗಳು
ಪ್ರಕರಣ 1 - 52% ರಿಂದ 85% ವರೆಗೆ ವ್ಯಾಪ್ತಿ. ಒಂದು ಸೇವಾ ಮಾಡ್ಯೂಲ್ನ ಪರೀಕ್ಷಾ ಕವರೇಜ್ 52% ಆಗಿತ್ತು. ತಂಡವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪರೀಕ್ಷೆಗಳನ್ನು AI ಗೆ ನೀಡಿತು, ಅದು ಪರೀಕ್ಷಿಸದ ಶಾಖೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿತು ಮತ್ತು ಅವುಗಳಿಗೆ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಿತು. ಮಾನವ ವಿಮರ್ಶೆಯೊಂದಿಗೆ, ವ್ಯಾಪ್ತಿಯು 85% ಕ್ಕೆ ಏರಿತು; ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಹಿಂದೆಂದೂ ಪರೀಕ್ಷಿಸದ ದೋಷ ಶಾಖೆಯಲ್ಲಿ AI ನಿಜವಾದ ದೋಷವನ್ನು (ತಪ್ಪಾದ ದೋಷ ಕೋಡ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸಿದ ಮಾರ್ಗ) ಬಹಿರಂಗಪಡಿಸಿತು.
ಪ್ರಕರಣ 2 - ತಪ್ಪು ನಿರೀಕ್ಷೆಯ ಸ್ಥಿರೀಕರಣ ಬಲೆ. ಹಣವನ್ನು ಸುತ್ತುವ ಕಾರ್ಯವು ನಿಜವಾಗಿ ತಪ್ಪಾಗಿದೆ; 2.675 ರಿಂದ 2.67 ರ ಬದಲಿಗೆ, 2.68 ರ ಬದಲಿಗೆ 2.67 ರೌಂಡಿಂಗ್ ಆಗಿತ್ತು. AI ಕೋಡ್ ಅನ್ನು ನೋಡಿದೆ ಮತ್ತು ಅಸೆರ್ಟ್ round_money (2.675) == 2.67 ಎಂದು ಬರೆದಿದೆ - ದೋಷವನ್ನು "ನಿಜ" ಎಂದು ಫ್ರೀಜ್ ಮಾಡುತ್ತದೆ. ಡೆವಲಪರ್ ವಿವರಣೆಯನ್ನು ಓದಿದಾಗ, ಅವರು ನಿರೀಕ್ಷೆಯನ್ನು ಸರಿಪಡಿಸಿದರು ಮತ್ತು ನಿಜವಾದ ದೋಷವನ್ನು ಹಿಡಿದರು. ನಿಯಮವನ್ನು ಪರೀಕ್ಷಿಸುವುದು, ಕೋಡ್ ಅಲ್ಲ, ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡಿದೆ.
ಪ್ರಕರಣ 3 - ಎಡ್ಜ್ ಸ್ಟೇಟ್ ಸ್ಫೋಟ. ದಿನಾಂಕ ಶ್ರೇಣಿಯ ಕಾರ್ಯಕ್ಕಾಗಿ ಕೇವಲ "ಎಡ್ಜ್ ಕೇಸ್" ಗಾಗಿ AI ಅನ್ನು ಕೇಳಿದಾಗ; ಇದು ಪ್ರಾರಂಭ=ಅಂತ್ಯ, ಹಿಮ್ಮುಖ ಮಧ್ಯಂತರ, ಅಧಿಕ ವರ್ಷ ಫೆಬ್ರವರಿ 29, ವಿಭಿನ್ನ ಸಮಯ ವಲಯಗಳು ಮತ್ತು ಶೂನ್ಯ ಮಧ್ಯಂತರಗಳಂತಹ 8 ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ಮಿಸಿದೆ. ಇವುಗಳಲ್ಲಿ ಎರಡು (ರಿವರ್ಸ್ ಸ್ಪೇಸಿಂಗ್ ಮತ್ತು ಅಧಿಕ ವರ್ಷ) ವಾಸ್ತವವಾಗಿ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತಿವೆ. ಈ ಪ್ರಕರಣಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪರಿಗಣಿಸುವುದನ್ನು ಹೆಚ್ಚಾಗಿ ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ; AI ಇಲ್ಲಿ "ಎಡ್ಜ್-ಕೇಸ್ ಬುದ್ದಿಮತ್ತೆ" ಪಾಲುದಾರರಾದರು.
ನಾಲ್ಕು ನಕಲು ಮಾಡಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್ಗಳು
ನಿರ್ದಿಷ್ಟತೆ ಆಧಾರಿತ ಪರೀಕ್ಷೆಯ ಉತ್ಪಾದನೆ:
ಪಾತ್ರ: ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವ ಡೆವಲಪರ್. ಫ್ರೇಮ್ವರ್ಕ್: {{pytest/JUnit/Jest...}}. ಕಾರ್ಯವು ಏನು ಮಾಡಬೇಕು (ನಿರ್ದಿಷ್ಟತೆ): {{rule}}ಕೆಳಗಿನ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ. ನಿರ್ದಿಷ್ಟತೆಯ ಪ್ರಕಾರ ನಿರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ, ಕೋಡ್ನ ಪ್ರಸ್ತುತ ಔಟ್ಪುಟ್ ಅಲ್ಲ. ಸಂತೋಷದ ಮಾರ್ಗ + ಕನಿಷ್ಠ 4 ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ಸೇರಿಸಿ. ಪ್ರತಿ ಪರೀಕ್ಷೆಯು ಒಂದು ವಿಷಯವನ್ನು ಪರೀಕ್ಷಿಸಲಿ, ವಿವರಣಾತ್ಮಕ ಹೆಸರನ್ನು ಬಳಸಿ. {{ಫಂಕ್ಷನ್}}
ಎಡ್ಜ್ ಕೇಸ್ ಬುದ್ದಿಮತ್ತೆ:
ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಬೇಕಾದ ಎಡ್ಜ್/ವೈಫಲ್ಯ ಪ್ರಕರಣಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ (ಶೂನ್ಯ, ಶೂನ್ಯ, ಬ್ರೇಕ್ಪಾಯಿಂಟ್ಗಳು, ಕೆಟ್ಟ ಸ್ವರೂಪ, ಏಕಕಾಲಿಕತೆ, ಬಾಹ್ಯ ದೋಷ). ಪ್ರತಿ ಪ್ರಕರಣಕ್ಕೆ: ಇನ್ಪುಟ್, ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ. ಇನ್ನೂ ಕೋಡ್ ಬರೆಯಬೇಡಿ, ಪಟ್ಟಿ ಮಾಡಿ.{{ಫಂಕ್ಷನ್}}
ವ್ಯಾಪ್ತಿ ಅಂತರ ವಿಶ್ಲೇಷಣೆ:
ಕಾರ್ಯಗಳು ಮತ್ತು ಲಭ್ಯವಿರುವ ಪರೀಕ್ಷೆಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಯಾವ ಶಾಖೆಗಳು, ಷರತ್ತುಗಳು ಮತ್ತು ಪ್ರಕರಣಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗಿಲ್ಲ? ನ್ಯೂನತೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ ಮತ್ತು ನ್ಯೂನತೆಗಳಿಗೆ ಮಾತ್ರ ಹೊಸ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವವುಗಳನ್ನು ಪುನರಾವರ್ತಿಸಬೇಡಿ. ಕಾರ್ಯ:{{function}}ಪರೀಕ್ಷೆಗಳು:{{existing_tests}}
ಪರೀಕ್ಷಾ ಡೇಟಾ / ಅಣಕು ವಸ್ತು ಉತ್ಪಾದನೆ:
{{ಫಂಕ್ಷನ್/ಸೇವೆ}} ಪರೀಕ್ಷೆಗಳಿಗೆ ವಾಸ್ತವಿಕ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸಿ: ಮಾನ್ಯ ಮಾದರಿಗಳು, ಗಡಿ ಮಾದರಿಗಳು ಮತ್ತು ಅಮಾನ್ಯ ಮಾದರಿಗಳು ಪ್ರತ್ಯೇಕವಾಗಿ. ಬಾಹ್ಯ ಅವಲಂಬನೆ {{X}} ಗಾಗಿ ಸರಳ ಅಣಕು ನಡವಳಿಕೆಯನ್ನು ಸೂಚಿಸಿ. ನಿಜವಾದ ಗೌಪ್ಯ ಡೇಟಾ/PII ಅನ್ನು ಬಳಸುವುದು; ನಕಲಿ ಡೇಟಾವನ್ನು ರಚಿಸಿ.
ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್
ದುರ್ಬಲ: "ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಿರಿ."
ಪ್ರಬಲ: "ಪೈಟೆಸ್ಟ್ನೊಂದಿಗೆ. ಫಂಕ್ಷನ್ ಅಪ್ಲೈ_ಡಿಸ್ಕೌಂಟ್ (ಒಟ್ಟು, ಶೇಕಡಾ) - ನಿಯಮ: ರಿಯಾಯಿತಿಯು 0%–30% ಆಗಿರಬೇಕು, ಮಿತಿಯ ಹೊರಗೆ ಮೌಲ್ಯದೋಷವನ್ನು ಎಸೆಯಬೇಕು, ಫಲಿತಾಂಶವನ್ನು 2 ದಶಮಾಂಶಗಳಿಗೆ ದುಂಡಾದ ಮಾಡಬೇಕು. ಈ ನಿಯಮದ ಮೂಲಕ ನಿರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ (ಕೋಡ್ನಿಂದ ಅಲ್ಲ). ಹ್ಯಾಪಿ ಪಾತ್ + ಈ ಎಡ್ಜ್ ಪ್ರಕರಣಗಳು: 0%, 31 30 [ಕೋಡ್]"
ಅವರು ಬಲವಾದ ಬಿಡುಗಡೆಯ ನಿಯಮವನ್ನು ನೀಡುತ್ತಾರೆ ಮತ್ತು "ನಿಯಮಕ್ಕೆ ಅನುಗುಣವಾಗಿ ನಿರೀಕ್ಷೆಯನ್ನು ಬರೆಯಿರಿ, ಕೋಡ್ ಅಲ್ಲ" ಎಂದು ಹೇಳುತ್ತಾರೆ; ಈ ಒಂದೇ ವಾಕ್ಯವು AI ಫಿಕ್ಸಿಂಗ್ ದುರ್ವರ್ತನೆಯ ಬಲೆಯನ್ನು ಮುಚ್ಚುತ್ತದೆ.
ಪರೀಕ್ಷಾ ಪ್ರಕಾರ
AI ಕೊಡುಗೆ
ಮಾನವ ನಿಯಂತ್ರಣ
ಸಂತೋಷದ ರಸ್ತೆ ಘಟಕ ಪರೀಕ್ಷೆ
ವೇಗದ ಅಸ್ಥಿಪಂಜರ
ನಿರೀಕ್ಷೆ ಸರಿಯಾಗಿದೆಯೇ?
ಎಡ್ಜ್ ಪ್ರಕರಣಗಳು
ವ್ಯಾಪಕವಾದ ಬುದ್ದಿಮತ್ತೆ
ಅಪ್ರಸ್ತುತವನ್ನು ನಿವಾರಿಸಿ
ವ್ಯಾಪ್ತಿ ಅಂತರವನ್ನು ತುಂಬುವುದು
ಬಿಟ್ಟುಹೋದ ಶಾಖೆಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ
ಮಹತ್ವವನ್ನು ದೃಢೀಕರಿಸಿ
ಪರೀಕ್ಷಾ ಡೇಟಾ/ಅಣಕು
ವಾಸ್ತವಿಕ ಮಾದರಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ
PII ಇಲ್ಲ, ವಾಸ್ತವಿಕತೆಯ ನಿಯಂತ್ರಣ
ಪರೀಕ್ಷೆಗಳು ಗುಣಮಟ್ಟವನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ, ಖಾತರಿ ನೀಡುವುದಿಲ್ಲ
ಹೆಚ್ಚಿನ ಪರೀಕ್ಷಾ ಕವರೇಜ್ ಆತ್ಮವಿಶ್ವಾಸವನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ ಇದು ತಪ್ಪುದಾರಿಗೆಳೆಯಬಹುದು: 100 ಪ್ರತಿಶತ ಕವರೇಜ್ ಎಂದರೆ "ಪ್ರತಿ ಲೈನ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗಿದೆ," "ಪ್ರತಿ ಸಾಲು ಸರಿಯಾಗಿದೆ." AI ಯೊಂದಿಗೆ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುವುದು ಸುಲಭ; ಅರ್ಥಪೂರ್ಣ ನಿರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದರಲ್ಲಿ ನಿಜವಾದ ಮೌಲ್ಯವಿದೆ. ಪರೀಕ್ಷೆಯ ಮೌಲ್ಯವು ಕೋಡ್ ಮುರಿದಾಗ ಅದನ್ನು ಮುರಿಯುವ ಮತ್ತು ಎಚ್ಚರಿಸುವ ಸಾಮರ್ಥ್ಯವಾಗಿದೆ. ಅದಕ್ಕಾಗಿಯೇ AI- ರಚಿತವಾದ ಪರೀಕ್ಷೆಗಳು "ಕೋಡ್ ಬದಲಾದಾಗ ಅದು ನಿಜವಾಗಿಯೂ ಒಡೆಯುತ್ತದೆಯೇ?" ಎಂಬ ಪ್ರಶ್ನೆಯನ್ನು ಆಧರಿಸಿದೆ. ಪ್ರಶ್ನೆಯೊಂದಿಗೆ ಅದನ್ನು ಪರೀಕ್ಷಿಸಿ; ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ರೇಖೆಯನ್ನು ಮುರಿಯುವುದು ಮತ್ತು ಪರೀಕ್ಷಾ ವಿರಾಮವನ್ನು ನೋಡುವುದು (ಮ್ಯುಟೇಶನ್ ಕಲ್ಪನೆ) ಪರೀಕ್ಷೆಯು ಕೆಲಸ ಮಾಡಿದೆ ಎಂಬುದಕ್ಕೆ ಪುರಾವೆಯಾಗಿದೆ.
ಸಲಹೆ: AI ಬರೆಯುವ ಪರೀಕ್ಷೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ನೋಡಲು, ಕೋಡ್ನಲ್ಲಿ ಸಣ್ಣ ದೋಷವನ್ನು ರಚಿಸಿ (ಉದಾ. a + ಗೆ a - ಬದಲಾಯಿಸಿ) ಮತ್ತು ಪರೀಕ್ಷೆಯು ಮುರಿದುಹೋಗುತ್ತದೆಯೇ ಎಂದು ನೋಡಿ. ಅದು ಮುರಿಯದಿದ್ದರೆ, ಆ ಪರೀಕ್ಷೆಯು ನಿಮ್ಮನ್ನು ರಕ್ಷಿಸುವುದಿಲ್ಲ.
ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು
- ನಿಯಮ ನೀಡದೆ ಪರೀಕ್ಷೆಗೆ ಕೇಳುತ್ತಿದ್ದಾರೆ. ಮಾದರಿಯು ಪ್ರಸ್ತುತ ನಡವಳಿಕೆಯನ್ನು ಫ್ರೀಜ್ ಮಾಡುತ್ತದೆ; ದೋಷವನ್ನು "ನಿಜ" ಎಂದು ಸರಿಪಡಿಸುತ್ತದೆ.
- ನಿರೀಕ್ಷೆಗಳನ್ನು ಓದದೆ ಸ್ವೀಕರಿಸುವುದು. ಸಮರ್ಥನೆಗಳು ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿವೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸದಿದ್ದರೆ ಪರೀಕ್ಷೆಯು ತಪ್ಪುದಾರಿಗೆಳೆಯುತ್ತದೆ.
- ಕೇವಲ ಸಂತೋಷದ ಮಾರ್ಗವನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದೆ. ನಿಜವಾದ ದೋಷಗಳು ಅಂಚುಗಳಲ್ಲಿ ವಾಸಿಸುತ್ತವೆ; ಎಡ್ಜ್ ಕೇಸ್ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕೇಳಿ.
- ಉದ್ದೇಶಕ್ಕಾಗಿ ವ್ಯಾಪ್ತಿಯನ್ನು ತಪ್ಪಾಗಿ ಗ್ರಹಿಸುವುದು. ಹೆಚ್ಚಿನ ಶೇಕಡಾವಾರು ಸರಿಯಾದ ನಡವಳಿಕೆಯ ಖಾತರಿಯಿಲ್ಲ.
- ಪರೀಕ್ಷಾ ಡೇಟಾದಂತೆ ನೈಜ/ಗುಪ್ತ ಡೇಟಾವನ್ನು ಮಾಡುವುದು. ಗ್ರಾಹಕರ ಡೇಟಾ ಅಥವಾ ರಹಸ್ಯಗಳು ಪರೀಕ್ಷೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯನ್ನು ನಮೂದಿಸಬಾರದು; ಸಂಶ್ಲೇಷಿತ ಡೇಟಾವನ್ನು ರಚಿಸಿ.
ಸಾರಾಂಶದಲ್ಲಿ
ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದರಿಂದ AI ಪುನರಾವರ್ತಿತ ಹೊರೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಇದು ವೇಗದ ಅಸ್ಥಿಪಂಜರಗಳನ್ನು, ಅಂಚಿನ ಪ್ರಕರಣಗಳ ದೊಡ್ಡ ಪಟ್ಟಿಗಳನ್ನು ಮತ್ತು ಕವರೇಜ್ ಗ್ಯಾಪ್ ವಿಶ್ಲೇಷಣೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಆದರೆ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಅಂಶವೆಂದರೆ ನಿರೀಕ್ಷೆಗಳು: AI ಕೋಡ್ನ ಪ್ರಸ್ತುತ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಒಲವು ತೋರುತ್ತದೆ, ಆದರೆ ಪರೀಕ್ಷೆಯನ್ನು ನಿರ್ದಿಷ್ಟತೆಯ ಪ್ರಕಾರ ಬರೆಯಬೇಕು. ನಿಯಮವನ್ನು ನೀಡಿ, ನಿರೀಕ್ಷೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ, ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ಜಾರಿಗೊಳಿಸಿ ಮತ್ತು ದೋಷವನ್ನು ಚುಚ್ಚುವ ಮೂಲಕ ಪರೀಕ್ಷೆಗಳು ನಿಜವಾಗಿಯೂ ರಕ್ಷಿಸುತ್ತವೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಿ. ಪರೀಕ್ಷಾ ಕವರೇಜ್ ಒಂದು ಸಾಧನವಾಗಿದೆ, ಗುರಿಯಲ್ಲ.
ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ
ಕಾರ್ಯವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ ಮತ್ತು ಮೊದಲು ಅದರ ಕೋಡ್ ಅನ್ನು ನೀಡುವ ಮೂಲಕ AI ಗೆ ಪರೀಕ್ಷೆಯನ್ನು ಮುದ್ರಿಸಿ; ನಿರೀಕ್ಷೆಗಳನ್ನು ಗಮನಿಸಿ. ನಂತರ ಪರೀಕ್ಷೆಯನ್ನು ಮತ್ತೊಮ್ಮೆ ಮುದ್ರಿಸಿ, ಅದೇ ಕಾರ್ಯಕ್ಕಾಗಿ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು (ಅಗತ್ಯವಿರುವ ನಡವಳಿಕೆ) ನೀಡುತ್ತದೆ. ಎರಡು ಪರೀಕ್ಷಾ ಸೆಟ್ಗಳ ನಿರೀಕ್ಷೆಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ: ಯಾವುದಾದರೂ ವಿಭಿನ್ನವಾಗಿದೆಯೇ, ಯಾವುದು ನಿಜವಾದ ದೋಷವನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ? ಅಂತಿಮವಾಗಿ, ಕೋಡ್ಗೆ ಉದ್ದೇಶಪೂರ್ವಕ ದೋಷವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಮತ್ತು ಪರೀಕ್ಷಾ ವಿರಾಮವನ್ನು ನೋಡುವ ಮೂಲಕ ರಚಿಸಲಾದ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಒಂದು ಕೆಲಸ ಮಾಡಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ.
ಪರಿಶೀಲನಾಪಟ್ಟಿ
- [ ] ಪರೀಕ್ಷೆಯು ನಡವಳಿಕೆಯನ್ನು ಸರಿಪಡಿಸಲು ಅಥವಾ ಪರಿಶೀಲಿಸಲು ನಾನು ಪ್ರತ್ಯೇಕಿಸುತ್ತೇನೆ.
- [ ] ನಾನು ಪರೀಕ್ಷೆಗೆ ವಿನಂತಿಸಿದಾಗ, ನಾನು ನಿಯಮವನ್ನು (ವಿಶೇಷಣ) ನೀಡುತ್ತೇನೆ, ಅದು ಕೋಡ್ ಅಲ್ಲ.
- [ ] ನಾನು ಪ್ರತಿ ರಚಿಸಲಾದ ಸಮರ್ಥನೆಯನ್ನು ನಿರ್ದಿಷ್ಟತೆಗೆ ಹೋಲಿಸುತ್ತೇನೆ.
- [ ] ನಾನು ಎಡ್ಜ್ ಮತ್ತು ವೈಫಲ್ಯದ ಪ್ರಕರಣಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವಿನಂತಿಸುತ್ತೇನೆ.
- [ ] ನಾನು ಶೇಕಡಾವಾರು ವ್ಯಾಪ್ತಿಯನ್ನು ಒಂದು ಸಾಧನವಾಗಿ ನೋಡುತ್ತೇನೆ, ಗುರಿಯಾಗಿಲ್ಲ.
- [ ] ದೋಷಗಳನ್ನು ಚುಚ್ಚುವ ಮೂಲಕ ಪರೀಕ್ಷೆಯು ನಿಜವಾಗಿಯೂ ರಕ್ಷಿಸುತ್ತದೆಯೇ ಎಂದು ನಾನು ಪರೀಕ್ಷಿಸುತ್ತೇನೆ.