๊ณต์ ํํ์ด์ง์ ์๋ 2020 ์ ๋ฌธ๊ฐ ํน๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ํ์ฏ ๋๋น


1๋ฒ. ์ด์ง ํ์ ํธ๋ฆฌ

- ๊ฐ ๋ ธ๋์๋ ์ค๋ณต๋์ง ์๋ key๊ฐ ์๋ค.
- ๋ฃจํธ ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ๋ ํด๋น ๋ ธ๋์ key๋ณด๋ค ์์ key๋ฅผ ๊ฐ๋ ๋ ธ๋๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ๋ฃจํธ ๋ ธ๋์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ๋ํด๋น ๋ ธ๋์ key๋ณด๋ค ํฐ key๋ฅผ ๊ฐ๋ ๋ ธ๋๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ์ข์ฐ ์๋ธํธ๋ฆฌ๋ ๋ชจ๋ ์ด์ง ํ์ ํธ๋ฆฌ์ด๋ค.
+ ์์ ์ด์ง ํธ๋ฆฌ
- ๋ชจ๋ ์๋ธํธ๋ฆฌ์ ๋ ๋ฒจ์ด ๊ฐ๊ณ , ๋ชจ๋ ๋ ธ๋๋ค์ด ๋ ๋ฒจ๋ณ๋ก ์ผ์ชฝ๋ถํฐ ์ฑ์์ ธ์๋ ๊ฒฝ์ฐ
2๋ฒ. ํด๋์ค ๋ค์ด์ด๊ทธ๋จ, ์ถ์ ํด๋์ค ์ ์ (JAVA)
<<abstract>> Book |
- Title : String - Author : String |
+ setTitle (title : String): void (abtract) + setAuthor (author : String): void (abtract) |
์์ ํด๋์ค ๋ค์ด์ด๊ทธ๋จ์ JAVA๋ก ์์ฑํ๋ค๋ฉด? โฌ๏ธโฌ๏ธ
public abstract class Book{
private String title;
private String author;
public abstract void setTitle(String title);
public abstract void setAuthor(String author);
}
์ถ๊ฐ์ ์ธ JAVA์ ๊ฐ๋ ๋ค
์์
- ๋ถ๋ชจ๊ฐ ๊ฐ์ง๊ฒ์ ์์์๊ฒ ๋ฌผ๋ ค์ฃผ๋ ๊ฒ์ ์๋ฏธํ๋ค. ๋ถ๋ชจ๊ฐ ๊ฐ๊ณ ์๋ ๊ฒ์ ์์์ด ์ฌ์ฉํ ์ ์๋ค.
- Is - a ๊ด๊ณ ํน์ kind of ๊ด๊ณ
// Bus๋ Car์ด๋ค.
public class Bus extends Car {
public void windows(){
Syetem.out.println("์ฐฝ๋ฌธ");
}
}
์๋ฐ๋ ํด๋์ค ์ด๋ฆ ๋ค์ extends ํค์๋๋ฅผ ์ ๊ณ ๋ถ๋ชจ ํด๋์ค ์ด๋ฆ์ ์ ์ผ๋ฉด ๋ถ๋ชจ ํด๋์ค๊ฐ ๊ฐ๊ณ ์๋ ๊ฒ์ ์์๋ฐ์ ์ ์๊ฒ ๋๋ค.
์๋ก์ด ํด๋์ค๋ฅผ ์ ์ํ ๋, ์ด๋ฏธ ๊ตฌํ๋ ํด๋์ค๋ฅผ ์์๋ฐ์์ ์์ฑ์ด๋ ๊ธฐ๋ฅ์ด ํ์ฅ๋ ํด๋์ค๋ฅผ ๊ตฌํํ๋ค. -> ํ์ฅ ๊ฐ๋ฅ
์ ๊ทผ ์ ํ์
ํด๋์ค ๋ด์์ ๋ฉค๋ฒ์ ์ ๊ทผ์ ์ ํํ๋ ์ญํ ์ ํ๋ค.
public (+) | ์ด๋ค ํด๋์ค์ ๊ฐ์ฒด์์๋ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค. |
protected (#) | ํดํ ํด๋์ค์ ๋์ผํ ํจํค์ง์ ์๊ฑฐ๋ ์์ ๊ด๊ณ์ ์๋ ํ์ ํด๋์ค์ ๊ฐ์ฒด๋ค๋ง ์ ๊ทผ ๊ฐ๋ฅํ๋ค. |
private (-) | ํด๋น ํด๋์ค์์ ์์ฑ๋ ๊ฐ์ฒด๋ง ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค. |
์ ๊ทผ ์ ํ์๋ฅผ ๋ช ์ํ์ง ์๋ default ์ ๊ทผ ์ง์ ์, ์๊ธฐ ์์ ๊ณผ ๊ฐ์ ํจํค์ง์์๋ง ์ ๊ทผํ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธ
์ถ์ํด๋์ค
๊ตฌ์ฒด์ ์ด์ง ์๊ณ ๊ฐ๋ ๋ง ์๋ ํด๋์ค๋ฅผ ์๋ฏธํ๋ค.
- ๋ ์๋ฆฌ, ํ์กฐ : ๊ตฌ์ฒด์ ์ธ ์๋ฅผ ์ง์นญ but ํฌ์ ๋ฅ๋ ๊ตฌ์ฒด์ ์ด์ง ์๋ค.
์ถ์ ํด๋์ค ์ ์ํ๊ธฐ
- ํด๋์ค ์์ abstract ํค์๋๋ฅผ ์ด์ฉํด์ ์ ์ํ๋ค.
- ๋ฏธ์์ฑ์ ์ถ์ ๋ฉ์๋๋ฅผ ํฌํจํ ์ ์๋ค.
- ๋ด์ฉ์ด ์๋ ๋ฉ์๋, ์ฆ ๊ตฌํ์ด ๋์ง ์์ ๋ฉ์๋์ด๋ค.
- return ํ์ ์์ abtract๋ผ๋ ํค์๋๊ฐ ๋ถ์ด์ผ ํ๋ค.
- ์ถ์ ํด๋์ค๋ ์ธ์คํด์ค๋ฅผ ์์ฑํ ์ ์๋ค โ ๊ฐ์ฒด๊ฐ ๋ ์ ์๋ค. newํ ํ ์ ์๋ค.
public abtract class Bird{
public abstract void sing();
public void fly(){
System.out.println("๋ ๋ค.");
}
}
์ถ์ ํด๋์ค๋ฅผ ์์๋ฐ๋ ํด๋์ค ์์ฑํ๊ธฐ
- ์ถ์ ํด๋์ค ๋ด๋ถ์๋ ์ผ๋ฐ ๋ฉ์๋ ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค.
- ์ถ์ ํด๋์ค๋ฅผ ์์๋ฐ์ ํด๋์ค๋ ์ถ์ ํด๋์ค๊ฐ ๊ฐ๊ณ ์๋ ์ถ์ ๋ฉ์๋๋ฅผ ๋ฐ๋์ ๊ตฌํํด์ผํ๋ค.
- ์ถ์ ํด๋์ค๋ฅผ ์์๋ฐ๊ณ , ์ถ์ ํด๋์ค๊ฐ ๊ฐ๊ณ ์๋ ์ถ์ ๋ฉ์๋๋ฅผ ๊ตฌํํ์ง ์์ผ๋ฉด ํด๋น ํด๋์ค๋ ์ถ์ ํด๋์ค๊ฐ ๋๋ค.
public class Duck extends Bird{
@Override
public void sing(){
System.out.println("๊ฝฅ๊ฝฅ!!");
}
}
๊ตฌํ์ ํ์ง ์๊ณ ์ ์ธ๋ง ํ๋ ค๋ฉด abstract๋ฅผ ๋ถ์ฌ์ ์ถ์ ๋ฉ์๋๋ก ๋ง๋ค์ด์ผ ํ๋ค. ๊ตฌํํ๊ฒ์ด ์๋ค๊ณ ์ถ์๋ฉ์๋๊ฐ ์๋๋ค.
ํด๋์คํ๋ณํ
- ๋ถ๋ชจ ํ์ ์ผ๋ก ์์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ฉด ๋ถ๋ชจ๊ฐ ๊ฐ์ง ๋ฉ์๋๋ง ์ฌ์ฉํ ์ ์๋ค.
- ์์ ๊ฐ์ฒด๊ฐ ๊ฐ๊ณ ์๋ ๋ฉ์๋๋ ์์ฑ์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด ํ๋ณํ์ ํด์ผํ๋ค.
public class Car{
public void run(){
System.out.println("Car์ run๋ฉ์๋")
}
}
// ์์์ is a ๊ด๊ณ, Bus๋ Car๋ค.
public class Bus extends Car{
public void ppangppang(){
System.out.println("๋นต๋นต!!")
}
}
- ๋ถ๋ชจ ํ์ ์ผ๋ก ์์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ ์ ์๋ค.
- ๋ถ๋ชจ ํ์ ์ผ๋ก ์์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ฉด ๋ถ๋ชจ๊ฐ ๊ฐ๊ณ ์๋ ๋ฉ์๋๋ง ์ฌ์ฉํ ์ ์๋ค.
public class BusExam{
public static void maind(String args[]){
Car car = new Bus();
car.run();
car.ppangppang(); // ์ปดํ์ผ ์ค๋ฅ ๋ฐ์
}
}
- ppangppang() ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ ์ถ๋ค๋ฉด, Bus ํ์ ์ ์ฐธ์กฐ๋ณ์๋ฅผ ์ฐธ์กฐํด์ผ ํ๋ค.
public class BusExam{
public static void main(String args[]){
Car car = new Bus();
car.run();
// car.ppangppang(); // ์ปดํ์ผ ์ค๋ฅ ๋ฐ์!
Bus bus = (Bus)car; // ๋ถ๋ชจ ํ์
์ ์์ ํ์
์ผ๋ก ํ๋ณํ
bus.run();
bus.ppangppang();
}
}
- ๊ฐ์ฒด๋ค๋ผ๋ฆฌ๋ ํ๋ณํ์ด ๊ฐ๋ฅํ๋ค. ๋จ, ์์ ๊ด๊ณ์ ์์์ ๋๋ง ๊ฐ๋ฅํ๋ค.
- ๋ถ๋ชจ ํ์ ์ผ๋ก ์์ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ ๋๋ ๋ฌต์์ ์ผ๋ก ํ๋ณํ์ด ์ผ์ด๋๋ค.
- ๋ถ๋ชจํ์ ๊ฐ์ฒด๋ฅผ ์์ ํ์ ์ผ๋ก ์ฐธ์กฐํ๊ฒ ํ ๋, ๋ช ์์ ํ๋ณํ์ ํด์ค์ผ ํ๋ค.
- ๋จ, ์ด๋ ๊ฒ ํ๋ณํ์ ์๋ํ ๋, ๋ถ๋ชจ๊ฐ ์ฐธ์กฐํ๋ ์ธ์คํด์ค๊ฐ ํ๋ณํํ๋ ค๋ ์์ ํ์ ์ผ ๋๋ง ๊ฐ๋ฅํ๋ค.
3๋ฒ. Data Flow Diagram (DFD)

- ๋ฐ์ดํฐ์ ํ๋ก์ธ์ค ํ๋ฆ ํํ, ์๋ฃ์ ์ถ๋ฐ์ง์ ๋ชฉ์ ์ง๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํ์ํ ๊ฒ์ด๋ค.
- ์ํํธ์จ์ด์ ์ค๊ณ ๋ฐ ์ ๋ณด์์คํ ์ ๋ถ์์ ์ ์ฉํ๊ฒ ์ฌ์ฉ
- ๋ฐ์ดํฐ ํ๋ฆ๋ or ์๋ฃ ํ๋ฆ๋ ๋ผ๊ณ ๋ ํ๋ค.
๊ตฌ์ฑ์์
- ํ๋ก์ธ์ค (Process), โ ์ (Bubble)
- ์ ๋ ฅ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ํ๋ ๋ฐ์ดํฐ๋ก ๋ณํํด ์ถ๋ ฅํ๊ธฐ ์ํ ๊ณผ์ ์ด๋ค.
- ๋ํ์ ํ๊ธฐ ํํ๋ ์๊ณผ ์ ์์ ์ด๋ฆ์ผ๋ก ํํํ๋ค.
- ์์์ ๊ธฐ๋กํ๋ ์ด๋ฆ์ ํ๋ก์ธ์ค๊ฐ ์ํํ๋ ์ผ ๋๋ ํ๋ก์ธ์ค๋ฅผ ์ํํ๋ ํ์์๋ฅผ ๊ธฐ์ ํ๋ค.
- ์์ฒด์ ์ผ๋ก๋ ๋ฐ์ดํฐ๋ฅผ ์์ฑํ ์ ์๊ณ ํญ์ ์ ๋ ฅ๋๋ ๋ฐ์ดํฐ๊ฐ ์์ด์ผ ํ๋ค.
- ํญ์ ์๋ก์ด ๊ฐ์น๋ฅผ ๋ถ๊ฐํด์ผ ํ๋ค. - ๋ฐ์ดํฐ ํ๋ฆ (Data Flow), โ ํ์ดํ
- DFD์ ๊ตฌ์ฑ์์๊ฐ ์ธํฐํ์ด์ค๋ฅผ ๋ํ๋ธ๋ค.
- ๋๋ถ๋ถ์ ๋ฐ์ดํฐํ๋ฆ์ ํ๋ก์ธ์ค ์ฌ์ด๋ฅผ ์ฐ๊ฒฐํ์ง๋ง, ๋ฐ์ดํฐ ์ ์ฅ์๋ก๋ถํฐ์ ๋ฐ์ดํฐ ํ๋ฆ์ ๋ํ๋ด๊ธฐ๋ ํ๋ค.
- ๋ช ์นญ์ด ๋ถ์ฌ๋๊ฑฐ๋ ๋ถ์ฌ๋์ง ์์ ํ์ดํ๋ก ํ์ํ๋ค. ํ์์์ ์ ์ฐธ์กฐ๋ฅผ ์ํด ๋๋๋ก ๋ช ์นญ์ด ๋ถ์ฌ๋๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค.
- ์๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ์ ํ๋ฆ์๋ ๋์ผํ ์ด๋ฆ์ ๋ถ์ฌํ์ง ์๋๋ค. - ๋ฐ์ดํฐ ์ ์ฅ์ (Data Store), = ๋ ํํ์
- ์ถํ ์์ธ์ค๋ฅผ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋์ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค.
- ์กํฐ์ ๋ฌ๋ฆฌ ์์ ์ ์ก์ ์ ์ทจํ์ง ์์ผ๋ฉฐ ๋ฐ์ดํฐ ์ ์ฅ์ด๋ ์์ธ์ค ์๊ตฌ์ ๋ฐ์ํ ๋ฟ์ด๋ค.
- ์ ์ฅ๋์ด์๋ ์ ๋ณด์ ์งํฉ์ ์๋ฏธํ๋ค.
- ๋จ์ํ ๋ฐ์ดํฐ์ ์ ์ฅ์ ๋ํ๋ด๋ ๊ฒ์ด์ง ๋ฐ์ดํฐ์ ๋ณ๋์ ํ์ํ๋ ๊ฒ์ ์๋๋ค.
- ๋ฐ์ดํฐ ํ๋ฆ์ ํ์ํจ์ผ๋ก์ ๋ฐ์ดํฐ์ ์ ์ถ๋ ฅ์ ๋ํ๋ธ๋ค.
- ๋ ๊ฐ์ ํํํ ์ง์ ์ผ๋ก ๋ํ๋ด๊ณ , ํํ์ ์์ ๋ฐ์ดํฐ ์ ์ฅ์์ ๋ช ์นญ์ ๋ถ์ฌํ๋ค. - ์ธ๋ถ์ํฐํฐ (External Entity), โก
- ํ๋ก์ธ์ค ์ฒ๋ฆฌ๊ณผ์ ์ ๋ฐ์ดํฐ๋ฐ์์ ์์ ๋ฐ ์ข ๋ฃ๋ฅผ ๋ํ๋ธ๋ค.
- ๊ธฐ์ ๋ด์ ์ธ(inside) ์ํฐํฐ๋ ๊ด๋ฆฌ, ๋ถ์, ๊ธฐ๋ฅ, ์์คํ ๋ฑ์ ํฌํจํ๋ฉฐ, ๊ธฐ์ ์ธ์ ์ธ(outside) ์ํฐํฐ๋ ๊ณ ๊ฐ, ๊ฑฐ๋์ฒ, ๊ณต๊ณต๊ธฐ๊ด, ์ธ๋ถ์์คํ ๋ฑ์ ํฌํจํ๋ค.
- ๋ฐ์ดํฐ ํ๋ฆ๋์์์ ํ๋ก์ธ์ค์์ ์ํธ ๊ด๋ จ์ฑ์ ํ์ํ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก DFD ๋ฒ์ ๋ฐ์์ ์ฌ๊ฐํ์ ํํ๋ก ํ์ํ๋ค.
- ์กํฐ๋ ๋ฐ์ดํฐ๋ฅผ ์์ฑ, ์๋น ํจ์ผ๋ก์ ๋ฐ์ดํฐ ํ๋ฆ๋๋ฅผ ์ฃผ๋ํ๋ ํ์ฑ ๊ฐ์ฒด์ด๋ค.
- ์กํฐ๋ ๋ฐ์ดํฐ ํ๋ฆ๋์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋ถ๋๋ค. ํ๋ฆ๋์ ๊ฒฝ๊ณ์ ๋์ด๊ฒ ๋๋ฉฐ ์์ค(source)๋ ์ฑํฌ(sink)๋ก์ ๋ฐ์ดํฐ์ ํ๋ฆ์ ์ค๋จ์ํจ๋ค.
DFD ์์ฑ ๋ฐฉ๋ฒ
- ์ ๋ฌด๋ฅผ ๋ถ์ํ์ฌ ํ๋ก์ธ์ค์ ๋ํ ๋ชจ๋ ์ ์ถ๋ ฅ ๋ฐ์ดํฐํ๋ฆ์ ์๋ณํ๋ค.
- ํ๋ฆ์ ํ์ํ๊ฑฐ๋ ์ ๊ณต๋์ด์ผ ํ ์ธ๋ถ์ํฐํฐ๋ฅผ ์ ์ํ๋ค.
- ์ ๋ ฅ์ผ๋ก๋ถํฐ ์ถ๋ ฅ์ผ๋ก, ์ถ๋ ฅ์ผ๋ก๋ถํฐ ์ ๋ ฅ์ผ๋ก, ๋๋ ์ค๊ฐ ์ง์ ๋ถํฐ์ ๋ฐ์ดํฐ ํ๋ฆ์ ์๋ณํ๋ค.
- ๋ชจ๋ ์ ์๊ด๊ณ ๋ฐ์ดํฐํ๋ฆ์ ์ฃผ์๊น๊ฒ ๋ช ์นญ(ํน์ ์๋ฃ๋ด์ญ)์ ๋ถ์ฌํ๋ค.
- ํ๋ก์ธ์ค์ ๋ํด ์ ์ถ๋ ฅ ๋ฐ์ดํฐํ๋ฆ์ ๋ช ์นญ์ ๋ฐ๋ผ ์ด๋ฆ์ ๋ถ์ฌํ๋ค.
- ํ๋ก์ธ์ค์ ๊ด๋ จ๋ ๋ฐ์ดํฐ์ ์ฅ์๋ฅผ ์ ์ํ๋ค.
- ๊ฒํ ํ๊ณ ๋ณด์ํ๋ค.
- ์์๋ ๋ฒจ DFD ์์ฑ ํ ํ์๋ ๋ฒจ์ DFD๋ก ๋ถํ ํด ์ตํ์ ๋ ๋ฒจ๊น์ง ๊ทธ๋ฆฌ๋๋ฐ ์ผ๋ฐ์ ์ผ๋ก 3๋ฒ ๋ฐ๋ณตํ๋ค.
4๋ฒ. ์ํํธ์จ์ด์ ๊ฒฐํฉ๋(coupling), ์์ง๋(cohension)
๋ชจ๋ํ(Modularization)
- ์ํํธ์จ์ด๋ฅผ ๊ฐ ๊ธฐ๋ฅ๋ณ๋ก ๋๋๋ ๊ฒ
- ํ๋ก๊ทธ๋จ์ด ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌ๋ ์ ์๋๋ก ์์คํ ์ ๋ถํดํ๊ณ ์ถ์ํํจ์ผ๋ก์จ ์ํํธ์จ์ด ์ ํ์ ์ฑ๋ฅ์ ํฅ์์ํค๊ฑฐ๋ ์์คํ ์ ์์ ๋ฐ ์ฌ์ฌ์ฉ, ์ ์ง ๊ด๋ฆฌ๋ฅผ ์ฉ์ดํ๊ฒ ํ๋ ๊ธฐ๋ฒ
๋ชจ๋(Module)
- ๊ธฐ๋ฅ๋ณ๋ก ๋๋ ์ง ๋ชจ๋ํ์ ๊ฒฐ๊ณผ
- ์ํํธ์จ์ด ๋ด์ ํ๋ก๊ทธ๋จ ๋๋ ์์ ๋จ์, ์ผ์ข ์ ์๋ธ๋ฃจํด(subroutine)
๋ ๋ฆฝ์ฑ
- ๋ชจ๋์ ์ฃผ์ด์ง ๊ธฐ๋ฅ๋ง์ ๋ ๋ฆฝ์ ์ผ๋ก ์ํํ๋ฉฐ ๋ค๋ฅธ ๋ชจ๋๊ณผ ์ ๊ฒ ์ฐ๊ด๋์ด์ผ ํจ.
- ๋ชจ๋์ ๊ฒฐํฉ๋์ ์์ง๋๋ก ๋ ๋ฆฝ์ฑ์ ์ธก์ ํ๋ค.
- ๋ ๋ฆฝ์ฑ์ด ๋์ ์๋ก ์ข์ ๋ชจ๋์ด๋ค -> ํด๋น ๋ชจ๋ ์์ ์ ๋ค๋ฅธ ๋ชจ๋์ด ๋ฏธ์น๋ ์ํฅ ๊ฐ์
์ด์์ ์ธ ๋ชจ๋ํ
๊ฒฐํฉ๋๋ ์ฝํ๊ฒ, ์์ง๋๋ ๊ฐํ๊ฒ, ๋ชจ๋์ ํฌ๊ธฐ๋ ์๊ฒ
๊ฒฐํฉ๋
- ์๋ก ๋ค๋ฅธ ๋ชจ๋ ๊ฐ ์ํธ ์์กดํ๋ ์ ๋, ๋ฎ์ ์๋ก ์ข๋ค.

์๋ฃ ๋ชจ๋๊ฐ ์ธํฐํ์ด์ค๋ก ์ ๋ฌ๋๋ ๋งค๊ฐ ๋ณ์๋ก ํต์ . ๋งค๊ฐ ๋ณ์๋ฅผ ์ต์ํ ํ๋๊ฒ์ด ์ข๋ค. ์์ํ ์๋ฃํ ์์ |
Void main(){ Local (int x, int y): } |
์คํฌํ ๋ชจ๋ ๊ฐ ์ธํฐํ์ด์ค์ ๋งค๊ฐ๋ณ์๋ก ๊ตฌ์กฐ์ฒด๋ฅผ ์ง์ . ๊ตฌ์กฐ์ฒด๋ฅผ ๋ณ์ํ. ์๋ฃ๊ตฌ์กฐ์ ํํ ๋ณ๊ฒฝ ์ ์ฐธ์กฐํ๋ ๋ชจ๋ ๋ชจ๋์ ์ํฅ |
Struct ์ขํ (int x, int y); Void main() {local(์ขํ x y)} |
์ ์ด ์ ์ด๋ฌธ์ ์ด์ฉ, ํ ๋ชจ๋์ ๋ด๋ถ ์ ์ด. ๋ณ๊ฒฝ์ด ๋ฐ์๋๋ฉด caller, callee ๋ชจ๋ ๋ณ๊ฒฝ. ๋คํ์ฑ ์ ์ฉ์ผ๋ก ํด๊ฒฐ |
Void main(){ local(1); } Void local(isExec){ if(isExec){} else{} } |
์ธ๋ถ ๋ชจ๋์ด ๋ค์์ ๊ธฐ๋ฅ์ ๊ฐ์ง ๋ ๋ชจ๋ ์์ ๊ตฌ์ฑ์ด ๊ทธ ๊ธฐ๋ฅ์ ์์ฐจ์ ์ผ๋ก ์ํ. ํน์ํ ์ธ๋ถ ํ๊ฒฝ์ ์ข ์๋์ด ์๋ ๊ฒฝ์ฐ ์ฐธ์กฐ๋๋ ๋ฐ์ดํฐ์ ๋ฒ์๊ฐ ๊ฐ ๋ชจ๋์์ ์ ํ (look up table) |
Void main(){ # include config data } Void local(){ # include config data } |
๊ณตํต ์ ์ญ๋ณ์ ๋ฑ ๋ชจ๋๊ฐ ํต์ผ ์๋ฃ์์ญ ๊ณตํต ์กฐํ ์ ์ญ๋ณ์๋ฅผ ์บก์ํํ์ฌ ๋ชจ๋์์ ์ ๊ณต (์ฑ๊ธํค ๋์์ธํจํด) |
Static in t A; Void main(){ A=1; } Void local(){ A=2; } |
๋ด์ฉ ๋ค๋ฅธ ๋ชจ๋์ ๋ด๋ถ ๋ฐ์ดํฐ๋ฅผ ์ง์ ์์ ํ๋ ๊ฒฝ์ฐ ๋ณ์๋ฅผ ์บก์ํํ์ฌ ๋ฐฉ์ง |
Void main(){ Go To Local; } Void local(int x int y){ LOCAL } |
์์ง๋
- ๋ชจ๋ ๋ด๋ถ์์ ๊ตฌ์ฑ ์์ ๊ฐ์ ๋ฐ์ ํ ๊ด๊ณ๋ฅผ ๋งบ๊ณ ์๋ ์ ๋, ๋์์๋ก ์ข๋ค.

๊ธฐ๋ฅ ๋ชจ๋ ๋ด๋ถ์ ๋ชจ๋ ๊ธฐ๋ฅ์ด ๋จ์ผํ ๋ชฉ์ ์ ์ํด ์ํ๋๋ ๊ฒฝ์ฐ ํ๋์ ๋ชจ๋, ํ๋์ ๊ธฐ๋ฅ ์ํ |
NA |
์์ฐจ ๋ชจ๋ ๋ด์์ ํ ํ๋์ผ๋ก๋ถํฐ ๋์จ ์ถ๋ ฅ๊ฐ์ ๋ค์ ์ ๋ ฅ ๊ฐ์ผ๋ก ์ฌ์ฉ |
A = update(); Delete(A) |
ํต์ ๋์ผํ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ๊ธฐ๋ฅ์ ์ํํ๋ ํ๋๋ค์ด ๋ชจ์ฌ์๋ ๊ฒฝ์ฐ |
DB์ ์ ์ฅ๋ name Print(name); Select(name) |
์ ์ฐจ ๋ชจ๋์ด ๋ค์์ ๊ด๋ จ ๊ธฐ๋ฅ์ ๊ฐ์ง ๋, ๋ชจ๋ ์์ ๊ตฌ์ฑ ์์๋ค์ด ๊ทธ ๊ธฐ๋ฅ์ ์์ฐจ์ ์ผ๋ก ์ํํ๋ ๊ฒฝ์ฐ |
Init() Listen() Request() |
์๊ฐ ์ฐ๊ด๋ ๊ธฐ๋ฅ์ด๋ผ๊ธฐ๋ณด๋ค ํน์ ์์ ์ ์ฒ๋ฆฌ๋์ด์ผ ํ๋ ํ๋๋ค์ ํ ๋ชจ๋์์ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ |
Init() Memset() |
๋
ผ๋ฆฌ ์ ์ฌํ ์ฑ๊ฒฉ์ ๊ฐ๊ฑฐ๋ ํน์ ํํ๋ก ๋ถ๋ฅ๋๋ ์ฒ๋ฆฌ ์์๋ค์ด ํ ๋ชจ๋์์ ์ฒ๋ฆฌ๋๋ ๊ฒฝ์ฐ ๋ฐ์ ํ ๊ด๋ จ์ ์์ |
Switch(1): Case 1: Case 2: Case 3: |
์ฐ์ฐ ๋ชจ๋ ๋ด๋ถ์ ๊ฐ ๊ตฌ์ฑ ์์๋ค์ด ์ฐ๊ด์ด ์๋ ๊ฒฝ์ฐ |
5๋ฒ. ์กํฐ๋นํฐ ๋ค์ด์ด๊ทธ๋จ
- ์ฌ์ฉ์์ ๊ด์ ์์ ์์คํ ์ด ์ํํ๋ ๊ธฐ๋ฅ์ ์ฒ๋ฆฌ ๊ณผ์ ์ ๋ฐ๋ผ ๋จ๊ณ์ ์ผ๋ก ํํํ ๊ฒ
- ํ๋์ ์ ์ค์ผ์ด์ค ์์์ ํน์ ์ ์ค์ผ์ด์ค ์ฌ์ด์ ๋ฐ์ํ๋ ๋ณต์กํ ์ฒ๋ฆฌ์ ํ๋ฆ์ ๋ช ํํ๊ฒ ํํ
- ์๋ฃ ํ๋ฆ๋์ ์ ์ฌ

6๋ฒ. ํ์ด์ฌ์ ์ฌ๊ท
- ํ์ด์ฌ์ ๊ธฐ๋ณธ ์ค์ ๊ฐ์ ๋ณ๊ฒฝํ์ง ์์ผ๋ฉด recursion ํ์๋ฅผ 1000๋ฒ์ผ๋ก ์ ํํ๊ณ ์๋ค.
7๋ฒ. ํ ์คํธ ์ปค๋ฒ๋ฆฌ์ง, ์ฝ๋ ์ปค๋ฒ๋ฆฌ์ง
ํ ์คํธ ์ปค๋ฒ๋ฆฌ์ง
- ์์คํ ๋ฐ ์ํํธ์จ์ด์ ๋ํด ์ถฉ๋ถํ ํ ์คํธ๊ฐ ๋์๋์ง๋ฅผ ๋ํ๋ด๋ ์ ๋์ด๋ค.
- ์ํํ ํ ์คํธ๊ฐ ์ผ๋ง๋ ํ ์คํธ ๋๋ฐฉ์ ์ปค๋ฒํ๋์ง๋ฅผ ๋ํ๋ธ๋ค.
์ฝํธ ์ปค๋ฒ๋ฆฌ์ง
- ํ ์คํธ์ ์ํด ์คํ๋ ์์ค ์ฝ๋์ ์์ ๋ํ๋ธ ๊ฒ์ด๋ค.
- ํ ์คํธ๋ก ์ฝ๋๊ฐ ์ผ๋ง๋ covered๋์๋์ง ๋ํ๋ด๋ ๊ฒ์ด๋ค.
- ํ์ดํธ ๋ฐ์ค ํ ์คํธ (์ํํธ์จ์ด ๋ด๋ถ ์์ค ์ฝ๋์ ๋ ผ๋ฆฌ์ ์ธ ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ํ ์คํธํ์ฌ ๋ชจ๋ ๋ด๋ถ์ ์๋์ ํ์ธํ๋ ๊ฒ, ๋ชจ๋์ ํ๋ฒ ์ด์ ์คํํ๋ฏ๋ก์จ ์ํ) ๋ฅผ ํตํด ์ธก์ ๋๊ณ % ๋จ์๋ก ํ์๋๋ค.
- but, ์ปค๋ฒ๋ฆฌ์ง๊ฐ 100%๋ผ๊ณ ํด์ ๋ฒ๊ทธ์๋ ์ํํธ์จ์ด๋ฅผ ๋ณด์ฅํ ์ ์๋ค.
- ๋์ค์ ์ผ๋ก ๊ตฌ๋ฌธ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ค.
์ฝ๋ ์ปค๋ฒ๋ฆฌ์ง ๊ธฐ์ค
๊ตฌ๋ฌธ ์ปค๋ฒ๋ฆฌ์ง (Statement Coverage)
- ๋ผ์ธ ์ปค๋ฒ๋ฆฌ์ง๋ผ๊ณ ๋ ํ๋ฉฐ ์ฝ๋ ํ์ค์ด ํ ๋ฒ ์ด์ ์คํ๋๋ค๋ฉด ์ถฉ์กฑ๋๋ค.
- ๋ก์ง์ ํ์ธํ๊ธฐ ๋ณด๋ค, ๋ชจ๋ ์ฝ๋๊ฐ ์คํ๋์๋์ง๋ฅผ ํ์ธํ๋ค.
- ์๋์ ์ฝ๋์์ a๊ฐ ์์๋ผ๋ฉด if๋ฌธ์ ๋ด๋ถ ๋ก์ง์ด ์คํ๋์ง ์๋๋ค. 4๊ฐ ์ค 3๊ฐ์ ๊ตฌ๋ฌธ๋ง ์คํ๋์์ผ๋ฏ๋ก ์ปค๋ฒ๋ฆฌ์ง๋ 3/4 = 75%
def foo(a:int):
print("--function start--") # 1๋ฒ
if a>0: # 2๋ฒ
a //= 2 # 3๋ฒ
print("--function end--") # 4๋ฒ
๊ฒฐ์ ์ปค๋ฒ๋ฆฌ์ง (Decision Coverage)
- ๋ธ๋์น ์ปค๋ฒ๋ฆฌ์ง๋ผ๊ณ ๋ ํ๋ฉฐ ์กฐ๊ฑด์์ด True/False๋ฅผ ๊ฐ์ง๋ ๊ฒฝ์ฐ ์ถฉ์กฑ๋๋ค.
- ์๋์ ์ฝ๋์์ foo(1,1), foo(1,0)์ ๊ฒฝ์ฐ ์กฐ๊ฑด๋ฌธ์ ๋ํด ์ฐธ/๊ฑฐ์ง์ ๋ง์กฑํ๋ ํ ์คํธ๊ฐ ๋์ด ๊ฒฐ์ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ง์กฑํ๋ค.
def foo(a: int, b: int):
if a>0 and b>0:
print("processing")
์กฐ๊ฑด ์ปค๋ฒ๋ฆฌ์ง (Condition Coverage)
- ๋ชจ๋ ๋ด๋ถ ์กฐ๊ฑด์ ๋ํด True/False๋ฅผ ๊ฐ์ง๊ฒ ๋๋ฉด ์ถฉ์กฑ๋๋ค.
- ๋ด๋ถ์กฐ๊ฑด์ด๋ if๋ฌธ ๋ด๋ถ์ ๋ชจ๋ ์กฐ๊ฑด๋ค์ ์๋ฏธํ๋ค.
- ์๋์ ์ฝ๋์์ a>0, b>0๊ฐ ๋ด๋ถ ์กฐ๊ฑด์ด ๋๋ฉฐ ๊ฐ๊ฐ์ ๋ํด True/False๋ฅผ ๊ฐ์ง๋ ํ ์คํธ๊ฐ ์๋ค๋ฉด ์ถฉ์กฑ๋๋ค.
- ํ ์คํธ ์ผ์ด์ค๊ฐ foo(1,0), foo(0,1) ์ผ ๋ ์๋์ a>0, b>0 ์ True/False ์ ์ผ์ด์ค๊ฐ ์กด์ฌํ๋ฏ๋ก ์กฐ๊ฑด ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ง์กฑํ๋ค. ํ์ง๋ง a>0 and b>0์ ์กฐ๊ฑด์์๋ False ์ด๋ฏ๋ก ์กฐ๊ฑด๋ฌธ ๋ด๋ถ์ ์ฝ๋๋ ํ ์คํธํ์ง ๋ชปํ๋ค.
- ์กฐ๊ฑด ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ง์กฑํ๋ค๊ณ ํด๋ ๊ตฌ๋ฌธ ์ปค๋ฒ๋ฆฌ์ง ๋๋ ๊ฒฐ์ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ง์กฑํ์ง ๋ชปํ ์ ์๋ค.
def foo(a: int, b: int):
if a>0 and b>0:
print("processing")
MC/DC
- ๊ฐ ๊ฐ๋ณ ์กฐ๊ฑด์์ด ๋ค๋ฅธ ๊ฐ๋ณ ์กฐ๊ฑด์์ ์ํฅ์ ๋ฐ์ง ์๊ณ ์ ์ฒด ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ์ ๋ ๋ฆฝ์ ์ผ๋ก ์ํฅ์ ์ฃผ๋๋กํจ
- ์กฐ๊ฑด/๊ฒฐ์ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ํฅ์์ํจ ํ ์คํธ ์ผ์ด์ค ๋์ถ ๊ธฐ๋ฒ
- ํด๋น ๊ฐ๋ณ ์กฐ๊ฑด์์ด ์ ์ฒด ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ์ ์ํฅ์ ์ฃผ๋ ์กฐ๊ฑด ์กฐํฉ์ ์ฐพ์์ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ํ ์คํธํ๋ ๋ฐฉ๋ฒ
MC/DC ๊ฒฐ์ ํ ์ด๋ธ ์์ฑ

MC/DC ๊ฒฐ์ ํ ์ด๋ธ
- ์ ์ฒด ์กฐ๊ฑด์ ํ ์คํธํ๋ ๊ฒ์ ์๊ฐ, ์ธ๋ ฅ, ๋น์ฉ ๋ฑ์ ๋ฌธ์ ๋ก ๊ฑฐ์ ๋ถ๊ฐ๋ฅํ์ฌ ์๋ฏธ์๋ ํ ์คํธ ์ผ์ด์ค๋ฅผ ๋์ถํ์ฌ ํ ์คํธ ์ํ์ด ๋ชฉ์

ํ ์คํธ ์ปค๋ฒ๋ฆฌ์ง ํฌํจ๊ด๊ณ

'Topcit' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ์ฏ ๋๋น ๋ฌธ์ ํ์ด] 02. ๋ฐ์ดํฐ ์ดํด์ ํ์ฉ (0) | 2023.10.26 |
---|