Unit TestingWhat is a unit?Some sta

Unit Testing

What is a unit?

Some standards—particularly ANSI/IEEE Std 1008-1987 (IEEE Standard for Software Unit Testing)—use a lax definition of software unit. According to IEEE-Std-1008 a software unit "...may occur at any level of the design hierarchy from a single module to a complete program". I think this is because at the time the standard was written most testing was manual, in which case there isn't much difference between planning/managing the test process for a single class and for a complete program. From an economic point of view though, there is a big difference: testing of each individual component was often considered too expensive and testing frequently skipped this step. Some approaches like Cleanroom were (partly) born as a reaction to the excessive cost of proper unit testing in particular in the context of incremental development life cycles. The introduction of automatic regression tests at the unit level and standard test harnesses has changed this balance.

More modern definitions (like the comp.software.testing FAQ and accepted industry best practice define unit tests in a much more restrictive way:

Unit. The smallest compilable component. A unit typically is the work of one programmer (At least in principle). As defined, it does not include any called sub-components (for procedural languages) or communicating components in general.

Unit Testing. In unit testing called components (or communicating components) are replaced with stubs, simulators, or trusted components. Calling components are replaced with drivers or trusted super-components. The unit is tested in isolation.

For object-oriented programs this means that the unit is usually a class. Some classes (like a simple Stack) might be self-contained, but most call other classes and are in turn called by yet other classes. In an attempt to reduce confusion when things go wrong, you should try to test each class in isolation. If you don't test them in isolation, you are implicitly trusting all classes used by the class you are testing. You are effectivelly saying: I think all the other classes already work and if they don't, I'm prepared to sort out the mess myself. That's what "trusted" means in the above definition. If you don't think the other classes work, you should test in isolation. This is normally more work as writing stubs and drivers is a pain.

When to test?

As the scope of unit testing narrows down from complete programs to individual classes, so does the meaning of integration testing. Any time you test two or more already unit-tested classes together instead of using stubs, you are doing a litle bit of integration testing.

For some systems integration testing is a big issue, because they wait to finish coding before they start unit testing. This is a big mistake, as delaying unit testing means you will be doing it under schedule pressure, making it all-too-easy to drop the tests and just finish the code. Developers should expect to spend between 25% and 50% percent of their time writing unit tests. If they leave testing until they have finished, they can expect to spend the same amount testing as they spend writing the module in the first place. This is going to be extremely painful for them. The idea is to spread the cost of unit testing over the whole implementation phase. This is sometimes called "incremental glass-box testing" (see Marc Rettig's article).

If you wait until you've finished coding before you start unit testing, you'll have to choose an integration strategy. Are you going to start with low level classes first and work your way up until you reach the classes that expose some functionality through an public API or start from the top and write stubs for lower level classes or will you just test them all in one go?

Code Coverage

The greatest doubt I had when writing the standard, was not only how much coverage to mandate but also whether to mandate any coverage at all. It is easy enough to come up with a figure: 85% seems to be pretty standard. But I have to agree with Brian Marick [BM] that there is no evidence supporting this number. In my opinion 100% is reasonable, as anything less means you haven't tested that particular statements at all. Of course it is difficult to have automatic unit tests for certain parts of the code. Hardware interaction and UI code are typical examples. Or panics. If you have acceptance tests that include tests for these parts of the code or review them thoroughly, and if you make a sincere effort to minimise the size and complexity of these parts of the code, you can normally get away with not unit testing them. But I'd rather include any known exceptions to the coverage rule in the standard itself instead of arbitrarily lowering the bar for all the rest of the code.

Three pitfalls to consider if you mandate coverage:

Don't consider tests that don't increase coverage as redundant. This is a big mistake. They might not add coverage, but they might find bugs. C

ผลลัพธ์ (ไทย) 1:

การทดสอบหน่วยหน่วยคืออะไรบางมาตรฐาน — โดยเฉพาะอย่างยิ่ง ANSI/IEEE Std 1008-1987 (มาตรฐาน IEEE สำหรับซอฟต์แวร์หน่วยทดสอบ) — ใช้คำจำกัดความหละหลวมของหน่วยซอฟต์แวร์ ตาม IEEE Std 1008 หน่วยซอฟต์แวร์ "... .may เกิดขึ้นในทุกระดับของลำดับชั้นออกจากโมดูเดียวโปรแกรมสมบูรณ์" ผมคิดว่า นี่คือเวลาที่มาตรฐานในการเขียนมากที่สุดในการทดสอบได้ด้วยตนเอง ในกรณีที่มีไม่มากความแตกต่างระหว่างการวางแผน/การบริหารกระบวนการทดสอบ สำหรับคลาสที่เดียว และ สำหรับโปรแกรมสมบูรณ์แบบ จากการมองทางเศรษฐกิจ แม้ว่า มีความแตกต่างใหญ่: การทดสอบของแต่ละส่วนแต่ละมักจะเป็นราคาแพงเกินไป และการทดสอบมักข้ามขั้นตอนนี้ บางวิธีเช่นคลี (บางส่วน) เกิดเป็นปฏิกิริยากับต้นทุนมากเกินไปของการทดสอบหน่วยโดยเฉพาะในบริบทของการพัฒนาเพิ่มวงจรชีวิต การแนะนำการทดสอบอัตโนมัติถดถอยที่บังเหียนทดสอบมาตรฐาน และระดับของหน่วยมีการเปลี่ยนแปลงสมดุลคำนิยามสมัยใหม่ (เช่น comp.software.testing FAQ และวิธีปฏิบัติที่ยอมรับในอุตสาหกรรมกำหนดทดสอบหน่วยในทางที่เข้มงวดมากขึ้น:หน่วยงาน การที่คอมไพล์ได้ส่วนประกอบ หน่วยคือ การทำงานของโปรแกรมเมอร์หนึ่ง (อย่างน้อยในหลักการ) ตามที่กำหนดไว้ มันไม่มีคอมโพเนนต์ย่อยเรียกว่า (สำหรับขั้นตอนภาษา) หรือคอมโพเนนต์การสื่อสารใด ๆ โดยทั่วไปการทดสอบหน่วย ในหน่วย ทดสอบเรียกว่าคอมโพเนนต์ (หรือคอมโพเนนต์การสื่อสาร) จะถูกแทนที่ ด้วยสตับ จำลอง หรือส่วนประกอบที่เชื่อถือได้ เรียกคอมโพเนนต์ถูกแทนที่ ด้วยไดรเวอร์ หรือเชื่อถือซุปเปอร์คอมโพเนนต์ หน่วยมีทดสอบในการแยกสำหรับโปรแกรมเชิงวัตถุ ซึ่งหมายความ ว่า หน่วยจะคลา บางประเภท (เช่นแถวง่าย) อาจบรรจุเอง แต่ส่วนใหญ่เรียกชั้นเรียนอื่น ๆ และยังได้ชั้นในเรียกว่า ในความพยายามลดความสับสนเมื่อสิ่งผิดไป คุณควรลองทดสอบแต่ละชั้นแยก ถ้าคุณไม่ทดสอบพวกเขาในการแยก คุณจะไว้วางใจคลาสทั้งหมดที่ใช้ โดยคลาที่คุณทดสอบนัย คุณอยู่ effectivelly พูดว่า: ผมคิดว่า เรียนอื่น ๆ ทำงานอยู่แล้ว และถ้าไม่ ฉันจะเรียงลำดับจากระเบียบตัวเอง ที่ ว่า "วางใจ" ความหมายในนิยามข้างต้น ถ้าคุณไม่คิดว่า การทำงานประเภทอื่น ๆ คุณควรทดสอบในการแยก นี่คือเป็นเขียนค่ายทำงานมากกว่าปกติ และควบคุม ความเจ็บปวดเมื่อการทดสอบเป็นขอบเขตของการทดสอบหน่วยแคบลงจากโปรแกรมเสร็จสมบูรณ์แต่ละระดับชั้นที่ จึงไม่ความหมายของการทดสอบรวม ตลอดเวลาที่คุณทดสอบสองทดสอบหน่วยแล้วคลาด้วยกันแทนการใช้สตับ คุณกำลังทำบิต litle ทดสอบรวมสำหรับบางระบบ รวมการทดสอบเป็นปัญหาใหญ่ เนื่องจากพวกเขาเสร็จสิ้นการเข้ารหัสก่อนที่จะเริ่มการทดสอบหน่วย นี้เป็นความผิดพลาดใหญ่ หน่วงเวลาหน่วยทดสอบหมายความว่า คุณจะทำได้ภายใต้ความดันเวลา ทำให้หมดง่ายเกินไปปล่อยทดสอบ และสิ้นสุดการรหัส นักพัฒนาควรจะใช้เวลาระหว่าง 25% และ 50% ของเวลาเขียนทดสอบหน่วย ถ้าพวกเขาปล่อยให้ทดสอบจนกว่าจะเสร็จสิ้น พวกเขาสามารถคาดหวังการใช้ทดสอบเป็นพวกเขาใช้เวลาเขียนโมแรกกัน นี้เป็นไปได้เจ็บปวดอย่างมากสำหรับพวกเขา ความคิดคือการ กระจายต้นทุนของหน่วยที่ทดสอบผ่านขั้นตอนการดำเนินการทั้งหมด บางครั้งเรียกว่า "การทดสอบกล่องเพิ่มแก้ว" (ดูบท Marc Rettig)ถ้าคุณรอจนกว่าคุณเสร็จสิ้นการเข้ารหัสก่อนที่จะเริ่มการทดสอบหน่วย คุณจะต้องเลือกกลยุทธ์การรวม คุณกำลังจะเริ่มต้นด้วยระดับต่ำชั้นแรก และทำงานจนกว่าจะถึงชั้นที่ให้ทำงานบางอย่างผ่านทาง API สาธารณะ หรือเริ่มจากด้านบน และเขียนค่ายสำหรับการเรียนระดับต่ำกว่า หรือคุณจะแค่ทดสอบพวกเขาทั้งหมดในครั้งเดียวความครอบคลุมของรหัสThe greatest doubt I had when writing the standard, was not only how much coverage to mandate but also whether to mandate any coverage at all. It is easy enough to come up with a figure: 85% seems to be pretty standard. But I have to agree with Brian Marick [BM] that there is no evidence supporting this number. In my opinion 100% is reasonable, as anything less means you haven't tested that particular statements at all. Of course it is difficult to have automatic unit tests for certain parts of the code. Hardware interaction and UI code are typical examples. Or panics. If you have acceptance tests that include tests for these parts of the code or review them thoroughly, and if you make a sincere effort to minimise the size and complexity of these parts of the code, you can normally get away with not unit testing them. But I'd rather include any known exceptions to the coverage rule in the standard itself instead of arbitrarily lowering the bar for all the rest of the code.Three pitfalls to consider if you mandate coverage:Don't consider tests that don't increase coverage as redundant. This is a big mistake. They might not add coverage, but they might find bugs. C

ผลลัพธ์ (ไทย) 2:

การทดสอบหน่วยเป็นหน่วยอะไรบางอย่างโดยเฉพาะอย่างยิ่งมาตรฐาน ANSI / IEEE Std 1008-1987 (มาตรฐาน IEEE สำหรับซอฟท์แวทดสอบหน่วย) ใช้งานที่มีความละเอียดหละหลวมของหน่วยซอฟแวร์ ตามที่ IEEE-STD-1008 หน่วยซอฟต์แวร์ " ... อาจจะเกิดขึ้นในระดับใดของลำดับชั้นการออกแบบจากโมดูลเดียวกับโปรแกรมที่สมบูรณ์" ผมคิดว่านี่เป็นเพราะในช่วงเวลามาตรฐานที่เขียนการทดสอบมากที่สุดคือคู่มือซึ่งในกรณีนี้มีไม่แตกต่างกันมากระหว่างการวางแผน / การจัดการกระบวนการทดสอบสำหรับชั้นเดียวและเป็นโปรแกรมที่สมบูรณ์ จากจุดทางเศรษฐกิจของมุมมองว่ามีความแตกต่างใหญ่: การทดสอบของแต่ละองค์ประกอบของแต่ละบุคคลก็มักจะถือว่าแพงเกินไปและการทดสอบบ่อยข้ามขั้นตอนนี้ วิธีการบางอย่างเช่น Cleanroom ถูก (บางส่วน) เกิดเป็นปฏิกิริยาที่ค่าใช้จ่ายที่มากเกินไปของการทดสอบหน่วยที่เหมาะสมโดยเฉพาะอย่างยิ่งในบริบทของการพัฒนาที่เพิ่มขึ้นวงจรชีวิต การแนะนำของการทดสอบการถดถอยอัตโนมัติในระดับหน่วยและสายรัดทดสอบมาตรฐานมีการเปลี่ยนแปลงความสมดุลนี้. คำจำกัดความที่ทันสมัยอื่น ๆ (เช่นคำถามที่พบบ่อย comp.software.testing และเป็นที่ยอมรับในอุตสาหกรรมปฏิบัติที่ดีที่สุดกำหนดทดสอบหน่วยในทางที่เข้มงวดมากขึ้น: . หน่วยที่เล็กที่สุด องค์ประกอบ compilable. หน่วยมักจะเป็นผลงานของหนึ่งโปรแกรมเมอร์ (อย่างน้อยในหลักการ). ตามที่กำหนดไว้ก็ไม่ได้รวมถึงเรียกว่าองค์ประกอบย่อย (สำหรับภาษาขั้นตอน) หรือส่วนประกอบการสื่อสารทั่วไป. หน่วยทดสอบ. ในหน่วยการทดสอบที่เรียกว่าส่วนประกอบ (หรือส่วนประกอบการสื่อสาร) จะถูกแทนที่ด้วยต้นขั้วจำลองหรือส่วนประกอบที่เชื่อถือได้. ส่วนประกอบโทรจะถูกแทนที่ด้วยไดรเวอร์หรือเชื่อถือได้ซุปเปอร์ส่วนประกอบ. หน่วยมีการทดสอบในการแยก. สำหรับโปรแกรมเชิงวัตถุนี้หมายความว่าหน่วยโดยปกติจะเป็นชั้นเรียน บางชั้นเรียน (เช่นสแตกง่าย) อาจจะมีอยู่ในตัวเอง แต่ส่วนใหญ่เรียกชั้นเรียนอื่น ๆ และในทางกลับกันเรียกได้ว่าเรียนอยู่อีก. ในความพยายามที่จะลดความสับสนเมื่อสิ่งผิดไปคุณควรพยายามที่จะทดสอบแต่ละชั้นเรียนในการแยก หากคุณไม่ได้ทดสอบพวกเขาในการแยกที่คุณไว้วางใจโดยปริยายทุกชั้นใช้โดยชั้นเรียนที่คุณกำลังทดสอบ คุณกำลัง effectivelly พูดว่า: ผมคิดว่าทุกชั้นเรียนอื่น ๆ แล้วการทำงานและถ้าพวกเขาทำไม่ได้ผมเตรียมที่จะจัดเรียงออกระเบียบตัวเอง นั่นคือสิ่งที่ "น่าเชื่อถือ" หมายความว่าในความหมายดังกล่าวข้างต้น ถ้าคุณไม่คิดว่าชั้นเรียนอื่น ๆ ทำงานคุณควรทดสอบในการแยก นี่คือการทำงานตามปกติมากขึ้นเช่นการเขียนสมบูรณ์และคนขับรถเป็นความเจ็บปวด. เมื่อทดสอบ? ขอบเขตของการทดสอบหน่วยแคบลงจากโปรแกรมที่สมบูรณ์ในการเรียนของแต่ละบุคคลจึงไม่ความหมายของการทดสอบการรวม เมื่อใดก็ตามที่คุณทดสอบสองคนหรือมากกว่าแล้วหน่วยการเรียนที่ผ่านการทดสอบร่วมกันแทนการใช้ต้นขั้วที่คุณกำลังทำบิต litle ของการทดสอบการรวม. สำหรับบางคนการทดสอบการรวมระบบเป็นปัญหาใหญ่เพราะพวกเขารอที่จะเสร็จสิ้นการเข้ารหัสก่อนที่จะเริ่มการทดสอบหน่วย นี่คือความผิดพลาดใหญ่เช่นการล่าช้าในการทดสอบหน่วยหมายความว่าคุณจะทำมันภายใต้ความกดดันกำหนดการทำให้ทุกเกินไปง่ายที่จะลดลงทดสอบและเพิ่งเสร็จสิ้นรหัส นักพัฒนาควรคาดหวังที่จะใช้จ่ายระหว่าง 25% และร้อยละ 50% ของเวลาเขียนการทดสอบหน่วยของพวกเขา หากพวกเขาออกจากการทดสอบจนกว่าพวกเขาจะได้เสร็จสิ้นการที่พวกเขาสามารถคาดหวังที่จะใช้การทดสอบจำนวนเงินเช่นเดียวกับที่พวกเขาใช้เขียนโมดูลในสถานที่แรก นี้เป็นไปได้ที่เจ็บปวดอย่างมากสำหรับพวกเขา ความคิดที่จะแพร่กระจายค่าใช้จ่ายของการทดสอบหน่วยที่ผ่านขั้นตอนการดำเนินการทั้งหมด นี้บางครั้งเรียกว่า "ที่เพิ่มขึ้นทดสอบแก้วกล่อง" (ดูบทความของมาร์ค Rettig). หากคุณรอจนกว่าคุณจะเข้ารหัสเสร็จแล้วก่อนที่จะเริ่มการทดสอบหน่วยคุณจะต้องเลือกยุทธศาสตร์บูรณาการ คุณกำลังจะเริ่มต้นด้วยการเรียนในระดับต่ำเป็นครั้งแรกและวิธีการทำงานของคุณขึ้นจนกว่าจะถึงระดับชั้นที่เผยให้เห็นการทำงานบางอย่างผ่าน API สาธารณะหรือเริ่มต้นจากด้านบนและเขียนไม่สมบูรณ์สำหรับการเรียนระดับที่ต่ำกว่าหรือคุณจะเพียงการทดสอบพวกเขาทั้งหมดในหนึ่งไป ? โครงการรหัสสงสัยที่ยิ่งใหญ่ที่สุดที่ฉันมีเมื่อเขียนมาตรฐานไม่ได้เป็นเพียงวิธีการคุ้มครองมากที่จะอาณัติ แต่ยังว่าจะอาณัติคุ้มครองใด ๆ เลย มันเป็นเรื่องง่ายมากพอที่จะเกิดขึ้นกับตัวเลข: 85% น่าจะเป็นมาตรฐานสวย แต่ก็ต้องยอมรับกับไบรอัน Marick [BM] ที่ไม่มีหลักฐานสนับสนุนจำนวนนี้ ในความคิดของฉัน 100% เป็นที่เหมาะสมเป็นอะไรที่น้อยหมายความว่าคุณไม่ได้ทดสอบว่างบโดยเฉพาะอย่างยิ่งที่ทุกคน แน่นอนมันเป็นเรื่องยากที่จะมีการทดสอบหน่วยอัตโนมัติสำหรับบางส่วนของรหัส ปฏิสัมพันธ์ฮาร์ดแวร์และรหัส UI เป็นตัวอย่างทั่วไป หรือตื่นตกใจ หากคุณมีการทดสอบการยอมรับว่ารวมถึงการทดสอบสำหรับชิ้นส่วนเหล่านี้ของรหัสหรือแสดงความคิดเห็นได้อย่างทั่วถึงและถ้าคุณทำให้ความพยายามอย่างจริงใจที่จะลดขนาดและความซับซ้อนของชิ้นส่วนเหล่านี้ของรหัสที่ปกติคุณจะสามารถรับไปกับหน่วยไม่ได้ทดสอบพวกเขา แต่ฉันอยากจะรวมถึงข้อยกเว้นใด ๆ ที่รู้จักกันในกฎคุ้มครองในมาตรฐานของตัวเองแทนการโดยพลการลดแถบสำหรับส่วนที่เหลือทั้งหมดของรหัส. สามข้อผิดพลาดที่จะต้องพิจารณาถ้าคุณอาณัติคุ้มครอง: ไม่ได้พิจารณาการทดสอบที่ไม่เพิ่มขึ้น ความคุ้มครองซ้ำซ้อน นี่คือความผิดพลาดใหญ่ พวกเขาอาจจะไม่เพิ่มความคุ้มครอง แต่พวกเขาอาจพบข้อบกพร่อง C

ผลลัพธ์ (ไทย) 3:

การทดสอบหน่วยอะไรคือหน่วยอะไรบางมาตรฐานโดย ANSI / IEEE Std 1008-1987 ( มาตรฐาน IEEE สำหรับหน่วยการทดสอบซอฟต์แวร์ ) - ใช้คำนิยามที่หละหลวมของหน่วยซอฟต์แวร์ ตาม ieee-std-1008 ซอฟต์แวร์หน่วย " . . . . . . . อาจเกิดขึ้นในระดับใดของลำดับชั้นการออกแบบจากโมดูลเดียวเป็นโปรแกรมที่สมบูรณ์ ฉันคิดว่านี้เป็นเพราะในเวลามาตรฐานเขียนมากที่สุด ทดสอบด้วยตนเอง ซึ่งในกรณีที่มีไม่มากความแตกต่างระหว่างการวางแผน / การจัดการกระบวนการทดสอบระดับเดียว และสำหรับโปรแกรมที่สมบูรณ์ จากมุมมองทางเศรษฐกิจ แม้ว่ามีความแตกต่าง : การทดสอบของส่วนประกอบแต่ละบุคคลมักจะถือว่าแพงเกินไปและการทดสอบบ่อยข้ามขั้นตอนนี้ วิธีการบางอย่างเช่น cleanroom ( บางส่วน ) เกิดเป็นปฏิกิริยากับค่าใช้จ่ายที่มากเกินไปของการทดสอบหน่วยที่เหมาะสมโดยเฉพาะอย่างยิ่งในบริบทของการพัฒนาชีวิตเพิ่มรอบ เบื้องต้นของการทดสอบการถดถอยอัตโนมัติในระดับหน่วยและ harnesses ทดสอบมาตรฐานมีการเปลี่ยนแปลงความสมดุลนี้คำนิยามสมัยใหม่มากขึ้น ( เหมือน comp.software.testing FAQ และยอมรับการปฏิบัติที่ดีที่สุดในอุตสาหกรรม กำหนดสอบในหน่วยวิธีมากที่เข้มงวดมากขึ้น :หน่วย ส่วนประกอบ compilable น้อยที่สุด หน่วยโดยทั่วไปเป็นผลงานของโปรแกรมเมอร์ ( อย่างน้อยในหลักการ ) หมายถึง มันไม่ได้รวมเรียกว่าย่อยส่วนประกอบ ( สำหรับภาษาขั้นตอน ) หรือการสื่อสารองค์ประกอบทั่วไปการทดสอบหน่วย ในหน่วยการทดสอบส่วนประกอบ ( หรือที่เรียกว่าการสื่อสารองค์ประกอบ ) จะถูกแทนที่ด้วยตอจําลอง หรือไว้ใจ ส่วนประกอบ เรียกส่วนประกอบจะถูกแทนที่ด้วยไดรเวอร์หรือส่วนประกอบสุดเชื่อถือได้ เป็นหน่วยทดสอบในการแยก .สำหรับโปรแกรมเชิงวัตถุซึ่งหมายความว่าหน่วยมักจะเป็นชั้น บางชั้นเรียน ( เหมือนกองง่าย ) อาจจะอยู่ในตัวเอง แต่คนอื่น ๆในชั้นเรียนส่วนใหญ่เรียก และจะเรียกโดยยังเรียนอื่น ๆ ในความพยายามที่จะลดความสับสนเมื่อสิ่งผิดไป คุณควรลองทดสอบในแต่ละระดับในการแยก . ถ้าคุณไม่ทดสอบพวกเขาในการแยกคุณไว้วางใจโดยปริยายชั้นเรียนทั้งหมดที่ใช้โดยคลาสที่คุณจะทดสอบ คุณ effectivelly พูดว่า : ฉันคิดว่า ทั้งหมดอื่น ๆ เรียนแล้วทำงาน และถ้าพวกเขาไม่ได้ ผมจะจัดการเรื่องเอง นั่นคือสิ่งที่ " หมายความว่า ในคำนิยามข้างต้นเชื่อถือได้ " ถ้าคุณไม่คิดว่า คนอื่น ๆในชั้นเรียน งาน คุณควรทดสอบในการแยก . นี้เป็นปกติทำงานเพิ่มเติม ตามที่เขียนตอและไดรเวอร์คือความเจ็บปวดเมื่อทดสอบ ?เป็นขอบเขตของการทดสอบหน่วยแคบลงจากโปรแกรมที่สมบูรณ์ในแต่ละชั้นเรียน ไม่ดังนั้น ความหมายของการทดสอบการรวม เวลาที่คุณทดสอบสองหรือมากกว่าแล้วหน่วยทดสอบเรียนด้วยกัน แทนการใช้บัตร คุณมาทำอะไรนิดหน่อยน่ะการทดสอบบูรณาการสำหรับการทดสอบการรวมระบบเป็นปัญหาใหญ่เพราะพวกเขารอที่จะเสร็จสิ้นการเข้ารหัสก่อนที่จะเริ่มการทดสอบหน่วย นี่คือความผิดพลาดใหญ่ ขณะที่ชะลอการทดสอบหน่วยหมายความว่าคุณจะทำภายใต้ความดันเวลา ทำให้มันง่ายมากที่จะส่งข้อสอบเสร็จรหัส นักพัฒนาควรคาดหวังที่จะใช้จ่ายระหว่างร้อยละ 25 และ 50 เปอร์เซ็นต์ของเวลาที่พวกเขาเขียนทดสอบหน่วย ถ้าพวกเขาไปทดสอบจนกว่าจะเสร็จสิ้น พวกเขาสามารถคาดหวังที่จะใช้จ่ายจำนวนเงินเดียวกันที่พวกเขาใช้เวลาทดสอบเขียนโมดูลในสถานที่แรก นี่จะต้องเจ็บปวดมากสำหรับพวกเขา ความคิดคือการกระจายต้นทุนของหน่วยทดสอบผ่านขั้นตอนการดำเนินงานทั้งหมด นี้บางครั้งเรียกว่า " เพิ่มกล่องแก้วทดสอบ " ( ดูบทความของมาร์ค ฟัง )ถ้าคุณรอจนกว่าคุณจะเสร็จสิ้นการเข้ารหัสก่อนที่จะเริ่มการทดสอบหน่วย คุณจะต้องเลือกกลยุทธ์แบบบูรณาการ คุณจะเริ่มเรียนระดับแรกและวิธีการทำงานของคุณขึ้นจนกว่าจะถึงบทเรียนที่แสดงบางฟังก์ชันผ่าน API สาธารณะหรือเริ่มต้นจากด้านบนและเขียนในชั้นเรียนระดับล่างหรือคุณจะทดสอบพวกเขาทั้งหมดในหนึ่งไปรหัสครอบคลุมสงสัยมากที่สุดก็ตอนที่เขียนมาตรฐาน ไม่เพียงเท่าใดความคุ้มครอง แต่ยังว่าอาณัติอาณัติความคุ้มครองใด ๆที่ทั้งหมด มันง่ายพอที่จะเกิดขึ้นกับรูป : 85% น่าจะสวยได้มาตรฐาน แต่ผมเห็นด้วยกับ ไบรอัน มาริค [ BM ] ที่ไม่มีหลักฐานสนับสนุน หมายเลขนี้ ในความเห็นของฉัน 100% ที่เหมาะสมเป็นสิ่งที่น้อยกว่าหมายความว่าคุณยังไม่ได้ทดสอบเฉพาะงบทั้งหมด แน่นอนมันเป็นเรื่องยากที่จะมีการทดสอบหน่วยอัตโนมัติสำหรับบางส่วนของรหัส ปฏิสัมพันธ์ระหว่างฮาร์ดแวร์และรหัส UI ตัวอย่างทั่วไป หรือตกใจ ถ้าคุณต้องได้รับการยอมรับการทดสอบรวมถึงการทดสอบสำหรับชิ้นส่วนของรหัสหรือการตรวจสอบอย่างละเอียด และถ้าคุณทำให้ความพยายามอย่างจริงใจที่จะลดขนาดและความซับซ้อนของส่วนต่างๆของรหัส คุณสามารถปกติออกไปกับหน่วยทดสอบพวกเขา แต่ผมอยากจะรวมเรียกว่าข้อยกเว้นความคุ้มครองการปกครองในมาตรฐานตัวเองแทนโดยพลการลดบาร์สำหรับส่วนที่เหลือทั้งหมดของรหัสสามข้อผิดพลาดที่ควรพิจารณาถ้าคุณอาณัติครอบคลุม :ไม่พิจารณาการทดสอบที่ไม่เพิ่มความคุ้มครองเป็น ) นี่มันเป็นความผิดพลาดครั้งใหญ่ พวกเขาไม่อาจเพิ่มความครอบคลุม แต่พวกเขาอาจพบข้อผิดพลาด