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

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

21 design-patterns  unit-testing  functional-programming  dependency-injection 

ข้อแก้ตัวหลักจากนักพัฒนาที่ไม่มีการทดสอบหน่วยที่ดีคือ "รหัสไม่ได้ถูกออกแบบในแบบทดสอบได้" ฉันพยายามที่จะเข้าใจประเภทของการออกแบบและรหัสที่ไม่สามารถทดสอบหน่วยได้

21 unit-testing 

ฉันพยายามทดสอบคลาสที่เรียกบริการเว็บของ Hadoop รหัสมีรูปแบบค่อนข้างมาก: method() { ...use Jersey client to create WebResource... ...make request... ...do something with response... } เช่นมีวิธีสร้างไดเรกทอรีวิธีสร้างโฟลเดอร์เป็นต้น ระบุว่ารหัสนั้นเกี่ยวข้องกับบริการเว็บภายนอกที่ฉันไม่สามารถควบคุมได้ฉันจะทดสอบหน่วยนี้ได้อย่างไร ฉันสามารถลองและเยาะเย้ยไคลเอนต์บริการเว็บ / การตอบสนอง แต่นั่นทำลายแนวทางที่ฉันได้เห็นมากเมื่อเร็ว ๆ นี้: "อย่าเยาะเย้ยวัตถุที่คุณไม่ได้เป็นเจ้าของ" ฉันสามารถตั้งค่าการใช้บริการเว็บจำลองที่ยังคงเป็นการทดสอบหน่วยหรือว่าเป็นการทดสอบการรวมหรือไม่ เป็นไปไม่ได้หรือที่จะทำการทดสอบหน่วยในระดับต่ำนี้ผู้ประกอบการ TDD จะทำเช่นนี้ได้อย่างไร?

21 unit-testing  tdd  web-services  integration-tests 

ฉันดิ้นรนกับปัญหาที่น่ารำคาญมากขึ้นเกี่ยวกับการทดสอบหน่วยของเราที่เรากำลังนำไปใช้ในทีมของฉัน เรากำลังพยายามเพิ่มการทดสอบหน่วยในรหัสดั้งเดิมที่ไม่ได้ออกแบบมาอย่างดีและในขณะที่เราไม่ได้มีปัญหาใด ๆ กับการเพิ่มการทดสอบจริง ๆ เราเริ่มที่จะต่อสู้กับการทดสอบที่เกิดขึ้น เป็นตัวอย่างของปัญหาสมมติว่าคุณมีวิธีการที่เรียก 5 วิธีอื่น ๆ เป็นส่วนหนึ่งของการดำเนินการ การทดสอบสำหรับวิธีนี้อาจเป็นการยืนยันว่าลักษณะการทำงานที่เกิดขึ้นเป็นผลมาจากวิธีการหนึ่งใน 5 วิธีการอื่นที่เรียกว่า ดังนั้นเนื่องจากการทดสอบหน่วยควรล้มเหลวด้วยเหตุผลเดียวและเหตุผลเดียวเท่านั้นคุณต้องการกำจัดปัญหาที่อาจเกิดขึ้นจากการเรียก 4 วิธีการอื่น ๆ เหล่านี้และเยาะเย้ยพวกเขาออก ที่ดี! การทดสอบหน่วยดำเนินการวิธีการเยาะเย้ยจะถูกละเว้น (และพฤติกรรมของพวกเขาสามารถยืนยันได้ว่าเป็นส่วนหนึ่งของการทดสอบหน่วยอื่น ๆ ) และการตรวจสอบใช้งานได้ แต่มีปัญหาใหม่ - การทดสอบหน่วยมีความรู้อย่างใกล้ชิดว่าคุณยืนยันพฤติกรรมและการเปลี่ยนแปลงลายเซ็นใด ๆ ของ 4 วิธีอื่น ๆ ในอนาคตหรือวิธีการใหม่ใด ๆ ที่จำเป็นต้องเพิ่มใน 'วิธีการหลัก' จะ ส่งผลให้ต้องเปลี่ยนการทดสอบหน่วยเพื่อหลีกเลี่ยงความล้มเหลวที่เป็นไปได้ โดยธรรมชาติแล้วปัญหาสามารถลดลงได้บ้างเพียงแค่มีวิธีการมากขึ้นที่จะทำให้พฤติกรรมน้อยลง แต่ฉันหวังว่าอาจจะมีวิธีการแก้ปัญหาที่หรูหรากว่านี้ นี่คือตัวอย่างการทดสอบหน่วยที่จับปัญหา ในฐานะที่เป็นโน้ตย่อ 'MergeTests' เป็นคลาสการทดสอบหน่วยที่สืบทอดจากคลาสที่เรากำลังทดสอบและแทนที่พฤติกรรมตามต้องการ นี่คือ 'รูปแบบ' ที่เราใช้ในการทดสอบของเราเพื่อให้เราสามารถแทนที่การโทรไปยังคลาส / การอ้างอิงภายนอก …

21 c#  testing  unit-testing  mocking 

ฉันกำลังพูดถึงการทดสอบหน่วยในความหมาย TDD (ไม่ใช่ "การรวม" โดยอัตโนมัติหรือสิ่งที่คุณต้องการเรียกว่าการทดสอบ) รหัสดั้งเดิมในรหัส (C ++) โดยไม่มีการทดสอบ (ดู: Michael Feathers ' ทำงานอย่างมีประสิทธิภาพด้วยรหัสดั้งเดิม ) แต่ยังเป็นรหัสดั้งเดิมใน: รหัสที่ทีมของเราทำงานด้วยกันมา 10-5 ปีที่ผ่านมาดังนั้นเราจึงมักจะมีความคิดที่ดีเกี่ยวกับสถานที่ที่จะนำสิ่งต่าง ๆ มาเปลี่ยนอะไรบางอย่าง เรามีการทดสอบหน่วยในสถานที่ (ผ่าน Boost.Test) สำหรับบางโมดูลที่มาในภายหลังหรือเป็นแบบ "ธรรมชาติ" สำหรับการทดสอบหน่วย (เช่นคอนเทนเนอร์เฉพาะแอปทั่วไปสตริงสิ่งผู้ช่วยเครือข่าย ฯลฯ ) เรายังไม่มีการทดสอบการยอมรับอัตโนมัติที่เหมาะสม ตอนนี้เมื่อเร็ว ๆ นี้ฉันมี "ความสุข" ที่จะใช้คุณสมบัติใหม่ 3 อย่างที่ผู้ใช้งานต้องเผชิญ แต่ละคนใช้เวลาประมาณ 1-2 ชั่วโมงในการเร่งความเร็วด้วยส่วนรหัสที่ฉันต้องการเปลี่ยน 1-2 ชั่วโมงชั่วโมงในการใช้รหัส (เล็กน้อย) ที่ฉันต้องเปลี่ยนและอีก 1-2 ชั่วโมงเพื่อให้แน่ใจว่าแอป วิ่งอย่างถูกต้องในภายหลังและมันก็ควรจะทำ ตอนนี้ฉันเพิ่มรหัสเล็กน้อย (ฉันคิดว่าวิธีหนึ่งและสองสามบรรทัดสำหรับแต่ละคุณสมบัติ) …

21 c++  tdd  legacy  unit-testing 

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

21 unit-testing  team  refactoring  bad-code  integration-tests 

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

21 books  testing  unit-testing 

ในข้อความเกี่ยวกับ TDD ฉันมักจะอ่านเกี่ยวกับ "ลบการทำซ้ำ" หรือ "ปรับปรุงการอ่าน" ในระหว่างขั้นตอนการสร้างใหม่ แต่อะไรทำให้ฉันลบฟังก์ชันที่ไม่ได้ใช้ออก สำหรับการพูดเช่นขอให้มีชั้นเรียนCด้วยวิธีการและa() b()ตอนนี้ผมคิดว่ามันจะดีที่จะมีวิธีการที่จะขับรถเข้าไปf() Cในความเป็นจริงf()แทนที่ทุกสายที่จะb()มีข้อยกเว้นของการทดสอบหน่วยที่กำหนดไว้ / b()อธิบาย ไม่จำเป็นอีกต่อไป - ยกเว้นการทดสอบ มันเป็นการประหยัดเพียงแค่ลบb()และการทดสอบทั้งหมดที่ใช้หรือไม่ เป็นส่วนหนึ่งของ "ปรับปรุงการอ่าน" หรือไม่?

20 unit-testing  refactoring  tdd  readability 

การทำซ้ำข้อมูลระหว่างการทดสอบและรหัสจริงดีหรือไม่ดี ตัวอย่างเช่นสมมติว่าฉันมีคลาส Python FooSaverที่บันทึกไฟล์ด้วยชื่อเฉพาะลงในไดเรกทอรีที่กำหนด: class FooSaver(object): def __init__(self, out_dir): self.out_dir = out_dir def _save_foo_named(self, type_, name): to_save = None if type_ == FOOTYPE_A: to_save = make_footype_a() elif type == FOOTYPE_B: to_save = make_footype_b() # etc, repeated with open(self.out_dir + name, "w") as f: f.write(str(to_save)) def save_type_a(self): self._save_foo_named(a, "a.foo_file") def save_type_b(self): …

20 unit-testing  coding-style  clean-code 

โดเมนของฉันประกอบด้วยคลาสที่ไม่เปลี่ยนรูปแบบง่าย ๆ มากมายเช่นนี้ public class Person { public string FullName { get; } public string NameAtBirth { get; } public string TaxId { get; } public PhoneNumber PhoneNumber { get; } public Address Address { get; } public Person( string fullName, string nameAtBirth, string taxId, PhoneNumber phoneNumber, Address address) { …

20 c#  unit-testing 

พื้นหลัง การทดสอบพัฒนาการขับเคลื่อนได้รับความนิยมหลังจากเรียนจบแล้วและในอุตสาหกรรม ฉันพยายามที่จะเรียนรู้ แต่สิ่งสำคัญบางอย่างยังคงหลบหนีฉัน ผู้เสนอ TDD พูดหลายสิ่งหลายอย่างเช่น (ต่อไปนี้เรียกว่า "หลักการยืนยันเดียว" หรือSAP ): บางครั้งฉันก็คิดว่าการทดสอบ TDD นั้นเรียบง่ายมีความหมายและสง่างามเท่าที่จะทำได้ บทความนี้สำรวจเล็กน้อยเกี่ยวกับสิ่งที่ต้องการทำแบบทดสอบที่ง่ายและย่อยสลายได้มากที่สุด: มีเป้าหมายสำหรับการยืนยันเดียวในแต่ละการทดสอบ ที่มา: http://www.artima.com/weblogs/viewpost.jsp?thread=35578 พวกเขายังพูดแบบนี้ (ซึ่งต่อไปจะเรียกว่า "หลักการวิธีการส่วนตัว" หรือPMP ): โดยทั่วไปคุณไม่ได้ทดสอบหน่วยวิธีการส่วนตัวโดยตรง เนื่องจากเป็นข้อมูลส่วนบุคคลให้พิจารณารายละเอียดการใช้งาน ไม่มีใครเคยเรียกหนึ่งในพวกเขาและคาดหวังว่ามันจะทำงานในรูปแบบเฉพาะ คุณควรทดสอบส่วนต่อประสานสาธารณะแทน หากวิธีการที่เรียกวิธีการส่วนตัวของคุณทำงานได้ตามที่คุณคาดไว้คุณจะถือว่าส่วนขยายนั้นวิธีส่วนตัวของคุณทำงานอย่างถูกต้อง ที่มา: คุณทำการทดสอบวิธีการส่วนตัวอย่างไร สถานการณ์ ฉันพยายามทดสอบระบบการประมวลผลข้อมูลที่เป็นรัฐ ระบบสามารถทำสิ่งที่แตกต่างกันสำหรับข้อมูลชิ้นเดียวกันที่ได้รับจากสถานะก่อนที่จะรับข้อมูลนั้น พิจารณาการทดสอบที่ตรงไปตรงมาที่สร้างสถานะขึ้นในระบบจากนั้นทดสอบพฤติกรรมที่วิธีการที่กำหนดไว้มีวัตถุประสงค์เพื่อทดสอบ SAP แนะนำว่าฉันไม่ควรทดสอบ "ขั้นตอนการสร้างรัฐ" ฉันควรสมมติว่าสถานะเป็นสิ่งที่ฉันคาดหวังจากรหัสการสะสมแล้วทดสอบการเปลี่ยนสถานะเดียวที่ฉันพยายามทดสอบ PMP แนะนำว่าฉันไม่สามารถข้ามขั้นตอน "state build up" นี้ได้และเพียงทดสอบวิธีการที่ควบคุมการทำงานนั้นอย่างอิสระ ผลลัพธ์ในรหัสจริงของฉันคือการทดสอบที่มีการป่องซับซ้อนซับซ้อนยาวและยากที่จะเขียน และหากการเปลี่ยนสถานะเปลี่ยนไปการทดสอบจะต้องเปลี่ยน ... ซึ่งจะดีกับการทดสอบขนาดเล็กที่มีประสิทธิภาพ แต่ใช้เวลานานมากและสับสนกับการทดสอบแบบป่องยาวเหล่านี้ ปกติแล้วจะทำอย่างไร?

20 design  unit-testing  tdd 

ฉันต้องการสอนตัวเองให้ใช้วิธีการของ TDD และฉันก็มีโครงการที่ฉันอยากจะทำอยู่พักหนึ่ง มันไม่ใช่โครงการขนาดใหญ่ดังนั้นฉันคิดว่ามันจะเป็นตัวเลือกที่ดีสำหรับ TDD อย่างไรก็ตามฉันรู้สึกว่ามีบางอย่างผิดปกติ ขอยกตัวอย่าง: ในระดับสูงโครงการของฉันเป็นส่วนเสริมสำหรับ Microsoft OneNote ที่จะให้ฉันติดตามและจัดการโครงการได้ง่ายขึ้น ตอนนี้ฉันยังต้องการให้ตรรกะทางธุรกิจสำหรับสิ่งนี้แยกออกจาก OneNote มากที่สุดในกรณีที่ฉันตัดสินใจที่จะสร้างที่เก็บข้อมูลที่กำหนดเองของฉันเองและกลับมาสิ้นสุดวันหนึ่ง ก่อนอื่นฉันเริ่มต้นด้วยการทดสอบการยอมรับคำธรรมดาเบื้องต้นเพื่อสรุปสิ่งที่ฉันต้องการให้คุณสมบัติแรกของฉันทำ ดูเหมือนบางสิ่งนี้ (ทำให้ลดความกระชับลง): ผู้ใช้คลิกสร้างโครงการ ผู้ใช้พิมพ์ชื่อเรื่องของโครงการ ตรวจสอบว่าโครงการสร้างขึ้นอย่างถูกต้อง ข้ามสิ่งที่ UI และการวางแผนตัวกลางฉันมาทดสอบหน่วยแรกของฉัน: [TestMethod] public void CreateProject_BasicParameters_ProjectIsValid() { var testController = new Controller(); Project newProject = testController(A.Dummy<String>()); Assert.IsNotNull(newProject); } จนถึงตอนนี้ดีมาก สีแดงเขียว refactor ฯลฯ เอาล่ะตอนนี้มันต้องการบันทึกของจริง ตัดขั้นตอนที่นี่ฉันปิดท้ายด้วยสิ่งนี้ [TestMethod] public void CreateProject_BasicParameters_ProjectMatchesExpected() { …

20 c#  agile  unit-testing  tdd  refactoring 

TL; DR การเขียนแบบทดสอบที่ดีและมีประโยชน์นั้นยากและมีค่าใช้จ่ายสูงในภาษาซีพลัสพลัส นักพัฒนาที่มีประสบการณ์คุณสามารถแบ่งปันเหตุผลของคุณเกี่ยวกับอะไรและเวลาที่จะทดสอบ? เรื่องยาว ฉันเคยทำการพัฒนาที่ขับเคลื่อนด้วยการทดสอบทั้งทีมจริง ๆ แล้ว แต่มันก็ไม่ได้ผลสำหรับเรา เรามีการทดสอบมากมาย แต่ดูเหมือนว่าพวกเขาจะไม่ครอบคลุมกรณีที่เรามีข้อบกพร่องและการถดถอยจริงซึ่งมักจะเกิดขึ้นเมื่อมีการโต้ตอบหน่วยไม่ใช่จากพฤติกรรมที่แยกได้ นี่เป็นเรื่องยากมากที่จะทดสอบในระดับหน่วยที่เราหยุดทำ TDD (ยกเว้นส่วนประกอบที่ทำให้การพัฒนาเร็วขึ้น) และใช้เวลาเพิ่มการครอบคลุมการทดสอบการรวมแทน ในขณะที่การทดสอบหน่วยขนาดเล็กไม่เคยตรวจจับข้อบกพร่องจริง ๆ และเป็นเพียงค่าบำรุงรักษา แต่การทดสอบการรวมนั้นคุ้มค่ากับความพยายาม ตอนนี้ฉันได้รับโปรเจ็กต์ใหม่และฉันสงสัยว่าจะลองทำอย่างไร มันเป็นแอพพลิเคชั่น C ++ / OpenGL ดั้งเดิมดังนั้นการทดสอบการรวมเข้าด้วยกันจึงไม่ใช่ทางเลือก แต่การทดสอบหน่วยใน C ++ นั้นค่อนข้างยากกว่าใน Java (คุณต้องทำสิ่งต่าง ๆ อย่างชัดเจนvirtual) และโปรแกรมไม่ได้เน้นวัตถุมากดังนั้นฉันจึงไม่สามารถเยาะเย้ย / ทำอะไรบางอย่างได้ ฉันไม่ต้องการแยกออกจากกันและ OO-ize ทุกสิ่งเพียงเพื่อเขียนการทดสอบเพื่อประโยชน์ในการเขียนการทดสอบ ดังนั้นฉันถามคุณ: ฉันควรเขียนทดสอบอะไร เช่น: ฟังก์ชั่น / คลาสที่ฉันคาดว่าจะเปลี่ยนบ่อย? ฟังก์ชั่น / คลาสที่ยากต่อการทดสอบด้วยตนเอง? ฟังก์ชั่น …

20 c++  unit-testing  tdd  integration-tests 

SortedDictionnary<DateTime, double>ฉันเพิ่งได้รับการออกแบบโมดูลอนุกรมเวลาที่อนุกรมเวลาของฉันเป็นหลัก ตอนนี้ฉันต้องการสร้างการทดสอบหน่วยเพื่อให้แน่ใจว่าโมดูลนี้ทำงานได้ตลอดเวลาและให้ผลลัพธ์ที่คาดหวัง การดำเนินการทั่วไปคือการคำนวณประสิทธิภาพระหว่างจุดต่างๆในอนุกรมเวลา ดังนั้นสิ่งที่ฉันทำคือสร้างอนุกรมเวลาด้วยพูด {1.0, 2.0, 4.0} (ในบางวันที่) และฉันคาดว่าผลลัพธ์จะเป็น {100%, 100%} สิ่งนี้คือถ้าฉันสร้างอนุกรมเวลาด้วยตนเองด้วยค่า {1.0, 1.0} และฉันตรวจสอบความเท่าเทียมกัน (โดยการเปรียบเทียบแต่ละจุด) การทดสอบจะไม่ผ่านเนื่องจากจะมีความไม่ถูกต้องเสมอเมื่อทำงานกับการเป็นตัวแทนไบนารีของจริง หมายเลข ดังนั้นฉันตัดสินใจที่จะสร้างฟังก์ชั่นต่อไปนี้: private static bool isCloseEnough(double expected, double actual, double tolerance=0.002) { return squaredDifference(expected, actual) < Math.Pow(tolerance,2); } มีวิธีจัดการกรณีเช่นนี้อีกวิธีหนึ่งหรือไม่?

20 .net  unit-testing  numbers 

บันทึกเบื้องต้น ฉันจะไม่เข้าไปในความแตกต่างของชนิดที่แตกต่างกันของการทดสอบมีมีอยู่แล้วไม่กี่คำถามในเว็บไซต์เหล่านี้เกี่ยวกับการที่ ฉันจะใช้สิ่งที่มีและที่กล่าวว่า: การทดสอบหน่วยในแง่ของ "การทดสอบหน่วยแยกได้ที่เล็กที่สุดของแอปพลิเคชัน"ซึ่งคำถามนี้มาจริง ปัญหาการแยกตัว คืออะไรหน่วย isolatable ที่เล็กที่สุดของโปรแกรม อย่างที่ฉันเห็นมันขึ้นอยู่กับว่าคุณกำลังใช้ภาษาอะไร Micheal Feathers พูดถึงแนวคิดของรอยต่อ : [WEwLC, p31] ตะเข็บเป็นสถานที่ที่คุณสามารถเปลี่ยนพฤติกรรมในโปรแกรมของคุณโดยไม่ต้องแก้ไขในสถานที่นั้น และโดยไม่ต้องลงรายละเอียดฉันเข้าใจตะเข็บ - ในบริบทของการทดสอบหน่วย - เป็นสถานที่ในโปรแกรมที่ "การทดสอบ" ของคุณสามารถเชื่อมต่อกับ "หน่วย" ของคุณ ตัวอย่าง การทดสอบหน่วย - โดยเฉพาะอย่างยิ่งใน C ++ ต้องการรหัสจากการทดสอบเพื่อเพิ่มตะเข็บเพิ่มเติมที่จะถูกเรียกอย่างเคร่งครัดสำหรับปัญหาที่ระบุ ตัวอย่าง: การเพิ่มอินเทอร์เฟซเสมือนซึ่งการใช้งานที่ไม่ใช่เสมือนจะเพียงพอ การแยก - การสรุป (?) - คลาส (เล็ก) เพิ่มเติม "เพียงแค่" เพื่ออำนวยความสะดวกในการเพิ่มการทดสอบ การแยกโครงการที่ดำเนินการได้ครั้งเดียวออกเป็น libs ที่ "อิสระ" ดูเหมือน …

20 c++  unit-testing  tdd  generalization