คำถามติดแท็ก unit-testing

ผมมักจะพยายามที่จะทำตามคำแนะนำของหนังสือเล่มนี้ทำงานอย่างมีประสิทธิภาพกับมรดกค้อจ ฉันทำลายการพึ่งพาย้ายส่วนต่าง ๆ ของรหัสไปยัง@VisibleForTesting public staticวิธีการและไปยังคลาสใหม่เพื่อให้รหัส (หรืออย่างน้อยก็บางส่วนของมัน) ทดสอบได้ และฉันเขียนการทดสอบเพื่อให้แน่ใจว่าฉันจะไม่ทำลายสิ่งใดเมื่อฉันแก้ไขหรือเพิ่มฟังก์ชั่นใหม่ เพื่อนร่วมงานคนหนึ่งบอกว่าฉันไม่ควรทำเช่นนี้ เหตุผลของเขา: รหัสต้นฉบับอาจทำงานไม่ถูกต้องตั้งแต่แรก และการเขียนการทดสอบทำให้การแก้ไขและการแก้ไขในอนาคตยากขึ้นเนื่องจาก devs ต้องเข้าใจและแก้ไขการทดสอบด้วย หากเป็นโค้ด GUI ที่มีตรรกะ (ตัวอย่างเช่น ~ 12 บรรทัด, 2-3 if / else บล็อก) การทดสอบจะไม่คุ้มกับปัญหาเนื่องจากรหัสนั้นเล็กน้อยเกินไปที่จะเริ่มต้น รูปแบบที่ไม่ดีที่คล้ายกันอาจมีอยู่ในส่วนอื่น ๆ ของ codebase เช่นกัน (ซึ่งฉันยังไม่ได้เห็นฉันค่อนข้างใหม่); มันจะง่ายกว่าในการทำความสะอาดพวกเขาทั้งหมดใน refactoring ใหญ่ การแยกตรรกะออกอาจทำให้ความเป็นไปได้ในอนาคตลดลง ฉันควรหลีกเลี่ยงการแยกส่วนที่สามารถทดสอบได้ออกมาและเขียนการทดสอบหรือไม่หากเราไม่มีเวลาสำหรับการเปลี่ยนโครงสร้างใหม่ให้สมบูรณ์? มีข้อเสียใด ๆ ที่ฉันควรพิจารณาหรือไม่?

72 unit-testing  refactoring  legacy-code 

สมมติว่ามีโปรแกรมที่ค่อนข้างใหญ่ (พูด 900k SLOC ใน C #) ทุกความเห็น / บันทึกไว้อย่างละเอียดจัดระเบียบดีและทำงานได้ดี ฐานรหัสทั้งหมดเขียนขึ้นโดยนักพัฒนาอาวุโสคนเดียวซึ่งไม่ได้อยู่กับ บริษัท อีกต่อไป รหัสทั้งหมดนั้นสามารถทำการทดสอบได้เหมือนเดิมและ IoC นั้นถูกใช้ไปตลอด - ยกเว้นด้วยเหตุผลแปลก ๆ บางอย่างที่พวกเขาไม่ได้เขียนการทดสอบหน่วยใด ๆ ตอนนี้ บริษัท ของคุณต้องการแยกรหัสและต้องการเพิ่มการทดสอบหน่วยเพื่อตรวจสอบเมื่อมีการเปลี่ยนแปลงการทำงานหลักของระบบ การเพิ่มการทดสอบเป็นความคิดที่ดีหรือไม่ ถ้าเป็นเช่นนั้นเราจะเริ่มจากสิ่งนี้ได้อย่างไร แก้ไข ตกลงดังนั้นฉันไม่ได้คาดหวังคำตอบที่สร้างข้อโต้แย้งที่ดีสำหรับข้อสรุปที่ตรงกันข้าม ปัญหาอาจจะออกจากมือของฉันอยู่ดี ฉันได้อ่าน "คำถามที่ซ้ำกัน" เช่นกันและฉันทามติทั่วไปคือ "การทดสอบการเขียนเป็นสิ่งที่ดี" ... ใช่ แต่ไม่เป็นประโยชน์ในกรณีนี้โดยเฉพาะ ฉันไม่คิดว่าฉันอยู่คนเดียวที่นี่ในการพิจารณาการทดสอบการเขียนสำหรับระบบเดิม ฉันจะทำตัวชี้วัดว่าใช้เวลาเท่าไรและมีกี่ครั้งที่การทดสอบใหม่ตรวจพบปัญหา (และกี่ครั้งที่พวกเขาไม่ทำ) ฉันจะกลับมาและอัปเดตปีนี้จากผลลัพธ์ของฉัน สรุปผลการศึกษา ดังนั้นจึงปรากฎว่าเป็นไปไม่ได้ที่จะเพิ่มการทดสอบหน่วยในโค้ดที่มีอยู่ด้วยลักษณะของออร์โธดอกซ์ เมื่อโค้ดทำงานคุณจะไม่สามารถทำการทดสอบของคุณได้แสงสีแดง / สีเขียว - เขียวก็มักจะไม่ชัดเจนว่าพฤติกรรมใดที่มีความสำคัญในการทดสอบไม่ชัดเจนว่าจะเริ่มต้นที่ใด ที่จริงแล้วการถามคำถามนี้พลาดประเด็นสำคัญในการเขียนแบบทดสอบในตอนแรก ในกรณีส่วนใหญ่ฉันพบว่ามันง่ายกว่าจริง ๆ …

68 unit-testing  tdd  maintenance 

จากการอ่านคำอธิบายฉันเข้าใจว่าในการทดสอบ TDD เสร็จแล้วก่อนที่จะเขียนฟังก์ชั่นและในการทดสอบหน่วยมันทำหลังจากนั้น นี่เป็นความแตกต่างหลักหรือไม่สามารถเปรียบเทียบสองคำนี้ได้ บางทีการทดสอบหน่วยเป็นส่วนหนึ่งของ TDD

64 unit-testing  tdd  difference 

แนะนำสั้น ๆ สำหรับคำถามนี้ ฉันใช้ตอนนี้ TDD และเมื่อเร็ว ๆ นี้ BDD นานกว่าหนึ่งปีแล้ว ฉันใช้เทคนิคอย่างเยาะเย้ยเพื่อให้การเขียนการทดสอบของฉันมีประสิทธิภาพยิ่งขึ้น เมื่อเร็ว ๆ นี้ฉันได้เริ่มโครงการส่วนตัวเพื่อเขียนโปรแกรมการจัดการเงินเล็กน้อยสำหรับตัวเอง เนื่องจากฉันไม่มีรหัสดั้งเดิมมันเป็นโครงการที่สมบูรณ์แบบที่จะเริ่มต้นด้วย TDD โชคไม่ดีที่ฉันไม่ได้สัมผัสกับความสุขของ TDD มาก มันทำให้เสียความสนุกของฉันมากจนฉันเลิกโครงการไปแล้ว ปัญหาคืออะไร? ฉันใช้วิธี TDD เหมือนวิธีการเพื่อให้การทดสอบ / ความต้องการพัฒนาการออกแบบของโปรแกรม ปัญหาคือกว่าครึ่งหนึ่งของเวลาในการพัฒนาสำหรับการทดสอบการเขียน / การรีแฟคเตอร์ ดังนั้นในที่สุดฉันก็ไม่ต้องการที่จะใช้คุณสมบัติอื่น ๆ อีกต่อไปเพราะฉันจะต้องปรับโครงสร้างและเขียนการทดสอบจำนวนมาก ที่ทำงานฉันมีรหัสดั้งเดิมมากมาย ที่นี่ฉันเขียนมากขึ้นและมากขึ้นการทดสอบการยอมรับและการทดสอบหน่วยน้อย สิ่งนี้ดูเหมือนจะไม่ใช่วิธีที่ไม่ดีเนื่องจากข้อบกพร่องส่วนใหญ่ถูกตรวจพบโดยการทดสอบการยอมรับและการรวม ความคิดของฉันคือในที่สุดฉันก็สามารถเขียนการทดสอบการรวมและการยอมรับได้มากกว่าการทดสอบหน่วย อย่างที่ฉันบอกว่าสำหรับการตรวจจับข้อบกพร่องการทดสอบหน่วยไม่ได้ดีไปกว่าการทดสอบการรวม / การยอมรับ การทดสอบหน่วยก็ดีสำหรับการออกแบบเช่นกัน เนื่องจากฉันเคยเขียนจำนวนมากเรียนของฉันจึงได้รับการออกแบบให้สามารถทดสอบได้ดีเสมอ นอกจากนี้วิธีการเพื่อให้การทดสอบ / ความต้องการเป็นแนวทางในการออกแบบนำไปสู่ในกรณีส่วนใหญ่เพื่อการออกแบบที่ดีขึ้น ข้อได้เปรียบสุดท้ายของการทดสอบหน่วยคือพวกมันเร็วกว่า ฉันได้เขียนการทดสอบการรวมเข้าด้วยกันพอที่จะรู้ว่าพวกเขาสามารถทำได้เร็วเท่ากับการทดสอบหน่วย หลังจากที่ผมถูกมองผ่านทางเว็บผมพบว่ามีความคิดที่คล้ายกันมากกับเหมืองกล่าวถึงที่นี่และมี คุณคิดอย่างไรกับความคิดนี้ แก้ไข การตอบคำถามตัวอย่างหนึ่งที่การออกแบบนั้นดี …

62 testing  unit-testing  tdd  bdd  integration-tests 

ที่ถูกเรียกโดยกระทู้นี้ฉัน (อีกครั้ง) กำลังคิดเกี่ยวกับการใช้การทดสอบหน่วยในโครงการของฉันในที่สุด มีผู้โพสต์สองสามคนพูดว่า "การทดสอบนั้นยอดเยี่ยมถ้าพวกเขาทำการทดสอบที่ดี" คำถามของฉันตอนนี้: การทดสอบ "ดี" คืออะไร? ในแอปพลิเคชั่นของฉันส่วนหลักมักจะเป็นการวิเคราะห์เชิงตัวเลขบางประเภทขึ้นอยู่กับข้อมูลจำนวนมากที่สังเกตได้และส่งผลให้มีฟังก์ชั่นพอดีที่สามารถใช้ในการสร้างแบบจำลองข้อมูลนี้ ฉันพบว่ามันยากมากที่จะสร้างการทดสอบสำหรับวิธีการเหล่านี้เนื่องจากจำนวนอินพุตและผลลัพธ์ที่เป็นไปได้มีมากเกินกว่าที่จะทดสอบได้ทุกกรณีและวิธีการของตัวเองมักจะค่อนข้างยาวและไม่สามารถปรับสภาพได้ง่าย ฉันสนใจการทดสอบ "ดี" เป็นพิเศษสำหรับวิธีการนี้

61 unit-testing 

ดังนั้นวันนี้ฉันได้พูดคุยกับเพื่อนร่วมทีมเกี่ยวกับการทดสอบหน่วย สิ่งทั้งหมดเริ่มต้นขึ้นเมื่อเขาถามฉันว่า "เฮ้การทดสอบของชั้นนั้นอยู่ที่ไหนฉันเห็นเพียงอันเดียว" ทั้งคลาสนั้นเป็นผู้จัดการ (หรือบริการถ้าคุณต้องการเรียกมันอย่างนั้น) และวิธีการเกือบทั้งหมดเป็นเพียงการมอบหมายสิ่งของให้กับ DAO ดังนั้นมันจึงคล้ายกับ: SomeClass getSomething(parameters) { return myDao.findSomethingBySomething(parameters); } ประเภทของแผ่นสำเร็จรูปที่ไม่มีตรรกะ (หรืออย่างน้อยฉันไม่ได้พิจารณาการมอบหมายอย่างง่ายเช่นตรรกะ) แต่เป็นแผ่นที่มีประโยชน์ในกรณีส่วนใหญ่ (การแยกชั้น ฯลฯ ) และเรามีการอภิปรายค่อนข้างยาวว่าควรทดสอบยูนิทหรือไม่ (ฉันคิดว่ามันคุ้มค่าที่จะกล่าวถึงว่าฉันทำการทดสอบยูนิทอย่างเต็มที่) ข้อโต้แย้งหลักของเขาคือว่าไม่ใช่ TDD (ชัดเจน) และบางคนอาจต้องการดูการทดสอบเพื่อตรวจสอบว่าวิธีการนี้ทำอะไร (ฉันไม่ทราบว่ามันจะชัดเจนมากขึ้น) หรือในอนาคตบางคนอาจต้องการเปลี่ยน การนำไปใช้งานและเพิ่มตรรกะ (หรือเช่น "ใด ๆ ") ใหม่ให้กับตรรกะนั้น (ซึ่งในกรณีนี้ฉันคิดว่าบางคนควรทดสอบตรรกะนั้น) นี่ทำให้ฉันคิดว่า เราควรมุ่งมั่นเพื่อให้ครอบคลุมการทดสอบมากที่สุดหรือไม่? หรือเป็นเพียงศิลปะเพื่อประโยชน์ของงานศิลปะในเวลานั้น? ฉันไม่เห็นเหตุผลใด ๆ ที่อยู่เบื้องหลังการทดสอบสิ่งต่าง ๆ เช่น: getters และ setters (ยกเว้นว่าพวกเขามีเหตุผลบางอย่างในตัวพวกเขา) รหัส "สำเร็จรูป" เห็นได้ชัดว่าการทดสอบวิธีการดังกล่าว …

61 testing  unit-testing  tdd 

ฉันได้รับมอบหมายให้เพิ่มรหัสครอบคลุมของโครงการ Java ที่มีอยู่ ฉันสังเกตเห็นว่าเครื่องมือครอบคลุมรหัส ( EclEmma ) ได้เน้นวิธีการบางอย่างที่ไม่เคยเรียกจากที่ใดก็ได้ ปฏิกิริยาเริ่มต้นของฉันคือไม่เขียนการทดสอบหน่วยสำหรับวิธีการเหล่านี้ แต่เพื่อเน้นพวกเขาไปยังผู้จัดการสายงาน / ทีมของฉันและถามว่าทำไมฟังก์ชันเหล่านี้ถึงเริ่มต้นด้วย วิธีการที่ดีที่สุดจะเป็นอย่างไร เขียนการทดสอบหน่วยสำหรับพวกเขาหรือตั้งคำถามว่าทำไมถึงมี

59 java  unit-testing  test-coverage 

ในการทดสอบหน่วยของฉันฉันมักจะโยนค่าโดยพลการที่รหัสของฉันเพื่อดูว่ามันทำอะไร ตัวอย่างเช่นถ้าฉันรู้ว่าfoo(1, 2, 3)ควรจะคืน 17 ฉันอาจเขียนนี้: assertEqual(foo(1, 2, 3), 17) ตัวเลขเหล่านี้เป็นกฎเกณฑ์โดยธรรมชาติและไม่มีความหมายที่กว้างกว่า (ตัวอย่างเช่นมันไม่ใช่เงื่อนไขขอบเขตแม้ว่าฉันจะทำการทดสอบกับสิ่งเหล่านั้นเช่นกัน) ฉันจะพยายามหาชื่อที่ดีสำหรับตัวเลขเหล่านี้และการเขียนอะไรทำนองconst int TWO = 2;นั้นก็ไม่ได้ช่วยอะไรเลย มันโอเคที่จะเขียนแบบทดสอบนี้หรือฉันควรแยกตัวเลขออกเป็นค่าคงที่หรือไม่? ในทุกหมายเลขมายากลถูกสร้างขึ้นเหมือนกันหรือไม่ เราได้เรียนรู้ว่าตัวเลขเวทมนตร์นั้นใช้ได้ถ้าความหมายนั้นชัดเจนจากบริบท แต่ในกรณีนี้ตัวเลขนั้นไม่มีความหมายเลย

59 unit-testing 

เมื่อทำการทดสอบหน่วยวิธีที่ "เหมาะสม" คือการถูทุกสายสาธารณะและส่งคืนค่าที่กำหนดไว้ล่วงหน้าหรือ mocks ฉันรู้สึกว่าฉันไม่ได้ทดสอบอะไรเลย ฉันกำลังดูรหัสของฉันอย่างแท้จริงและสร้างตัวอย่างจากการไหลของตรรกะผ่านวิธีการสาธารณะของฉัน และทุกครั้งที่มีการเปลี่ยนแปลงการใช้งานฉันต้องไปและเปลี่ยนการทดสอบเหล่านั้นอีกครั้งไม่รู้สึกว่าฉันทำสิ่งที่มีประโยชน์ (ไม่ว่าจะเป็นระยะกลางหรือระยะยาว) ฉันยังทำการทดสอบแบบรวม (รวมถึงเส้นทางที่ไม่มีความสุข) และฉันไม่สนใจเวลาการทดสอบที่เพิ่มขึ้น กับสิ่งเหล่านั้นฉันรู้สึกเหมือนจริง ๆ แล้วฉันกำลังทดสอบการถดถอยเนื่องจากพวกเขาจับได้หลายตัวในขณะที่การทดสอบหน่วยทั้งหมดนั้นแสดงให้ฉันเห็นว่าการดำเนินการตามวิธีการสาธารณะของฉันเปลี่ยนไปซึ่งฉันรู้แล้ว การทดสอบหน่วยเป็นหัวข้อที่กว้างใหญ่และฉันรู้สึกว่าฉันเป็นคนที่ไม่เข้าใจอะไรบางอย่างที่นี่ อะไรคือข้อได้เปรียบที่สำคัญของการทดสอบหน่วยและการทดสอบการรวมระบบ (ไม่รวมค่าใช้จ่ายด้านเวลา)

58 testing  unit-testing  integration-tests 

ฉันได้อ่านคำตอบของคำถามในบรรทัดที่คล้ายกันเช่น "คุณจะให้การทดสอบหน่วยของคุณทำงานอย่างไรเมื่อทำการรีแฟคเตอร์?" ในกรณีของฉันสถานการณ์แตกต่างกันเล็กน้อยซึ่งฉันได้รับโครงการเพื่อตรวจสอบและนำไปสู่มาตรฐานที่เรามีอยู่ในขณะนี้ไม่มีการทดสอบใด ๆ สำหรับโครงการ! ฉันได้ระบุหลายสิ่งที่ฉันคิดว่าทำได้ดีกว่าเช่นไม่ผสมรหัสประเภท DAO ในเลเยอร์บริการ ก่อนที่จะทำการเปลี่ยนรูปใหม่ดูเหมือนว่าเป็นความคิดที่ดีที่จะเขียนการทดสอบสำหรับโค้ดที่มีอยู่ ปัญหาที่ฉันเห็นก็คือเมื่อฉันทำ refactor แล้วการทดสอบเหล่านั้นจะแตกในขณะที่ฉันกำลังเปลี่ยนแปลงที่ตรรกะบางอย่างจะทำและการทดสอบจะถูกเขียนด้วยโครงสร้างก่อนหน้าในใจ (ล้อเลียนอ้างอิง ฯลฯ ) ในกรณีของฉันสิ่งที่จะเป็นวิธีที่ดีที่สุดในการดำเนินการ? ฉันถูกล่อลวงให้เขียนการทดสอบเกี่ยวกับรหัส refactored แต่ฉันรู้ว่ามีความเสี่ยงที่ฉันอาจ refactor สิ่งที่ไม่ถูกต้องที่อาจเปลี่ยนพฤติกรรมที่ต้องการ ไม่ว่าจะเป็น refactor หรือการออกแบบใหม่ฉันมีความสุขที่จะเข้าใจคำศัพท์เหล่านั้นที่จะได้รับการแก้ไขในขณะนี้ฉันกำลังทำงานกับคำจำกัดความต่อไปนี้สำหรับการ refactoring "ด้วยการ refactoring ตามนิยามคุณจะไม่เปลี่ยนแปลงสิ่งที่ซอฟต์แวร์ของคุณทำ คุณเปลี่ยนวิธีการใช้งาน ". ดังนั้นฉันจะไม่เปลี่ยนแปลงสิ่งที่ซอฟต์แวร์ทำฉันจะเปลี่ยนวิธี / มันทำ เท่าเทียมกันฉันสามารถดูอาร์กิวเมนต์ว่าถ้าฉันเปลี่ยนลายเซ็นของวิธีการที่อาจถือเป็นการออกแบบใหม่ นี่เป็นตัวอย่างสั้น ๆ MyDocumentService.java (ปัจจุบัน) public class MyDocumentService { ... public List<Document> findAllDocuments() { DataResultSet rs = …

55 unit-testing  refactoring 

การใช้การฉีดพึ่งพา (DI) จำเป็นสำหรับการทดสอบหน่วยหรือไม่ ฉันไม่สามารถคิดวิธีอื่นในการแยกรหัสเพื่อให้สามารถทดสอบได้ นอกจากนี้ตัวอย่างทั้งหมดที่ฉันเคยเห็นใช้รูปแบบนี้ นั่นเป็นเพราะมันเป็นทางเลือกเดียวที่ทำงานได้หรือมีทางเลือกอื่น ๆ ?

55 design-patterns  unit-testing 

โครงการส่วนใหญ่ที่ฉันทำงานพิจารณาการพัฒนาและการทดสอบหน่วยในการแยกซึ่งทำให้การทดสอบหน่วยการเขียนในภายหลังเป็นฝันร้าย วัตถุประสงค์ของฉันคือการทดสอบในใจในระหว่างขั้นตอนการออกแบบระดับสูงและระดับต่ำเอง ฉันต้องการทราบว่ามีหลักการออกแบบที่กำหนดไว้อย่างดีซึ่งส่งเสริมรหัสที่สามารถทดสอบได้หรือไม่ หนึ่งในหลักการดังกล่าวที่ฉันได้เข้าใจเมื่อเร็ว ๆ นี้คือการพึ่งพิงการพึ่งพาผ่านการฉีดการพึ่งพาและการกลับควบคุม ฉันได้อ่านแล้วว่ามีบางสิ่งที่เรียกว่าโซลิด ฉันต้องการที่จะเข้าใจว่าหากทำตามหลักการของ SOLID จะส่งผลทางอ้อมในรหัสที่สามารถทดสอบได้ง่ายหรือไม่? ถ้าไม่มีมีหลักการออกแบบที่ชัดเจนที่ส่งเสริมรหัสที่สามารถทดสอบได้หรือไม่ ฉันรู้ว่ามีบางสิ่งที่เรียกว่าการทดสอบพัฒนา แม้ว่าฉันจะสนใจการออกแบบโค้ดโดยคำนึงถึงการทดสอบในระหว่างขั้นตอนการออกแบบเองมากกว่าที่จะผลักดันการออกแบบผ่านการทดสอบ ฉันหวังว่านี่จะสมเหตุสมผล อีกหนึ่งคำถามที่เกี่ยวข้องกับหัวข้อนี้คือไม่ว่าจะเป็นปัจจัยใหม่ผลิตภัณฑ์ / โครงการที่มีอยู่และทำการเปลี่ยนแปลงรหัสและการออกแบบเพื่อวัตถุประสงค์ในการสามารถเขียนกรณีทดสอบหน่วยสำหรับแต่ละโมดูล?

54 unit-testing  tdd  solid 

วงจรสีแดง - เขียว - รีแฟคเตอร์สำหรับ TDD นั้นได้รับการยอมรับและยอมรับอย่างดี เราเขียนการทดสอบหน่วยที่ล้มเหลวหนึ่งรายการและทำให้ผ่านการทดสอบอย่างง่ายที่สุดเท่าที่จะทำได้ ประโยชน์ที่ได้รับจากวิธีนี้คือการเขียนการทดสอบหน่วยที่ล้มเหลวจำนวนมากสำหรับชั้นเรียนและทำให้พวกเขาผ่านการทดสอบเพียงครั้งเดียว ชุดทดสอบยังคงปกป้องคุณจากการเขียนรหัสที่ไม่ถูกต้องหรือทำผิดพลาดในขั้นตอนการเปลี่ยนโครงสร้างดังนั้นอันตรายคืออะไร บางครั้งมันง่ายกว่าที่จะเขียนการทดสอบทั้งหมดสำหรับคลาส (หรือโมดูล) ก่อนเป็นรูปแบบของ 'การถ่ายโอนข้อมูลสมอง' เพื่อเขียนพฤติกรรมที่คาดหวังทั้งหมดได้อย่างรวดเร็วในครั้งเดียว

54 unit-testing  development-process  tdd 

อะไรคือความแตกต่างระหว่างการสร้างแอปพลิเคชันOutside Inกับการสร้างInside Outโดยใช้ TDD นี่คือหนังสือที่ฉันอ่านเกี่ยวกับ TDD และการทดสอบหน่วย: การทดสอบพัฒนาขับเคลื่อน: โดยตัวอย่าง การพัฒนาขับเคลื่อนทดสอบ: คู่มือปฏิบัติ: แนวทางปฏิบัติ: แนวทางปฏิบัติ โซลูชั่นโลกแห่งความจริงสำหรับการพัฒนา PHP Framework คุณภาพสูงและ การพัฒนาทดสอบขับเคลื่อนแอพพลิเคชันใน Microsoft รูปแบบการทดสอบNET xUnit: รหัสการทดสอบการปรับ โครงสร้างใหม่ศิลปะการทดสอบหน่วย: ด้วยตัวอย่างใน. Net การพัฒนาซอฟต์แวร์เชิงวัตถุแนะนำโดยการทดสอบ ---> อันนี้ยากที่จะเข้าใจจริงๆเพราะ JAVA ไม่ใช่ภาษาหลักของฉัน :) เกือบทั้งหมดอธิบายถึงพื้นฐานของ TDD และการทดสอบหน่วยโดยทั่วไป แต่ด้วยการกล่าวถึงเพียงเล็กน้อยถึงวิธีต่างๆในการสร้างแอปพลิเคชัน อีกสิ่งที่ฉันสังเกตเห็นคือหนังสือส่วนใหญ่ (ถ้าไม่ใช่ทั้งหมด) จะไม่สนใจขั้นตอนการออกแบบเมื่อเขียนแอปพลิเคชัน พวกเขามุ่งเน้นที่การเขียนกรณีทดสอบอย่างรวดเร็วและปล่อยให้การออกแบบเกิดขึ้นเอง อย่างไรก็ตามฉันเจอย่อหน้าในรูปแบบการทดสอบ xUnit ที่กล่าวถึงวิธีการที่ผู้คนเข้าหา TDD มี 2 โรงเรียนออกมีนอกใน VS Inside Out น่าเศร้าที่หนังสือเล่มนี้ไม่ได้อธิบายเพิ่มเติมในประเด็นนี้ …

53 design  web-development  unit-testing  tdd 

เราทดสอบรหัสของเราเพื่อให้ถูกต้องมากขึ้น (จริง ๆ แล้วมีโอกาสน้อยที่จะไม่ถูกต้อง ) อย่างไรก็ตามการทดสอบนั้นก็เป็นรหัส - พวกเขายังสามารถมีข้อผิดพลาด และหากการทดสอบของคุณมีข้อบกพร่องพวกเขาแทบจะไม่ทำให้โค้ดของคุณดีขึ้น ฉันสามารถคิดถึงข้อผิดพลาดสามประเภทที่เป็นไปได้ในการทดสอบ: ข้อผิดพลาดเชิงตรรกะเมื่อโปรแกรมเมอร์เข้าใจผิดงานในมือและการทดสอบทำในสิ่งที่เขาคิดว่าพวกเขาควรทำซึ่งผิด ข้อผิดพลาดในกรอบการทดสอบพื้นฐาน (เช่น. การเยาะเย้ยสิ่งที่เป็นนามธรรม); ข้อบกพร่องในการทดสอบ: การทดสอบทำแตกต่างจากที่โปรแกรมเมอร์คิดไว้เล็กน้อย ข้อผิดพลาดประเภท (1) ดูเหมือนว่าเป็นไปไม่ได้ที่จะป้องกัน (เว้นแต่ว่าโปรแกรมเมอร์เพิ่ง ... ฉลาดขึ้น) อย่างไรก็ตาม (2) และ (3) อาจถูกเวไนยได้ คุณจัดการกับข้อผิดพลาดประเภทนี้อย่างไร คุณมีกลยุทธ์พิเศษเพื่อหลีกเลี่ยงพวกเขาหรือไม่? ตัวอย่างเช่นคุณเขียนการทดสอบแบบ "ว่างเปล่า" เป็นพิเศษหรือไม่ซึ่งเป็นการตรวจสอบเพียงข้อสันนิษฐานของผู้เขียนทดสอบเท่านั้น นอกจากนี้คุณจะแก้ไขข้อบกพร่องในกรณีทดสอบอย่างไร

53 unit-testing  tdd  debugging