๋จ์ ํ ์คํธ ์ข ๋ฅ
์ ํ ์คํธ์ ๊ฐ ์ ํ์ ์ข ๋ ์์ธํ๊ฒ ์ค๋ช ํ๊ณ , ๊ฐ ์ ํ์ด ์ด๋ค ๋ฌธ์ ๋ฅผ ์ก๊ธฐ ์ํด ์ฌ์ฉ๋๋์ง, ๊ทธ๋ฆฌ๊ณ ๊ฐ๊ฐ์ ๋ํ ๊น๋ํ ์ฝ๋ ์์ ๋ฅผ ์ ๊ณตํ๊ฒ ๋ค. ์ฌ๊ธฐ์๋ ๊ฐ๋จํ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๋จ์ ํ ์คํธ์ ๋ํด ์ค๋ช ํ๋ค.
โญ 1. ๋์ ํจ์
// calculateDiscount ํจ์๋ ๊ตฌ๋งค ๊ธ์ก(amount)์ ๋ฐ๋ผ ํ ์ธ์จ์ ์ ์ฉํจ.
// 100 ์ด์์ผ ๋๋ 10% ํ ์ธ, 50 ์ด์ 100 ๋ฏธ๋ง์ผ ๋๋ 5% ํ ์ธ, ๊ทธ ์ธ์๋ ํ ์ธ ์์.
double calculateDiscount(double amount) {
if (amount >= 100) return amount * 0.9;
else if (amount >= 50) return amount * 0.95;
else return amount;
}
โญ 2. Positive UT
๊ธ์ ํ ์คํธ๋ ํจ์๊ฐ ์ฌ๋ฐ๋ฅธ ์ ๋ ฅ์ ๋ํด ์์๋ ๋์์ ์ํํ๋์ง ํ์ธํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ์ด๋ ๊ธฐ๋ณธ์ ์ผ๋ก ํจ์์ "์ ์์ ์ธ" ์ฌ์ฉ ์ฌ๋ก๋ฅผ ํ ์คํธํ๋ค.
void testCalculateDiscountPositive() {
assert(calculateDiscount(150) == 135); // 100 ์ด์์ ๊ธ์ก์ ๋ํด 10% ํ ์ธ์ด ์ ์ฉ๋์ด์ผ ํจ.
assert(calculateDiscount(75) == 71.25); // 50 ์ด์ 100 ๋ฏธ๋ง์ ๊ธ์ก์ ๋ํด 5% ํ ์ธ์ด ์ ์ฉ๋์ด์ผ ํจ.
assert(calculateDiscount(25) == 25); // 50 ๋ฏธ๋ง์ ๊ธ์ก์๋ ํ ์ธ์ด ์ ์ฉ๋์ง ์์์ผ ํจ.
printf("Positive tests passed.\n");
}
โญ 3. Negative UT
๋ถ์ ํ ์คํธ๋ ํจ์๊ฐ ์๋ชป๋ ์ ๋ ฅ์ด๋ ์์ธ์ ์ธ ์ํฉ์ ์ ์ ํ๊ฒ ์ฒ๋ฆฌํ๋์ง ํ์ธํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ์ด๋ ํจ์์ ์ค๋ฅ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ํ ์คํธํ๋ค.
void testCalculateDiscountNegative() {
// ์ด ํจ์๋ ์๋ชป๋ ์
๋ ฅ์ ๋ํ ์์ธ ์ฒ๋ฆฌ๋ฅผ ๊ตฌํํ์ง ์์๊ธฐ ๋๋ฌธ์, ์๋์ ์ผ๋ก ์ค๋ฅ ์ํฉ์ ๋ง๋ค์ด ๋ณผ ์ ์์.
// ๋ง์ฝ calculateDiscount ํจ์๊ฐ ์์ ์
๋ ฅ์ ๋ํด ์๋ฌ๋ฅผ ๋ฐํํ๋๋ก ์ค๊ณ๋์๋ค๋ฉด, ๊ทธ๊ฒ์ ํ
์คํธํ๋ ์ฝ๋๊ฐ ์ฌ๊ธฐ์ ์์นํ ๊ฒ์.
}
โญ 4. Boundary UT
๊ฒฝ๊ณ ํ ์คํธ๋ ์ ๋ ฅ ๊ฐ์ด๋ ์ถ๋ ฅ ๊ฐ์ด ๊ฒฝ๊ณ์ ์์นํ ๋ ํจ์์ ๋์์ ๊ฒ์ฆํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ์ด๋ ํจ์๊ฐ ๊ฒฝ๊ณ ์กฐ๊ฑด์์๋ ์ฌ๋ฐ๋ฅด๊ฒ ๋์ํ๋์ง ํ์ธํ๋ค.
void testCalculateDiscountBoundary() {
assert(calculateDiscount(100) == 90); // ์ ํํ 100์ธ ๊ฒฝ์ฐ, 10% ํ ์ธ์ด ์ ์ฉ๋์ด์ผ ํจ.
assert(calculateDiscount(50) == 47.5); // ์ ํํ 50์ธ ๊ฒฝ์ฐ, 5% ํ ์ธ์ด ์ ์ฉ๋์ด์ผ ํจ.
assert(calculateDiscount(49.99) == 49.99); // 50 ๋ฏธ๋ง์ ๊ฒฝ๊ณ๊ฐ์์ ํ ์ธ์ด ์ ์ฉ๋์ง ์์์ผ ํจ.
printf("Boundary tests passed.\n");
}
โญ 5. Equivalence Partitioning UT
๋๋ฑ ๋ถํ ํ ์คํธ๋ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ ํจํ ๊ฐ์ ์งํฉ(ํ ์ธ์ด ์ ์ฉ๋๋ ๊ธ์ก ๋ฒ์)๊ณผ ์ ํจํ์ง ์์ ๊ฐ์ ์งํฉ(ํ ์ธ์ด ์ ์ฉ๋์ง ์๋ ๊ธ์ก ๋ฒ์)์ผ๋ก ๋๋๋ค. ์ฌ๊ธฐ์๋ ๋ชจ๋ ์ ๋ ฅ์ด ์ ํจํ๋ฏ๋ก, ํ ์ธ์จ์ด ์ ์ฉ๋๋ ๋ฒ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋ ์ ์๋ค.
void testCalculateDiscountEquivalence() {
assert(calculateDiscount(25) == 25); // ํ ์ธ ์์
assert(calculateDiscount(75) == 71.25); // 5% ํ ์ธ ์ ์ฉ
assert(calculateDiscount(150) == 135); // 10% ํ ์ธ ์ ์ฉ
printf("Equivalence partitioning tests passed.\n");
}
โญ 6. Min/Max Unit Test
๊ฒฝ๊ณ ํ ์คํธ๋ ํ ์ธ์จ ๋ณ๊ฒฝ์ ๊ทผ์ฒ์ ๊ฐ๋ค์ ํ ์คํธํ๋ค. ๋ํ, Min/Max ํ ์คํธ๋ก๋ ๊ตฌ๋งค ๊ธ์ก์ ํฉ๋ฆฌ์ ์ธ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ๊ณ ๋ คํ ์ ์๋ค.
void testCalculateDiscountBoundary() {
assert(calculateDiscount(0) == 0); // ์ต์๊ฐ ํ
์คํธ
assert(calculateDiscount(1000) == 900); // ์์๋ก ๋ ์ต๋๊ฐ ํ
์คํธ
printf("Boundary and Min/Max tests passed.\n");
}
โญ 7. Fault Injection Unit Test
๊ณ ์์ ์ผ๋ก ํจ์์ ์๋ชป๋ ๊ฐ์ ์ฃผ์ ํ์ฌ, ํจ์๊ฐ ์์ธ ์ํฉ์ ์ ์ ํ ์ฒ๋ฆฌํ๋์ง ํ์ธํ๋ ํ ์คํธ์ด๋ค. calculateDiscount ํจ์์ ๊ฒฝ์ฐ, ์์ ๊ธ์ก์ ์ฒ๋ฆฌํ๋ ๋ฅ๋ ฅ์ ํ ์คํธํ ์ ์๋ค. ํ์ง๋ง ํ์ฌ ํจ์ ๊ตฌํ์์๋ ์์ ์ ๋ ฅ์ ๋ํ ๋ช ์์ ์ฒ๋ฆฌ๊ฐ ์์ผ๋ฏ๋ก, ์ด ์์ ๋ ํจ์๊ฐ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋๋ก ์ค๊ณ๋ ์ํฉ์ ๊ฐ์ ํ๊ณ ์์ฑ๋๋ค.
void testCalculateDiscountFaultInjection() {
// ๊ฐ์ : ์์ ๊ธ์ก์ ๋ํด์๋ 0์ ๋ฐํํ๋๋ก ํจ์๊ฐ ์์ ๋์๋ค๊ณ ๊ฐ์
assert(calculateDiscount(-50) == 0); // ์๋ชป๋ ์
๋ ฅ ์ฒ๋ฆฌ ํ
์คํธ
printf("Fault injection tests passed.\n");
}
์ค์ ๊ฐ๋ฐ ํ๊ฒฝ์์๋ ์ด๋ฌํ ํ ์คํธ๋ค์ ํตํด ํจ์์ ๋ค์ํ ์ธก๋ฉด์ ๊ฒ์ฆํ์ฌ, ์ค๋ฅ ๊ฐ๋ฅ์ฑ์ ์ค์ด๊ณ ์ฝ๋์ ์ ๋ขฐ์ฑ์ ๋์ผ ์ ์๋ค. Fault Injection์ ๊ฒฝ์ฐ, ์ค์ ๊ตฌํ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ ์ฉ๋ ์ ์์ผ๋ฉฐ, ํจ์๊ฐ ์์ธ ์ํฉ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์๋๋ก ๋ณด์ฅํ๋ ์ค์ํ ๋ฐฉ๋ฒ ์ค ํ๋์ด๋ค.
'๐ท C์ธ์ด 30๊ฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C/C++ Tip] 29. C์ธ์ด Unit Test (0) | 2024.11.12 |
---|---|
[C/C++ Tip] 28. C์ธ์ด ํฌ์ธํฐ์ ๋ค์ํ ํํ๋ค (0) | 2024.11.11 |
[C/C++ Tip] 27. C์ธ์ด ๋ฐ์ดํฐ ํ์ ๋ฒ์ (0) | 2024.11.11 |
[C/C++ Tip] 26. Char, String ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ (1) | 2024.11.10 |
[C/C++ Tip] 25. C์ธ์ด 2์ฐจ์ ๋ฐฐ์ด (0) | 2024.11.10 |