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

ใน TDD มีไวยากรณ์จัดเรียง Assert (AAA): [Test] public void Test_ReturnItemForRefund_ReturnsStockOfBlackSweatersAsTwo_WhenOneInStockAndOneIsReturned() { //Arrange ShopStock shopStock = new ShopStock(); Item blackSweater = new Item("ID: 25"); shopStock.AddStock(blackSweater); int expectedResult = 2; Item blackSweaterToReturn = new Item("ID: 25"); //Act shopStock.ReturnItemForRefund(blackSweaterToReturn); int actualResult = shopStock.GetStock("ID: 25"); //Assert Assert.AreEqual(expectedResult, actualResult); } ในการทดสอบการเขียน BDD ใช้โครงสร้างที่คล้ายกัน แต่มีไวยากรณ์เมื่อเมื่อ (GWT): [Given(@"a …

13 c#  unit-testing  tdd  bdd 

ฉันทำงานกับ บริษัท ใหญ่และฉันรับผิดชอบงานจาวาแอพพลิเคชั่นขนาดใหญ่ที่มีการทดสอบ Junit นับพัน ตั้งแต่ฉันย้ายไปที่บทนี้มีการทดสอบแตก 200-300 ครั้ง (น่าจะพังได้หลายปี) การทดสอบนั้นเก่าและเปราะบางและพวกเขากำลังยุ่งเหยิงของการพึ่งพาสปาเก็ตตี้ที่มักจะจบลงด้วยข้อมูลแซนด์บ็อกซ์สด เป้าหมายของฉันคือการผ่านการทดสอบ 100% เพื่อให้เราสามารถสร้างความล้มเหลวในการสร้างหน่วยทดสอบ แต่ฉันไม่สามารถทำได้จนกว่าฉันจะจัดการกับการทดสอบที่เสียหาย ฉันมีงบประมาณน้อยมากเพราะงบประมาณการบำรุงรักษาเป็นสิ่งสำคัญสำหรับการสนับสนุน แต่ทีมของฉันได้ระบุและแก้ไขการทดสอบผลไม้แขวนลอยต่ำ (ส่วนใหญ่เป็นปัญหาการกำหนดค่า / ปัญหาทรัพยากรในท้องถิ่น) และเราลงไปทดสอบที่น่าเกลียด 30-40 อะไรคือความคิดเห็นเกี่ยวกับแนวปฏิบัติที่ดีที่สุด ฉันไม่คิดว่าการทดสอบนั้นมีค่า แต่ฉันก็ไม่รู้ว่าพวกเขากำลังทดสอบอะไรหรือทำไมพวกเขาถึงไม่ทำงานโดยไม่ต้องขุดซึ่งต้องใช้เวลาและเงินที่เราอาจไม่มี ฉันคิดว่าเราควรบันทึกสถานะของการทดสอบที่เสียหายด้วยสิ่งใดก็ตามที่เรารู้จากนั้นลบหรือเพิกเฉยต่อการทดสอบที่เสียหายทั้งหมดและป้อนข้อบกพร่องที่มีลำดับความสำคัญต่ำกว่า / รายการงานเพื่อตรวจสอบและแก้ไข จากนั้นเราจะอยู่ที่ 100% และเริ่มได้รับมูลค่าที่แท้จริงจากการทดสอบอื่น ๆ และหากเรามีโชคลาภการบำรุงรักษา / การปรับโครงสร้างใหม่เราจะสามารถรับได้อีกครั้ง อะไรคือแนวทางที่ดีที่สุด แก้ไข: ฉันคิดว่านี่เป็นคำถามที่แตกต่างจากคำถามนี้เพราะฉันมีทิศทางที่ชัดเจนสำหรับการทดสอบที่เราควรจะเขียนต่อไป แต่ฉันได้รับมรดกการทดสอบที่ล้มเหลวแบบดั้งเดิมที่จะอยู่ก่อนการทดสอบชุดใหญ่ในปัจจุบันจะมีความหมาย

13 java  unit-testing  legacy 

เริ่มจากตัวอย่างกันก่อน สมมติว่าฉันมีวิธีที่เรียกexportว่าขึ้นอยู่กับ schema DB อย่างมาก และโดย“ พึ่งพาหนัก” ฉันหมายถึงฉันรู้ว่าการเพิ่มคอลัมน์ใหม่ในตารางหนึ่งบ่อยครั้ง (บ่อยครั้งมาก) จะนำไปสู่exportการเปลี่ยนแปลงวิธีการที่สอดคล้องกัน(โดยปกติแล้วคุณควรเพิ่มเขตข้อมูลใหม่ลงในข้อมูลการส่งออกด้วย) โปรแกรมเมอร์มักจะลืมที่จะเปลี่ยนexportวิธีการเพราะมันไม่ชัดเจนจริงๆคุณควรดูที่นี้ เป้าหมายของฉันคือการบังคับให้โปรแกรมเมอร์ตัดสินใจอย่างชัดเจนเพื่อตัดสินว่าเขาลืมดูexportวิธีการหรือไม่ต้องการเพิ่มเขตข้อมูลลงในข้อมูลการส่งออก และฉันกำลังมองหาโซลูชันการออกแบบสำหรับปัญหานี้ ฉันมีสองแนวคิด แต่ทั้งคู่มีข้อบกพร่อง เสื้อคลุม "อ่านทั้งหมด" สมาร์ท ฉันสามารถสร้าง wrapper อัจฉริยะที่ทำให้แน่ใจว่าข้อมูลทั้งหมดอ่านอย่างชัดเจน บางสิ่งเช่นนี้ def export(): checker = AllReadChecker.new(table_row) name = checker.get('name') surname = checker.get('surname') checker.ignore('age') # explicitly ignore the "age" field result = [name, surname] # or whatever checker.check_now() # check …

13 design  design-patterns  architecture  unit-testing 

เมื่อนานมาแล้วที่ฉันอ่านคำตอบสแต็คโอเวอร์โฟลว์ที่ฉันหาไม่พบประโยคที่อธิบายว่าคุณควรทดสอบ API สาธารณะและผู้เขียนบอกว่าคุณควรทดสอบอินเทอร์เฟซ ผู้เขียนอธิบายว่าหากมีการเปลี่ยนแปลงวิธีการใช้งานคุณไม่จำเป็นต้องแก้ไขกรณีทดสอบเนื่องจากการทำเช่นนี้จะเป็นการผิดสัญญาที่ทำให้ระบบภายใต้การทดสอบทำงานได้ กล่าวอีกนัยหนึ่งการทดสอบควรล้มเหลวหากวิธีการไม่ทำงาน แต่ไม่ใช่เพราะการใช้งานมีการเปลี่ยนแปลง สิ่งนี้เรียกร้องความสนใจของฉันเมื่อเราพูดถึงการล้อเลียน เนื่องจากการเยาะเย้ยต้องอาศัยการเรียกร้องอย่างคาดหวังจากระบบภายใต้การทดสอบของผู้ทดสอบดังนั้น mocks จึงผนวกเข้ากับการใช้งานอย่างแน่นหนามากกว่าอินเตอร์เฟส ในขณะที่ทำการค้นคว้าmock vs stubหลายบทความเห็นด้วยว่าควรใช้ต้นขั้วแทน mocks เนื่องจากไม่ต้องพึ่งพาความคาดหวังจากการพึ่งพาซึ่งหมายความว่าการทดสอบไม่จำเป็นต้องมีความรู้เกี่ยวกับระบบพื้นฐานภายใต้การใช้งานการทดสอบ คำถามของฉันจะเป็น: mocks ละเมิดหลักการเปิด / ปิดหรือไม่? มีบางสิ่งที่ขาดหายไปในการโต้แย้งเพื่อช่วยสตับในย่อหน้าสุดท้ายที่ทำให้สตับไม่ดีเทียบกับ mocks หรือไม่? ถ้าเป็นเช่นนั้นเมื่อไรจะเป็นกรณีการใช้งานที่ดีในการเยาะเย้ยและเมื่อไหร่จะเป็นกรณีการใช้งานที่ดีในการใช้สตับ

13 unit-testing  solid  mocking  open-close  stub 

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

13 c#  design  unit-testing 

IContextฉันมีอินเตอร์เฟซที่เรียกว่า สำหรับวัตถุประสงค์นี้ไม่สำคัญว่าจะทำอะไรยกเว้นดังต่อไปนี้: T GetService<T>(); สิ่งที่วิธีนี้ทำคือดูที่ DI คอนเทนเนอร์ปัจจุบันของแอ็พพลิเคชันและพยายามแก้ไขการพึ่งพา ฉันคิดว่าค่อนข้างมาตรฐาน ในแอปพลิเคชัน ASP.NET MVC ของฉันคอนสตรัคของฉันมีลักษณะเช่นนี้ protected MyControllerBase(IContext ctx) { TheContext = ctx; SomeService = ctx.GetService<ISomeService>(); AnotherService = ctx.GetService<IAnotherService>(); } ดังนั้นแทนที่จะเพิ่มหลายพารามิเตอร์ในตัวสร้างสำหรับแต่ละบริการ (เพราะจะทำให้รำคาญและใช้เวลานานสำหรับนักพัฒนาที่ขยายแอปพลิเคชัน) ฉันใช้วิธีนี้เพื่อรับบริการ ตอนนี้ก็รู้สึกผิด แต่วิธีการที่ฉันกำลังเหตุผลมันอยู่ในหัวของฉันนี้ - ฉันจะเยาะเย้ยมัน ฉันสามารถ. IContextการทดสอบตัวควบคุมนั้นคงไม่ยาก ฉันจะต้องต่อไป: public class MyMockContext : IContext { public T GetService<T>() { if (typeof(T) == typeof(ISomeService)) …

13 c#  unit-testing  asp.net-mvc  dependency-injection 

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

13 unit-testing  testing  tdd  games 

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

13 unit-testing  tdd 

ฉันเขียนคลาสนี้ที่ทำบางสิ่ง (บางทีนี่อาจเป็นการละเมิดหลักการความรับผิดชอบเดี่ยว) ตอนนี้ฉันรู้แล้วว่าบางส่วนของโครงการต้องการตรรกะชิ้นหนึ่งและวิธีที่ฉันจะเปิดเผยก็คือการดึงคลาสออกจากระบบเดิมภายใต้การทดสอบของฉัน ฉันคาดหวังว่าจะสามารถทำได้โดยไม่ต้องเปลี่ยนรหัสทดสอบใด ๆ แต่เมื่อฉันเสร็จคุณสามารถยืนยันว่าการทดสอบไม่ใช่การทดสอบหน่วยอีกต่อไป มันจะทำการทดสอบคลาสเดิมและคลาสที่ฉันแยกออกมา กล่าวอีกนัยหนึ่งฉันจะมีหนึ่งกรณีทดสอบ แต่สองระบบภายใต้การทดสอบ ฉันควร refactor รหัสทดสอบของฉันหลังจากที่ฉันทำเสร็จแล้ว? IE: สร้าง ExtractedClassTest และย้ายการทดสอบที่เกี่ยวข้องทั้งหมดจาก OriginalClassTest ลงไปหรือไม่ ดูเหมือนว่าอาจมีความเสี่ยงเล็กน้อย: ฉันอาจสูญเสียความครอบคลุมบางส่วนในกระบวนการอาจไม่ง่ายเหมือนการย้ายการทดสอบและฉันสิ้นสุดการเขียนรหัสการทดสอบบางอย่างที่ฉันรู้ว่าเคยทำงาน แต่อาจไม่ได้อีกต่อไป เป็นต้น ในทางกลับกันถ้าฉันปล่อยให้ OriginalClassTest ตามเดิมฉันสามารถเห็นว่านี่เป็นปัญหาการบำรุงรักษาทดสอบ มันจะสับสนเล็กน้อยในการค้นหาที่การทดสอบของ ExtractedClass ความประทับใจแรกของคุณก็คือมันไม่มีอยู่จริง เมื่อเวลาผ่านไปด้วยการปรับโครงสร้างรหัสการผลิตจำนวนมากสิ่งนี้อาจกลายเป็นปัญหาร้ายแรง ฉันใหม่สำหรับ TDD ดังนั้นฉันต้องการคำแนะนำจากผู้เชี่ยวชาญ ขอบคุณ!

13 programming-practices  unit-testing  tdd  integration-tests 

ดังนั้นฉันมีโมดูลการตรวจสอบสิทธิ์ที่ฉันเขียนเมื่อไม่นานมานี้ ตอนนี้ฉันเห็นข้อผิดพลาดในทางของฉันและเขียนการทดสอบหน่วยสำหรับมัน ในขณะที่เขียนการทดสอบหน่วยฉันมีช่วงเวลาที่ยากลำบากในการหาชื่อที่ดีและพื้นที่ที่ดีสำหรับการทดสอบ ตัวอย่างเช่นฉันมีสิ่งที่ชอบ RequiresLogin_should_redirect_when_not_logged_in RequiresLogin_should_pass_through_when_logged_in Login_should_work_when_given_proper_credentials โดยส่วนตัวฉันคิดว่ามันน่าเกลียดนิดหน่อยถึงแม้ว่ามันจะดูเหมือน "เหมาะสม" ก็ตาม ฉันยังมีปัญหาในการแยกความแตกต่างระหว่างการทดสอบโดยการสแกนพวกเขา (ฉันต้องอ่านชื่อวิธีการอย่างน้อยสองครั้งเพื่อทราบว่าล้มเหลวเพียงใด) ดังนั้นฉันคิดว่าอาจจะแทนที่จะเขียนแบบทดสอบที่ทดสอบการทำงานล้วนๆอาจจะเขียนชุดการทดสอบที่ครอบคลุมสถานการณ์ ตัวอย่างเช่นนี่คือส่วนทดสอบที่ฉันสร้างขึ้นด้วย: public class Authentication_Bill { public void Bill_has_no_account() { //assert username "bill" not in UserStore } public void Bill_attempts_to_post_comment_but_is_redirected_to_login() { //Calls RequiredLogin and should redirect to login page } public void Bill_creates_account() { //pretend the login page …

13 design-patterns  .net  testing  unit-testing  user-story 

ฉันทำการทดสอบหน่วยและในชั้นเรียนของฉันฉันต้องส่งจดหมายจากวิธีใดวิธีหนึ่งดังนั้นการใช้การฉีดคอนสตรัคเตอร์ฉันฉีดอินสแตนซ์ของZend_Mailคลาสที่อยู่ในกรอบ Zend ตอนนี้บางคนยืนยันว่าถ้าห้องสมุดมีความมั่นคงเพียงพอและจะไม่เปลี่ยนแปลงบ่อยครั้งก็ไม่จำเป็นต้องห่อมัน ดังนั้นสมมติว่าZend_Mailมันเสถียรและจะไม่เปลี่ยนแปลงและมันก็เหมาะกับความต้องการของฉันทั้งหมดแล้วฉันจะไม่ต้องการเสื้อคลุม ตอนนี้มาดูคลาสของฉันLoggerที่ขึ้นอยู่กับZend_Mail: class Logger{ private $mailer; function __construct(Zend_Mail $mail){ $this->mail=$mail; } function toBeTestedFunction(){ //Some code $this->mail->setTo('some value'); $this->mail->setSubject('some value'); $this->mail->setBody('some value'); $this->mail->send(); //Some } } อย่างไรก็ตามการทดสอบหน่วยต้องการให้ฉันทดสอบองค์ประกอบหนึ่งครั้งดังนั้นฉันต้องจำลองZend_Mailชั้นเรียน นอกจากนี้ฉันกำลังละเมิดหลักการการพึ่งพาการพึ่งพาเนื่องจากLoggerชั้นเรียนของฉันตอนนี้ขึ้นอยู่กับการตัดสินใจที่ไม่เป็นนามธรรม ตอนนี้ฉันจะทดสอบLoggerการแยกโดยไม่ต้องห่อได้Zend_Mailอย่างไร! รหัสอยู่ใน PHP แต่คำตอบไม่จำเป็นต้องเป็น นี่เป็นปัญหาการออกแบบมากกว่าฟีเจอร์เฉพาะภาษา

13 design  object-oriented  unit-testing  tdd  solid 

ในโครงการปัจจุบันอำนาจที่ต้องการให้มีการทดสอบหน่วยรวมอยู่ในวงจรการพัฒนาของเราเพื่อหลีกเลี่ยงข้อผิดพลาดจำนวนคงที่ที่ดูเหมือนจะซึมเข้าไปในรหัสของเรา ปัญหาคือรหัสสปาเก็ตตี้นั้นเป็นขั้นตอน 95% ซึ่งฉันไม่เคยทำการทดสอบหน่วยด้วย (ประสบการณ์ทั้งหมดของฉันกับการทดสอบหน่วยได้รับด้วยรหัส OOP) ดังนั้นคำถามของฉันสั้น ๆ ก็ควรที่จะดำเนินการทดสอบหน่วยกับ codebase ปัจจุบันของเราหรือแนะนำให้เลื่อนออกไปจนกว่าแอปพลิเคชันจะถูกย้ายไปยังกรอบงาน OOP ที่เหมาะสมหรือไม่ PS: ในขณะที่ฉันพยายามจัดรูปแบบคำถามนี้เป็นผู้ไม่เชื่อเรื่องภาษาฉันรู้สึกว่าการระบุแอปพลิเคชันที่เป็นปัญหานั้นใช้ PHP และ javascript จะช่วยให้คำตอบที่เฉพาะเจาะจงมากขึ้นซึ่งสามารถตอบคำถามนี้ได้

13 object-oriented  unit-testing  procedural 

ในขณะที่มีวิธีการป้องกันการทดสอบหน่วยจากการถูกดำเนินการอะไรคือค่าของการตรวจสอบในการทดสอบหน่วยที่ล้มเหลว? ฉันจะใช้ตัวอย่างง่ายๆ: Case Sensitivity รหัสปัจจุบันคำนึงถึงขนาดตัวพิมพ์ อินพุตที่ถูกต้องลงในเมธอดคือ "Cat" และจะส่งคืน enum ของ Animal อย่างไรก็ตามฟังก์ชั่นที่ต้องการของวิธีการไม่ควรคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ดังนั้นหากวิธีการที่อธิบายไว้ถูกส่งผ่าน "cat" มันอาจจะส่งคืนบางอย่างเช่น Animal.Null แทน Animal.Cat และการทดสอบหน่วยจะล้มเหลว แม้ว่าการเปลี่ยนรหัสอย่างง่ายจะทำให้งานนี้เกิดปัญหาที่ซับซ้อนมากขึ้นอาจใช้เวลาหลายสัปดาห์ในการแก้ไข แต่การระบุข้อบกพร่องด้วยการทดสอบหน่วยอาจเป็นงานที่ซับซ้อนน้อยกว่า แอปพลิเคชันที่กำลังถูกวิเคราะห์มีรหัส 4 ปีที่ "ทำงาน" อย่างไรก็ตามการสนทนาล่าสุดเกี่ยวกับการทดสอบหน่วยได้พบข้อบกพร่องในรหัส บางคนเพียงต้องการเอกสารการใช้งานที่ชัดเจน (เช่นเล็กหรือใหญ่) หรือรหัสที่ไม่ได้ดำเนินการบั๊กตามวิธีที่เรียกใช้ในปัจจุบัน แต่การทดสอบหน่วยสามารถสร้างการดำเนินการตามสถานการณ์เฉพาะที่จะทำให้เกิดข้อบกพร่องที่จะเห็นและเป็นอินพุตที่ถูกต้อง มูลค่าของการตรวจสอบในการทดสอบหน่วยที่ใช้บั๊กจนกว่าจะมีใครสามารถแก้ไขโค้ดได้ การทดสอบหน่วยนี้ควรตั้งค่าสถานะด้วยการเพิกเฉยลำดับความสำคัญหมวดหมู่และอื่น ๆ เพื่อตรวจสอบว่าการสร้างเสร็จสมบูรณ์ตามการทดสอบที่ดำเนินการหรือไม่ ในที่สุดควรสร้างการทดสอบหน่วยเพื่อเรียกใช้รหัสเมื่อมีคนแก้ไข ในมือข้างหนึ่งก็แสดงให้เห็นว่าข้อบกพร่องที่ระบุยังไม่ได้รับการแก้ไข ในอีกทางหนึ่งอาจมีการทดสอบหน่วยที่ล้มเหลวหลายร้อยรายการปรากฏขึ้นในบันทึกและกำจัดวัชพืชผ่านการทดสอบที่ควรล้มเหลวและความล้มเหลวเนื่องจากการตรวจสอบรหัสจะยากที่จะหา

13 unit-testing 

คุณจะทำอย่างไรเมื่อคุณเขียนข้อสอบและถึงจุดที่คุณต้องทำแบบทดสอบและคุณรู้ว่าคุณต้องการฟังก์ชั่นเพิ่มเติมที่ควรแยกออกมาเป็นหน้าที่ของตัวเอง? ฟังก์ชั่นใหม่นั้นจำเป็นต้องได้รับการทดสอบเช่นกัน แต่วัฏจักร TDD บอกว่าการทดสอบล้มเหลว หากฉันอยู่ในขั้นตอนที่ฉันพยายามทำให้ผ่านการทดสอบฉันไม่ควรออกไปและเริ่มการทดสอบที่ล้มเหลวอีกครั้งเพื่อทดสอบการทำงานใหม่ที่ฉันต้องนำไปใช้ ตัวอย่างเช่นฉันกำลังเขียนคลาสพอยต์ที่มีฟังก์ชั่นWillCollideWith ( LineSegment ) : public class Point { // Point data and constructor ... public bool CollidesWithLine(LineSegment lineSegment) { Vector PointEndOfMovement = new Vector(Position.X + Velocity.X, Position.Y + Velocity.Y); LineSegment pointPath = new LineSegment(Position, PointEndOfMovement); if (lineSegment.Intersects(pointPath)) return true; return false; } } …

13 unit-testing  tdd 

นี่คือรหัส C ++ ทั่วไป: foo.hpp #pragma once class Foo { public: void f(); void g(); ... }; foo.cpp #include "foo.hpp" namespace { const int kUpperX = 111; const int kAlternativeX = 222; bool match(int x) { return x < kUpperX || x == kAlternativeX; } } // namespace void Foo::f() …

12 c++  unit-testing