ਯੂਨਿਟ ਟੈਸਟ ਜਨਰੇਸ਼ਨ ਅਤੇ ਟੈਸਟੇਬਿਲਟੀ: AI ਨਾਲ ਮਜ਼ਬੂਤ ਟੈਸਟਿੰਗ

ਲਾਭ:

• ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ ਤੋਂ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਯੂਨਿਟ ਟੈਸਟਾਂ ਵਿੱਚ ਅਨੁਮਾਨਤ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਕੇ ਗਲਤ ਵਿਵਹਾਰ ਨੂੰ 'ਸਹੀ' ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਨ ਤੋਂ ਨਕਲੀ ਬੁੱਧੀ ਨੂੰ ਰੋਕਣ ਦੀ ਸਮਰੱਥਾ
• AAA ਅਤੇ FIRST ਸਿਧਾਂਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਅਤੇ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦਾ ਮਜ਼ਾਕ ਉਡਾ ਕੇ ਤੇਜ਼, ਸੁਤੰਤਰ ਅਤੇ ਦੁਹਰਾਉਣਯੋਗ ਟੈਸਟਾਂ ਨੂੰ ਛਾਪਣ ਦੀ ਸਮਰੱਥਾ
• ਪਰਿਵਰਤਨ (ਕੋਡ ਤੋੜਨ) ਨਾਲ ਟੈਸਟਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਡਿਜ਼ਾਇਨ ਦੀ ਗੰਧ ਦੇ ਤੌਰ 'ਤੇ ਟੈਸਟ ਕਰਨ ਲਈ ਮੁਸ਼ਕਲ ਕੋਡ ਦੀ ਪਛਾਣ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

ਟੈਸਟਿੰਗ ਪਿਰਾਮਿਡ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਅਤੇ ਸਭ ਤੋਂ ਤੇਜ਼ ਪਰਤ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਹੈ — ਟੈਸਟਿੰਗ ਜੋ ਕਿਸੇ ਫੰਕਸ਼ਨ ਜਾਂ ਕੋਡ ਦੇ ਛੋਟੇ ਟੁਕੜੇ ਨੂੰ ਹਰ ਚੀਜ਼ ਤੋਂ ਅਲੱਗ ਕਰਕੇ ਪ੍ਰਮਾਣਿਤ ਕਰਦੀ ਹੈ। ਹਜ਼ਾਰਾਂ ਯੂਨਿਟ ਟੈਸਟ ਸਕਿੰਟਾਂ ਵਿੱਚ ਚੱਲਦੇ ਹਨ ਅਤੇ ਇੱਕ ਬੱਗ ਫੜਦੇ ਹਨ ਜਦੋਂ ਕੋਡ ਅਜੇ ਵੀ ਡਿਵੈਲਪਰ ਦੀ ਸਕ੍ਰੀਨ 'ਤੇ ਹੁੰਦਾ ਹੈ। ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਯੂਨਿਟ ਟੈਸਟਾਂ ਦੇ ਉਤਪਾਦਨ ਵਿੱਚ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵੱਧ ਨਿਪੁੰਨ ਹੈ: ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਦਿੰਦੇ ਹੋ, AI ਦਰਜਨਾਂ ਟੈਸਟਾਂ ਦਾ ਉਤਪਾਦਨ ਕਰਦਾ ਹੈ। ਪਰ ਇਹ ਬਹੁਤ ਹੀ ਸਹੂਲਤ ਸਭ ਤੋਂ ਵੱਡੇ ਜਾਲ ਨੂੰ ਜਨਮ ਦਿੰਦੀ ਹੈ: AI ਆਸਾਨੀ ਨਾਲ ਅਜਿਹੇ ਟੈਸਟ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜੋ "ਹਰੇ ਰੰਗ ਦੇ ਚਮਕਦੇ ਹਨ ਪਰ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕਰਦੇ" ਜਾਂ ਕੋਡ ਦੇ ਮੌਜੂਦਾ (ਸ਼ਾਇਦ ਨੁਕਸਦਾਰ) ਵਿਵਹਾਰ ਨੂੰ "ਸਹੀ" ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ AI ਦੇ ਨਾਲ ਅਸਲ ਵਿੱਚ ਸੁਰੱਖਿਆਤਮਕ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਅਤੇ ਟੈਸਟੇਬਲ ਕੋਡ ਅਤੇ AI ਵਿਚਕਾਰ ਸਬੰਧ।

ਇੱਕ ਚੰਗੀ ਯੂਨਿਟ ਟੈਸਟ ਦੇ ਗੁਣ: ਪਹਿਲਾ

ਚੰਗੇ ਯੂਨਿਟ ਟੈਸਟ ਪਹਿਲੇ ਸਿਧਾਂਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹਨ: ਤੇਜ਼, ਸੁਤੰਤਰ (ਟੈਸਟ ਇੱਕ ਦੂਜੇ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ), ਦੁਹਰਾਉਣ ਯੋਗ (ਦੁਹਰਾਉਣ ਯੋਗ — ਕਿਸੇ ਵੀ ਵਾਤਾਵਰਣ ਵਿੱਚ ਉਹੀ ਨਤੀਜਾ), ਸਵੈ-ਪ੍ਰਮਾਣਿਤ (ਸਪਸ਼ਟ ਪਾਸ/ਫੇਲ), ਸਮੇਂ ਸਿਰ (ਸਮੇਂ 'ਤੇ)। AI ਉਤਪਾਦਨ ਦੇ ਟੈਸਟ ਕਰਵਾਉਣ ਵੇਲੇ ਆਪਣੇ ਆਪ ਨੂੰ ਇਹਨਾਂ ਸਿਧਾਂਤਾਂ ਦੀ ਯਾਦ ਦਿਵਾਓ; ਖਾਸ ਤੌਰ 'ਤੇ ਪੁੱਛੋ ਕਿ ਟੈਸਟ "ਸੁਤੰਤਰ" ਅਤੇ "ਦੁਹਰਾਉਣਯੋਗ" ਹੋਣ ਲਈ ਬਾਹਰੀ ਸੰਸਾਰ (ਅਸਲ ਡਾਟਾਬੇਸ, ਨੈੱਟਵਰਕ, ਘੜੀ) 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।

AAA ਪੈਟਰਨ ਅਤੇ ਭਾਵਪੂਰਤ ਦਾਅਵਾ

ਇੱਕ ਠੋਸ ਯੂਨਿਟ ਟੈਸਟ AAA ਢਾਂਚੇ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ: ਵਿਵਸਥਿਤ ਕਰੋ (ਤਿਆਰ ਕਰੋ — ਇਨਪੁਟ ਅਤੇ ਨਿਰਭਰਤਾ ਸੈਟ ਅਪ ਕਰੋ), ਐਕਟ (ਐਕਜ਼ੀਕਿਊਟ ਕਰੋ — ਟੈਸਟ ਦੇ ਅਧੀਨ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ), ਅਸਰਟ (ਪ੍ਰਮਾਣਿਤ ਕਰੋ — ਉਮੀਦ ਕੀਤੇ ਮੁੱਲ ਨਾਲ ਨਤੀਜੇ ਦੀ ਤੁਲਨਾ ਕਰੋ)। ਨਾਜ਼ੁਕ ਇੱਕ ਦਾਅਵਾ ਹੈ. AI ਦੁਆਰਾ ਕੀਤੀ ਗਈ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀ ਟੈਸਟ ਦੇ ਅਧੀਨ ਕੋਡ ਦੇ ਆਉਟਪੁੱਟ ਤੋਂ ਦਾਅਵਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ — “ਜੋ ਵੀ ਕੋਡ ਵਾਪਸ ਕਰਦਾ ਹੈ ਉਹ ਸੱਚ ਹੈ” ਤਰਕ। ਇਹ ਟੈਸਟ ਨੂੰ ਅਰਥਹੀਣ ਬਣਾ ਦਿੰਦਾ ਹੈ. ਸਹੀ ਤਰੀਕਾ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਉਮੀਦ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ (ਸਵੀਕ੍ਰਿਤੀ ਦੇ ਮਾਪਦੰਡ ਤੋਂ, ਇਸਦੀ ਖੁਦ ਗਣਨਾ ਕਰੋ)।

ਧਿਆਨ ਦਿਓ: ਜੇਕਰ ਤੁਸੀਂ AI ਨੂੰ "ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਟੈਸਟ ਲਿਖੋ" ਕਹਿੰਦੇ ਹੋ, ਤਾਂ AI ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਆਉਟਪੁੱਟ ਨੂੰ "ਉਮੀਦ" ਵਜੋਂ ਲਿਖ ਸਕਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਪਾਸ ਹੁੰਦਾ ਹੈ ਭਾਵੇਂ ਫੰਕਸ਼ਨ ਗਲਤ ਹੈ। ਇਸਦੀ ਬਜਾਏ, ਕਹੋ "ਤੁਸੀਂ ਇਹਨਾਂ ਨਿਯਮਾਂ ਦੇ ਅਨੁਸਾਰ ਸੰਭਾਵਿਤ ਨਤੀਜਿਆਂ ਦੀ ਗਣਨਾ ਕਰਦੇ ਹੋ, ਫੰਕਸ਼ਨ ਦੇ ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਦਾ ਹਵਾਲਾ ਨਾ ਦਿਓ।"

ਮਖੌਲ, ਸਟੱਬ ਅਤੇ ਨਿਰਭਰਤਾ

ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਲਈ ਆਈਸੋਲੇਸ਼ਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਡਾ ਫੰਕਸ਼ਨ ਇੱਕ ਡੇਟਾਬੇਸ ਜਾਂ API 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਟੈਸਟਿੰਗ ਵਿੱਚ ਮੌਕ ਆਬਜੈਕਟ (ਮੌਕ/ਸਟੱਬ — ਇੱਕ ਨਿਯੰਤਰਿਤ, ਅਸਲੀ ਨਿਰਭਰਤਾ ਲਈ ਡਮੀ ਬਦਲ) ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਨੂੰ ਤੇਜ਼, ਸੁਤੰਤਰ ਅਤੇ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। AI ਨਕਲੀ ਸਥਾਪਨਾ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ; ਪਰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮਜ਼ਾਕ ਉਡਾਉਣ ਤੋਂ ਸਾਵਧਾਨ ਰਹੋ: ਜੇ ਤੁਸੀਂ ਹਰ ਚੀਜ਼ ਦਾ ਮਜ਼ਾਕ ਉਡਾਉਂਦੇ ਹੋ, ਤਾਂ ਟੈਸਟ ਸਿਰਫ਼ "ਮਜ਼ਾਕ ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ" ਦੀ ਪੁਸ਼ਟੀ ਕਰੇਗਾ, ਅਸਲ ਤਰਕ ਦੀ ਨਹੀਂ। ਸੰਤੁਲਨ: ਬਾਹਰੀ ਦੁਨੀਆ ਦੀ ਨਕਲ ਕਰੋ, ਟੈਸਟ ਦੇ ਅਧੀਨ ਅਸਲ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ.

ਟੈਸਟਬਿਲਟੀ ਅਤੇ ਏ.ਆਈ

ਇੱਕ ਦਿਲਚਸਪ ਫੀਡਬੈਕ ਹੈ: ਕੋਡ ਜਿਸਦੀ ਜਾਂਚ ਕਰਨਾ ਔਖਾ ਹੁੰਦਾ ਹੈ ਉਹ ਅਕਸਰ ਮਾੜਾ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਕੋਡ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ AI ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ (ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਰਭਰਤਾਵਾਂ, ਲੁਕਵੀਂ ਗਲੋਬਲ ਸਥਿਤੀ, ਮਾੜੇ ਪ੍ਰਭਾਵ) ਲਈ ਟੈਸਟ ਲਿਖਣ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਡਿਜ਼ਾਈਨ ਦੀ ਗੰਧ ਹੈ। AI ਨੂੰ ਪੁੱਛਣਾ "ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਟੈਸਟ ਕਰਨ ਯੋਗ ਬਣਾਉਣ ਲਈ ਕਿਵੇਂ ਰੀਫੈਕਟਰ ਕਰੋਗੇ" ਬਿਹਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਬਿਹਤਰ ਕੋਡ ਦੋਵਾਂ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ।

ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਟੈਸਟ ਅਤੇ ਡਾਟਾ ਵਿਭਿੰਨਤਾ

ਵੱਖ-ਵੱਖ ਇਨਪੁਟਸ ਦੇ ਨਾਲ ਇੱਕੋ ਨਿਯਮ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਹਰ ਵਾਰ ਇੱਕ ਵੱਖਰਾ ਟੈਸਟ ਲਿਖਣਾ ਔਖਾ ਅਤੇ ਕਾਇਮ ਰੱਖਣਾ ਮੁਸ਼ਕਲ ਹੈ। ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਟੈਸਟਿੰਗ — ਇੱਕ ਢਾਂਚਾ ਜੋ ਵਾਰ-ਵਾਰ ਇਨਪੁਟਸ ਅਤੇ ਸੰਭਾਵਿਤ ਨਤੀਜਿਆਂ ਦੀ ਸੂਚੀ 'ਤੇ ਇੱਕੋ ਟੈਸਟ ਤਰਕ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ — ਇਸ ਦੁਹਰਾਓ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ: ਇੱਕ ਸਿੰਗਲ ਟੈਸਟ ਬਾਡੀ ਨੂੰ ਦਰਜਨਾਂ ਇੰਪੁੱਟ ਜੋੜਿਆਂ ਨਾਲ ਖੁਆਇਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ ਦਿੰਦੇ ਹੋ ਤਾਂ AI ਇਹਨਾਂ ਇਨਪੁਟ-ਉਮੀਦ ਕੀਤੇ ਨਤੀਜੇ ਟੇਬਲ ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਕੁਸ਼ਲ ਹੈ; ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹ ਯੋਜਨਾਬੱਧ ਢੰਗ ਨਾਲ ਸੀਮਾ ਮੁੱਲਾਂ ਅਤੇ ਸਮਾਨਤਾ ਵਰਗਾਂ ਨੂੰ ਸਾਰਣੀਬੱਧ ਕਰਦਾ ਹੈ।

ਪਰ ਇੱਥੇ ਇੱਕ ਜਾਲ ਵੀ ਹੈ: AI ਟੈਸਟ ਦੇ ਅਧੀਨ ਕੋਡ ਤੋਂ ਤਿਆਰ ਕੀਤੀ ਸਾਰਣੀ ਵਿੱਚ ਸੰਭਾਵਿਤ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਟੈਸਟਿੰਗ ਵਿੱਚ ਇਹ ਗਲਤੀ ਹੋਰ ਵੀ ਖਤਰਨਾਕ ਹੈ, ਕਿਉਂਕਿ ਇੱਕ ਗਲਤ ਤਰਕ ਦਰਜਨਾਂ ਲਾਈਨਾਂ ਨੂੰ ਅਯੋਗ ਕਰ ਦਿੰਦਾ ਹੈ। ਇਸ ਲਈ, ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ ਦੇ ਅਨੁਸਾਰ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਅਨੁਮਾਨਿਤ ਨਤੀਜੇ ਕਾਲਮ ਦੀ ਗਣਨਾ ਕਰੋ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਕੁਝ ਕਤਾਰਾਂ ਨੂੰ ਹੱਥੀਂ ਪ੍ਰਮਾਣਿਤ ਕਰੋ। ਇੱਕ ਵਰਣਨ ਕਾਲਮ ਲਈ ਵੀ ਪੁੱਛੋ "ਹਰੇਕ ਕਤਾਰ ਕੀ ਦਰਸਾਉਂਦੀ ਹੈ"; ਇਸ ਲਈ ਜਦੋਂ ਇੱਕ ਕਤਾਰ ਟੁੱਟਦੀ ਹੈ ਤਾਂ ਤੁਸੀਂ ਤੁਰੰਤ ਦੇਖੋ ਕਿ ਕਿਹੜੀ ਅਵਸਥਾ ਟੁੱਟੀ ਹੈ।

ਨੁਕਤਾ: ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਟੈਸਟ ਟੇਬਲ ਵਿੱਚ ਜਾਣਬੁੱਝ ਕੇ ਇੱਕ "ਟਰੈਪ ਕਤਾਰ" ਸ਼ਾਮਲ ਕਰੋ — ਭਾਵ, ਜਾਣਬੁੱਝ ਕੇ ਨਤੀਜਾ ਗਲਤ ਟਾਈਪ ਕਰੋ। ਜੇਕਰ ਉਹ ਲਾਈਨ ਲਾਲ ਨਹੀਂ ਹੁੰਦੀ ਜਦੋਂ ਤੁਸੀਂ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡਾ ਟੈਸਟ ਅਸਲ ਵਿੱਚ ਉਸ ਸਥਿਤੀ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ। ਇਹ ਇੱਕ ਤੇਜ਼ ਮੌਕ-ਪਾਸ ਜਾਂਚ ਹੈ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਇਕ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖੋ।"

ਮਜ਼ਬੂਤ: "ਟੈਕਸ ਕੈਲਕੂਲੇਟ(ਰਾਕਮਾ, ਦਰ) ਫੰਕਸ਼ਨ ਲਈ [ਭਾਸ਼ਾ/ਫਰੇਮਵਰਕ] ਯੂਨਿਟ ਟੈਸਟ ਲਿਖੋ। ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ: ਨਤੀਜਾ = ਰਕਮ * ਦਰ, 2 ਦਸ਼ਮਲਵ ਤੱਕ ਗੋਲ; ਨਕਾਰਾਤਮਕ ਰਕਮ ਜਾਂ ਦਰ ਇੱਕ ਤਰੁੱਟੀ ਸੁੱਟਦੀ ਹੈ; ਰਿਟਰਨ 0 ਜੇਕਰ ਦਰ 0 ਹੈ। AAA ਬਣਤਰ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਹੱਥੀਂ ਗਣਨਾ ਕਰੋ। ਸੰਭਾਵਿਤ ਫੰਕਸ਼ਨ ਦੇ ਮੌਜੂਦਾ ਨਿਯਮਾਂ ਦੇ ਅਨੁਸਾਰ ਸੰਭਾਵਿਤ ਮੁੱਲਾਂ ਨੂੰ ਵਾਪਸ ਨਾ ਕਰੋ। ਅਤੇ ਨੈਗੇਟਿਵ ਕੇਸ (0, ਨੈਗੇਟਿਵ, ਬਹੁਤ ਵੱਡਾ, ਗੋਲ ਤੋਂ ਲੈ ਕੇ ਦਸ਼ਮਲਵ ਤੱਕ) ਹਰ ਟੈਸਟ ਦੇ ਨਾਮ ਨੂੰ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦਿਓ।

ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ; ਇਹ ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ, ਸੁਤੰਤਰ ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਦੀ ਉਮੀਦ, ਬਣਤਰ ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਦਿੰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਟੈਸਟ ਨਿਯਮ ਦਾ ਸਰਪ੍ਰਸਤ ਬਣ ਜਾਂਦਾ ਹੈ, ਕੋਡ ਦਾ ਸ਼ੀਸ਼ਾ ਨਹੀਂ।

ਯੂਨਿਟ ਟੈਸਟ ਗੁਣਵੱਤਾ ਸਾਰਣੀ

ਲੱਛਣ

ਮਾੜਾ ਟੈਸਟ (ਜਾਅਲੀ-ਭਰੋਸਾ)

ਚੰਗਾ ਟੈਸਟ

ਦਾਅਵਾ

ਕੋਈ ਨਹੀਂ ਜਾਂ "ਨਲ ਨਹੀਂ"

ਉਮੀਦ ਕੀਤੀ ਠੋਸ ਮੁੱਲ

ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਸਰੋਤ

ਫੰਕਸ਼ਨ ਦਾ ਆਉਟਪੁੱਟ

ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ / ਦਸਤੀ ਗਣਨਾ

ਨਸ਼ਾ

ਅਸਲ DB/ਨੈੱਟਵਰਕ/ਘੰਟਾ

ਨਕਲੀ/ਸਟੱਬ ਨਾਲ ਇੰਸੂਲੇਟ ਕੀਤਾ ਗਿਆ

ਕਿਨਾਰੇ ਕੇਸ

ਸਿਰਫ ਖੁਸ਼ਹਾਲ ਸੜਕ

ਸੀਮਾ, ਨਕਾਰਾਤਮਕ, ਗਲਤੀ

ਜਦੋਂ ਤੁਸੀਂ ਕੋਡ ਤੋੜਦੇ ਹੋ

ਹਰਾ ਰਹਿੰਦਾ ਹੈ

ਲਾਲ ਹੋ ਜਾਂਦਾ ਹੈ

ਨਾਮ

ਟੈਸਟ1, ਟੈਸਟ ਵਿਧੀ

ਉਸ ਨਿਯਮ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ ਜਿਸਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ

1) ਨਿਯਮ-ਸੰਚਾਲਿਤ ਯੂਨਿਟ ਟੈਸਟਿੰਗ:

ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਸੀਨੀਅਰ ਸਾਫਟਵੇਅਰ ਟੈਸਟ ਇੰਜੀਨੀਅਰ। [ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ] ਦੇ ਨਾਲ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ 'ਤੇ ਇਕ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖੋ: [ਦਸਤਖਤ]। ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ: [ਨਿਯਮ]।- ਏਏਏ ਢਾਂਚੇ ਦੀ ਵਰਤੋਂ ਕਰੋ।- ਇਹਨਾਂ ਨਿਯਮਾਂ ਦੇ ਅਨੁਸਾਰ ਹੱਥੀਂ ਅਨੁਮਾਨਿਤ ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਕਰੋ; ਫੰਕਸ਼ਨ ਦੇ ਮੌਜੂਦਾ ਆਉਟਪੁੱਟ ਦਾ ਹਵਾਲਾ ਨਾ ਦਿਓ। - ਵੱਖਰੇ ਟੈਸਟਾਂ ਨਾਲ ਸੀਮਾ, ਨਕਾਰਾਤਮਕ, ਗਲਤੀ ਅਤੇ ਖੁਸ਼ਹਾਲ ਮਾਰਗ ਨੂੰ ਕਵਰ ਕਰੋ। - ਹਰੇਕ ਟੈਸਟ ਦੇ ਨਾਮ ਨੂੰ ਉਸ ਨਿਯਮ ਦਾ ਵਰਣਨ ਕਰਨ ਦਿਓ ਜਿਸਦੀ ਇਹ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ। - ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦਾ ਮਖੌਲ; ਅਸਲ ਤਰਕ ਦਾ ਕੰਮ ਕਰੋ।

2) ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਰੋਧ ਨਿਯੰਤਰਣ:

ਇਹਨਾਂ ਯੂਨਿਟ ਟੈਸਟਾਂ ਦੀ ਜਾਂਚ ਕਰੋ। 5 ਮਾਮੂਲੀ ਟਵੀਕਸ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਮੈਂ ਟੈਸਟ ਅਧੀਨ ਕੋਡ ਵਿੱਚ ਕਰ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ (a - a + ਦੀ ਬਜਾਏ, a >= a > ਦੀ ਬਜਾਏ, ਇੱਕ ਸੀਮਾ ਸ਼ਿਫਟ) ਅਤੇ ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਹੜਾ ਟੈਸਟ ਲਾਲ ਹੋ ਜਾਵੇਗਾ? ਜੇਕਰ ਕੋਈ ਵੀ ਵਾਪਸ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਟੈਸਟ ਨਾਕਾਫ਼ੀ ਹੈ। ਕੋਡ + ਟੈਸਟ: [ਪੇਸਟ]

3) ਟੈਸਟਯੋਗਤਾ ਸਮੀਖਿਆ:

ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖਣਾ ਮੁਸ਼ਕਲ ਕਿਉਂ ਹੈ? ਛੁਪਿਆ ਨਸ਼ਾ, ਗਲੋਬਲ ਸਟੇਟਸ, ਸਾਈਡ ਇਫੈਕਟ, ਕੀ ਬਹੁਤ ਸਾਰੀਆਂ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਹਨ? ਇਸ ਨੂੰ ਟੈਸਟ ਕਰਨ ਯੋਗ ਬਣਾਉਣ ਲਈ ਘੱਟੋ-ਘੱਟ ਰੀਫੈਕਟਰਿੰਗ ਦਾ ਸੁਝਾਅ ਦਿਓ; ਵਿਹਾਰ ਨਾ ਬਦਲੋ। ਕੋਡ: [ਪੇਸਟ]

4) ਅਧੂਰਾ ਦ੍ਰਿਸ਼ ਪੂਰਾ ਹੋਣਾ:

ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਅਤੇ ਉਪਲਬਧ ਟੈਸਟ ਦਿੱਤੇ ਗਏ ਹਨ। ਸੂਚੀ ਬਣਾਓ ਕਿ ਕਿਹੜੇ ਵਿਹਾਰ/ਐਜਕੇਸ ਦੀ ਕਦੇ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਗਈ (ਸਕੋਪ ਗੈਪ) ਅਤੇ ਹਰੇਕ ਲਈ ਇੱਕ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ। ਫੰਕਸ਼ਨ + ਟੈਸਟ: [ਪੇਸਟ]

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - ਕੋਡ ਨੂੰ ਮਿਰਰਿੰਗ ਦੀ ਜਾਂਚ ਕਰੋ। ਇੱਕ ਡਿਵੈਲਪਰ ਨੇ AI ਨੂੰ ਰਾਊਂਡਿੰਗ ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਟੈਸਟ ਲਿਖਣਾ ਸੀ; 10 ਟੈਸਟ ਹਰੇ ਸਨ। ਅਸਲ ਵਿੱਚ, ਫੰਕਸ਼ਨ ਗਲਤ ਦਿਸ਼ਾ ਵਿੱਚ ਰਾਊਂਡਿੰਗ ਕਰ ਰਿਹਾ ਸੀ, ਪਰ AI ਨੇ ਫੰਕਸ਼ਨ ਦੇ ਆਉਟਪੁੱਟ ਤੋਂ ਸੰਭਾਵਿਤ ਮੁੱਲ ਲਏ ਸਨ, ਇਸਲਈ ਟੈਸਟਾਂ ਨੇ ਗਲਤੀ ਨੂੰ "ਸਹੀ" ਮੰਨਿਆ। ਜਦੋਂ "ਨਿਯਮ-ਸੰਚਾਲਿਤ" ਟੈਮਪਲੇਟ ਨਾਲ ਸੰਭਾਵਿਤ ਮੁੱਲਾਂ ਦੀ ਦਸਤੀ ਗਣਨਾ ਕੀਤੀ ਗਈ ਸੀ, ਤਾਂ 4 ਟੈਸਟ ਲਾਲ ਹੋ ਗਏ ਸਨ ਅਤੇ ਅਸਲ ਗਲਤੀ ਸਾਹਮਣੇ ਆਈ ਸੀ।

ਕੇਸ 2 - ਪਰਿਵਰਤਨ ਨਿਯੰਤਰਣ ਦਾ ਮੁੱਲ। ਇਕ ਟੀਮ ਨੇ 45 ਯੂਨਿਟ ਟੈਸਟਾਂ 'ਤੇ ਭਰੋਸਾ ਕੀਤਾ। "ਮਿਊਟੇਸ਼ਨ ਮਜਬੂਤਤਾ ਜਾਂਚ" ਦੇ ਨਾਲ ਕੋਡ ਵਿੱਚ 20 ਛੋਟੇ ਸੁਧਾਰਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ; ਟੈਸਟਾਂ ਵਿੱਚ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਸਿਰਫ 11 ਹੀ ਫੜੇ ਗਏ। ਬਾਕੀ 9 ਰੁਕਾਵਟਾਂ ਚੁੱਪਚਾਪ ਲੰਘ ਗਈਆਂ। ਟੀਮ ਨੇ ਕਮਜ਼ੋਰ ਟੈਸਟਾਂ ਨੂੰ ਮਜ਼ਬੂਤ ​​ਕੀਤਾ; ਅਗਲੀ ਰੀਲੀਜ਼ ਵਿੱਚ ਇਹਨਾਂ ਵਿਸਤ੍ਰਿਤ ਟੈਸਟਾਂ ਦੁਆਰਾ ਇੱਕ ਅਸਲ ਗਣਨਾ ਗਲਤੀ ਫੜੀ ਗਈ ਸੀ।

ਕੇਸ 3 - ਅਸਥਿਰਤਾ ਇੱਕ ਡਿਜ਼ਾਈਨ ਦੀ ਗੰਧ ਹੈ। AI ਆਰਡਰਿੰਗ ਫੰਕਸ਼ਨ ਲਈ ਟੈਸਟ ਨਹੀਂ ਲਿਖ ਸਕਦਾ ਸੀ, ਇਸ ਨੂੰ ਲਗਾਤਾਰ ਅਸਲ ਡਾਟਾਬੇਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। "ਟੈਸਟੇਬਿਲਟੀ ਸਮੀਖਿਆ" ਟੈਂਪਲੇਟ ਨੇ ਦਿਖਾਇਆ ਕਿ ਫੰਕਸ਼ਨ ਨੇ ਡੇਟਾਬੇਸ ਪਹੁੰਚ ਨੂੰ ਏਮਬੈਡ ਕੀਤਾ ਹੈ। ਜਦੋਂ ਨਿਰਭਰਤਾ ਟੀਕਾ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਸੀ, ਤਾਂ ਟੈਸਟ ਲਿਖੇ ਜਾ ਸਕਦੇ ਸਨ ਅਤੇ ਕੋਡ ਸਾਫ਼ ਹੋ ਗਿਆ ਸੀ।

ਆਮ ਗਲਤੀਆਂ

• ਕੋਡ ਤੋਂ ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨਾ। AI ਫੰਕਸ਼ਨ ਆਉਟਪੁੱਟ ਨੂੰ "ਸਹੀ" ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ; ਟੈਸਟ ਜੋ ਨੁਕਸਦਾਰ ਕੋਡ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ।
• ਬਿਨਾਂ ਕਿਸੇ ਦਾਅਵੇ ਦੇ ਜਾਂ ਮਾਮੂਲੀ ਦਾਅਵੇ ਨਾਲ ਟੈਸਟ ਕਰੋ। "ਉਸਨੇ ਗਲਤੀ ਨਹੀਂ ਕੀਤੀ, ਉਹ ਪਾਸ ਹੋਇਆ" ਤਰਕ; ਇਹ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕਰਦਾ.
• ਅਤਿ ਮਜ਼ਾਕ। ਹਰ ਚੀਜ਼ ਦਾ ਮਜ਼ਾਕ ਉਡਾਉਂਦੇ ਹੋਏ ਅਤੇ ਸਿਰਫ ਇਹ ਪਰਖਣਾ ਕਿ ਮਖੌਲ ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ; ਅਸਲ ਤਰਕ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।
• ਬਸ ਖੁਸ਼ਹਾਲ ਸੜਕ. ਸੀਮਾ, ਨਕਾਰਾਤਮਕ ਅਤੇ ਗਲਤੀ ਸਥਿਤੀਆਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨਾ।
• ਕੋਡ ਨੂੰ ਤੋੜ ਕੇ ਟੈਸਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਰਿਹਾ। ਪਰਿਵਰਤਨ ਦੀ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਹਰੇ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ।
• ਅਸਥਿਰਤਾ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ. ਸਖ਼ਤ ਟੈਸਟਿੰਗ ਨੂੰ ਧੱਕਣ ਦੀ ਬਜਾਏ ਮਾੜੇ ਡਿਜ਼ਾਈਨ ਨੂੰ ਪਛਾਣਨਾ ਅਤੇ ਠੀਕ ਨਹੀਂ ਕਰਨਾ।

ਸੰਖੇਪ ਵਿੱਚ

ਯੂਨਿਟ ਟੈਸਟ ਟੈਸਟਿੰਗ ਪਿਰਾਮਿਡ ਦੀ ਸਭ ਤੋਂ ਤੇਜ਼ ਅਤੇ ਸਭ ਤੋਂ ਵੱਡੀ ਪਰਤ ਹਨ; ਇਹ ਸਭ ਤੋਂ ਸਸਤੇ ਪਲ 'ਤੇ ਗਲਤੀ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ. AI ਯੂਨਿਟ ਟੈਸਟਾਂ ਦਾ ਉਤਪਾਦਨ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਰੱਥ ਹੈ, ਪਰ ਇਸਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਨੁਕਸਾਨ ਟੈਸਟਾਂ ਨੂੰ ਲਿਖਣਾ ਹੈ ਜੋ ਕੋਡ ਤੋਂ ਹੀ ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਕੇ ਗਲਤ ਵਿਵਹਾਰ ਨੂੰ "ਸਹੀ" ਮੰਨਦੇ ਹਨ। ਹੱਲ: ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ ਦਿਓ, ਸੰਭਾਵਿਤ ਮੁੱਲਾਂ ਦੀ ਹੱਥੀਂ ਗਣਨਾ ਕਰੋ, AAA ਅਤੇ FIRST ਸਿਧਾਂਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਬਾਹਰੀ ਦੁਨੀਆ ਦਾ ਮਜ਼ਾਕ ਉਡਾਓ ਅਤੇ ਅਸਲ ਤਰਕ ਚਲਾਓ, ਅਤੇ ਪਰਿਵਰਤਨ (ਕੋਡ ਨੂੰ ਤੋੜਨਾ) ਦੁਆਰਾ ਹਰੇਕ ਟੈਸਟ ਦੀ ਜਾਂਚ ਕਰੋ। ਕੋਡ ਜਿਸਦੀ ਜਾਂਚ ਕਰਨਾ ਔਖਾ ਹੈ ਇੱਕ ਡਿਜ਼ਾਈਨ ਚਿੰਨ੍ਹ ਹੈ ਜਿਸਨੂੰ ਫਿਕਸਿੰਗ ਦੀ ਲੋੜ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਇੱਕ ਫੰਕਸ਼ਨ ਚੁਣੋ ਜਿਸ ਵਿੱਚ ਤੁਹਾਡੇ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚੋਂ ਇੱਕ ਵਪਾਰਕ ਨਿਯਮ ਸ਼ਾਮਲ ਹੋਵੇ। ਸਵੀਕ੍ਰਿਤੀ ਦੇ ਨਿਯਮ ਲਿਖੋ ਅਤੇ "ਨਿਯਮ-ਸੰਚਾਲਿਤ ਯੂਨਿਟ ਟੈਸਟਿੰਗ" ਟੈਮਪਲੇਟ ਨਾਲ AI ਲਿਖਤੀ ਟੈਸਟ ਕਰਵਾਓ; ਸੰਭਾਵਿਤ ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਹੱਥੀਂ ਕਰੋ। ਫਿਰ "ਮਿਊਟੇਸ਼ਨ ਮਜਬੂਤਤਾ ਜਾਂਚ" ਨੂੰ ਲਾਗੂ ਕਰੋ: ਕੋਡ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ 5 ਛੋਟੇ ਬ੍ਰੇਕ ਬਣਾਓ ਅਤੇ ਮਾਪੋ ਕਿ ਕਿੰਨੇ ਟੈਸਟ ਲਾਲ ਹੋ ਗਏ ਹਨ। ਅਣਪਛਾਤੇ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਲਈ ਨਵਾਂ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ। ਰਿਪੋਰਟ ਕਰੋ ਕਿ ਕਿੰਨੇ ਵਿਘਨ ਫੜੇ ਗਏ ਸਨ (ਜਿਵੇਂ ਕਿ ਮਿਊਟੇਸ਼ਨ ਸਕੋਰ)।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਸਵੀਕ੍ਰਿਤੀ ਨਿਯਮ ਦਿੱਤੇ ਹਨ ਅਤੇ ਸੰਭਾਵਿਤ ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਹੱਥੀਂ ਕੀਤੀ ਹੈ।
• [ ] ਮੈਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਕਿ ਟੈਸਟਾਂ ਨੇ ਕੋਡ ਤੋਂ ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕੀਤਾ ਹੈ।
• [ ] ਮੈਂ AAA ਅਤੇ FIRST ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋਏ ਸੁਤੰਤਰ ਜਾਂਚ ਦੀ ਸਥਾਪਨਾ ਕੀਤੀ ਹੈ।
• [ ] ਮੈਂ ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦਾ ਮਜ਼ਾਕ ਉਡਾਇਆ ਅਤੇ ਅਸਲ ਤਰਕ ਚਲਾਇਆ।
• [ ] ਮੈਂ ਸੀਮਾ, ਨਕਾਰਾਤਮਕ ਅਤੇ ਗਲਤੀ ਦੇ ਕੇਸਾਂ ਨੂੰ ਕਵਰ ਕੀਤਾ।
• ਕੋਡ (ਮਿਊਟੇਸ਼ਨ) ਨੂੰ ਤੋੜ ਕੇ ਮੈਂ ਸਾਬਤ ਕੀਤਾ ਕਿ ਟੈਸਟ ਅਸਲ ਵਿੱਚ ਸੁਰੱਖਿਆ ਕਰਦੇ ਹਨ।