การทดสอบหน่วยรหัส C [ปิด]

ฉันทำงานในระบบฝังตัวในฤดูร้อนนี้เขียนตรง C. เป็นโครงการที่มีอยู่แล้วซึ่ง บริษัท ที่ฉันทำงานเพื่อรับช่วงต่อ ฉันคุ้นเคยกับการเขียนการทดสอบหน่วยใน Java โดยใช้ JUnit แต่เป็นวิธีที่ดีที่สุดในการเขียนการทดสอบหน่วยสำหรับโค้ดที่มีอยู่

มีโครงการใดบ้างที่ทำให้การทดสอบหน่วย C รหัสธรรมดาง่ายเหมือนการทดสอบหน่วยรหัส Java กับ JUnit? ความเข้าใจใด ๆ ที่จะนำไปใช้กับการพัฒนาโดยเฉพาะ (การคอมไพล์ข้ามกับแพลตฟอร์ม arm-linux) จะได้รับการชื่นชมอย่างมาก

กรอบการทดสอบหน่วยหนึ่งใน C คือตรวจสอบ ; รายการกรอบการทดสอบหน่วยใน C สามารถพบได้ที่นี่และทำซ้ำด้านล่าง ขึ้นอยู่กับจำนวนไลบรารี่มาตรฐานที่คุณใช้ในการใช้งานจริงคุณอาจใช้หรือไม่สามารถใช้ได้

AceUnit

AceUnit (Advanced C และหน่วยฝังตัว) เรียกเก็บเงินเองว่าเป็นกรอบการทดสอบหน่วยรหัส C ที่สะดวกสบาย มันพยายามเลียนแบบ JUnit 4.x และรวมถึงความสามารถในการสะท้อนกลับ AceUnit สามารถใช้ในสภาพแวดล้อมที่มีข้อ จำกัด ของทรัพยากรเช่นการพัฒนาซอฟต์แวร์แบบฝังตัวและที่สำคัญมันทำงานได้ดีในสภาพแวดล้อมที่คุณไม่สามารถรวมไฟล์ส่วนหัวมาตรฐานเดียวและไม่สามารถเรียกใช้ฟังก์ชัน C มาตรฐานเดียวจากไลบรารี ANSI / ISO C นอกจากนี้ยังมีพอร์ต Windows มันไม่ได้ใช้ส้อมเพื่อดักจับสัญญาณแม้ว่าผู้เขียนได้แสดงความสนใจในการเพิ่มคุณสมบัติดังกล่าว ดูหน้าแรก AceUnit

GNU Autounit

ในแนวเดียวกันกับการตรวจสอบรวมถึงการทำการทดสอบหน่วยในพื้นที่ที่อยู่แยกต่างหาก (ในความเป็นจริงผู้แต่งดั้งเดิมของ Check ได้ยืมแนวคิดจาก GNU Autounit) GNU Autounit ใช้ GLib อย่างกว้างขวางซึ่งหมายความว่าการเชื่อมโยงและต้องการตัวเลือกพิเศษ แต่นี่อาจไม่ใช่ปัญหาใหญ่สำหรับคุณโดยเฉพาะถ้าคุณใช้ GTK หรือ GLib อยู่แล้ว ดูที่หน้าแรกของ GNU Autounit

Cunit

ใช้ GLib ด้วย แต่ไม่แยกเพื่อป้องกันพื้นที่ที่อยู่ของการทดสอบหน่วย

Cunit

Standard C พร้อมแผนสำหรับการนำ Win32 GUI ไปใช้ ไม่แยกหรือป้องกันพื้นที่ที่อยู่ของการทดสอบหน่วยในปัจจุบัน ในช่วงต้นของการพัฒนา ดูหน้าแรก Cunit

น่ารัก

เฟรมเวิร์กอย่างง่าย ๆ ที่มีเพียงหนึ่งไฟล์. c และไฟล์. h ไฟล์เดียวที่คุณดรอปไว้ในแผนผังต้นไม้ต้นทางของคุณ ดูหน้าแรกน่ารัก

CppUnit

กรอบการทดสอบหน่วยชั้นนำสำหรับ C ++; คุณสามารถใช้มันเพื่อทดสอบรหัส C มันเสถียรพัฒนาอย่างแข็งขันและมีส่วนต่อประสาน GUI เหตุผลหลักที่จะไม่ใช้ CppUnit สำหรับ C เป็นอันดับแรกซึ่งค่อนข้างใหญ่และอันดับสองคุณต้องเขียนการทดสอบใน C ++ ซึ่งหมายความว่าคุณต้องมี C ++ คอมไพเลอร์ หากสิ่งเหล่านี้ดูเหมือนไม่น่ากังวลมันก็คุ้มค่าที่จะต้องพิจารณาควบคู่ไปกับกรอบการทดสอบหน่วย C ++ อื่น ๆ ดูหน้าแรก CppUnit

embUnit

embUnit (หน่วยฝังตัว) เป็นอีกหนึ่งกรอบการทดสอบหน่วยสำหรับระบบฝังตัว ดูเหมือนว่าสิ่งนี้จะถูกแทนที่โดย AceUnit หน้าแรกหน่วยสมองกลฝังตัว

MinUnit

มาโครชุดเล็ก ๆ น้อย ๆ และนั่นแหละ! ประเด็นคือเพื่อแสดงให้เห็นว่าการทดสอบโค้ดของคุณนั้นง่ายเพียงใด ดูหน้าแรก MinUnit

CUnit สำหรับนาย Ando

การใช้ CUnit ที่ค่อนข้างใหม่และเห็นได้ชัดว่ายังอยู่ในช่วงต้นของการพัฒนา ดูCunit หน้าแรกนาย

รายการนี้ได้รับการปรับปรุงล่าสุดในเดือนมีนาคม 2008

กรอบเพิ่มเติม:

CMocka

CMocka เป็นกรอบการทดสอบสำหรับ C ด้วยการสนับสนุนวัตถุจำลอง ใช้งานและตั้งค่าได้ง่าย

ดูที่หน้าแรกของ CMocka

เกณฑ์

เกณฑ์เป็นกรอบการทดสอบหน่วยข้ามแพลตฟอร์ม C ที่รองรับการลงทะเบียนทดสอบอัตโนมัติ, การทดสอบพารามิเตอร์, ทฤษฎีและที่สามารถส่งออกไปยังหลายรูปแบบรวมถึง TAP และ JUnit XML การทดสอบแต่ละครั้งจะดำเนินการในกระบวนการของตนเองดังนั้นสัญญาณและการขัดข้องสามารถรายงานหรือทดสอบได้หากจำเป็น

ดูหน้าแรกของเกณฑ์สำหรับข้อมูลเพิ่มเติม

HWUT

HWUT เป็นเครื่องมือทดสอบหน่วยทั่วไปที่รองรับ C. ได้อย่างดีมันสามารถช่วยสร้าง Makefiles สร้างกรณีทดสอบขนาดใหญ่ที่เขียนใน 'ตารางการทำซ้ำ' ขั้นต่ำเดินไปตามเครื่องจักรของรัฐสร้าง C-stub และอื่น ๆ วิธีการทั่วไปไม่เหมือนใคร: Verdicts นั้นมาจาก 'stdout ที่ดี / stdout ที่ไม่ดี' อย่างไรก็ตามฟังก์ชั่นการเปรียบเทียบมีความยืดหยุ่น ดังนั้นสคริปต์ประเภทใดก็ได้ที่สามารถใช้สำหรับการตรวจสอบ อาจใช้กับภาษาใดก็ได้ที่สามารถสร้างเอาต์พุตมาตรฐาน

ดูที่หน้าแรกของ HWUT

CGreen

การทดสอบหน่วยข้ามภาษาที่ทันสมัยพกพาและกรอบการเยาะเย้ยสำหรับ C และ C ++ มันมีสัญลักษณ์ BDD ซึ่งเป็นตัวเลือกไลบรารีการเยาะเย้ยความสามารถในการเรียกใช้ในกระบวนการเดียว (เพื่อให้การดีบักง่ายขึ้น) นักวิ่งทดสอบที่ค้นพบโดยอัตโนมัติฟังก์ชั่นการทดสอบที่มีอยู่ แต่คุณสามารถสร้างโปรแกรมของคุณเองได้

คุณสมบัติทั้งหมดเหล่านั้น (และอื่น ๆ ) มีการอธิบายในคู่มือ CGreen

Wikipedia ให้รายละเอียดเกี่ยวกับกรอบการทดสอบหน่วย C ภายใต้รายการกรอบการทดสอบหน่วย: C

ส่วนตัวผมชอบกรอบการทำงานของ Google ทดสอบ

ความยากลำบากที่แท้จริงในการทดสอบรหัส C คือการทำลายการพึ่งพาโมดูลภายนอกดังนั้นคุณจึงสามารถแยกรหัสในหน่วย ซึ่งอาจเป็นปัญหาโดยเฉพาะอย่างยิ่งเมื่อคุณพยายามรับการทดสอบเกี่ยวกับรหัสดั้งเดิม ในกรณีนี้ฉันมักจะพบว่าตัวเองใช้ linker เพื่อใช้ฟังก์ชั่นสมบูรณ์ในการทดสอบ

นี่คือสิ่งที่ผู้คนพูดถึงเมื่อพวกเขาพูดถึง " ตะเข็บ " ใน C ตัวเลือกเดียวของคุณคือใช้ตัวประมวลผลล่วงหน้าหรือตัวเชื่อมโยงเพื่อจำลองการอ้างอิงของคุณ

ชุดทดสอบทั่วไปในหนึ่งในโครงการ C ของฉันอาจมีลักษณะเช่นนี้:

#include "myimplementationfile.c"
#include <gtest/gtest.h>

// Mock out external dependency on mylogger.o
void Logger_log(...){}

TEST(FactorialTest, Zero) {
    EXPECT_EQ(1, Factorial(0));
}

โปรดทราบว่าคุณเป็นจริงรวมทั้งไฟล์ C และไม่ไฟล์ส่วนหัว สิ่งนี้ให้ประโยชน์จากการเข้าถึงสมาชิกข้อมูลคงที่ทั้งหมด ที่นี่ฉันจำลอง logger ของฉัน (ซึ่งอาจอยู่ใน logger.o และให้การใช้งานที่ว่างเปล่าซึ่งหมายความว่าไฟล์ทดสอบรวบรวมและเชื่อมโยงอย่างอิสระจากส่วนที่เหลือของรหัสฐานและดำเนินการแยก

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

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

ไมเคิลขนมีหนังสือที่ดีเกี่ยวกับการทดสอบรหัสเดิม ในบทที่หนึ่งเขาครอบคลุมเทคนิคต่าง ๆ สำหรับการจัดการกับรหัสที่ไม่ใช่ OO ซึ่งฉันขอแนะนำ

แก้ไข : ฉันได้เขียนบล็อกโพสต์เกี่ยวกับหน่วยทดสอบรหัสขั้นตอนที่มีแหล่งที่มาที่มีอยู่บน GitHub

แก้ไข : มีหนังสือเล่มใหม่ออกมาจาก Pragmatic โปรแกรมเมอร์ที่เน้นรหัสการทดสอบหน่วย C ซึ่งฉันขอแนะนำเป็นพิเศษ

Minunitเป็นกรอบการทดสอบหน่วยง่าย ๆ อย่างไม่น่าเชื่อ ฉันใช้มันเพื่อทดสอบหน่วย c รหัสไมโครคอนโทรลเลอร์สำหรับ avr

ขณะนี้ฉันกำลังใช้กรอบการทดสอบหน่วย CuTest:

http://cutest.sourceforge.net/

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

• ไฟล์ส่วนหัวรวมอยู่ทุกที่ที่คุณเรียกรูทีน CuTest
• ไฟล์ 'C' เพิ่มเติมหนึ่งรายการที่จะรวบรวม / เชื่อมโยงไปยังภาพ
• เพิ่มรหัสง่าย ๆ ให้กับ main เพื่อตั้งค่าและเรียกการทดสอบหน่วย - ฉันมีสิ่งนี้ในฟังก์ชั่น main () พิเศษที่ได้รับการคอมไพล์หากกำหนด UNITTEST ระหว่างการสร้าง

ระบบจำเป็นต้องสนับสนุนฮีปและฟังก์ชั่น stdio บางอย่าง (ซึ่งไม่ใช่ระบบที่ฝังอยู่ทั้งหมด) แต่รหัสนั้นง่ายพอที่คุณจะสามารถทำงานแทนข้อกำหนดเหล่านั้นได้หากแพลตฟอร์มของคุณไม่มี

ด้วยการใช้บล็อก "C" จากภายนอกอย่างรอบคอบก็ช่วยสนับสนุนการทดสอบ C ++ ได้ด้วย

ฉันพูดเกือบจะเหมือนกับ ratkok แต่ถ้าคุณมีการบิดตัวที่ฝังตัวกับการทดสอบหน่วยแล้ว ...

Unity - เฟรมเวิร์กที่แนะนำสูงสำหรับการทดสอบหน่วยรหัส C

ตัวอย่างในหนังสือที่กล่าวถึงในหัวข้อนี้TDD สำหรับ C ฝังตัวจะถูกเขียนโดยใช้ Unity (และ CppUTest)

คุณอาจต้องการลองดูที่libtapซึ่งเป็นกรอบการทดสอบ C ซึ่งแสดงผลลัพธ์ Test Anything Protocol (TAP) และรวมเข้ากับเครื่องมือที่หลากหลายสำหรับเทคโนโลยีนี้ ส่วนใหญ่จะใช้ในโลกของภาษาแบบไดนามิก แต่มันใช้งานง่ายและเป็นที่นิยมมาก

ตัวอย่าง:

#include <tap.h>

int main () {
    plan(5);

    ok(3 == 3);
    is("fnord", "eek", "two different strings not that way?");
    ok(3 <= 8732, "%d <= %d", 3, 8732);
    like("fnord", "f(yes|no)r*[a-f]$");
    cmp_ok(3, ">=", 10);

    done_testing();
}

มีความสง่างามหน่วยทดสอบกรอบสำหรับ C ด้วยการสนับสนุนสำหรับวัตถุจำลองที่เรียกว่าเป็นcmocka มันต้องใช้ไลบรารี C มาตรฐานเท่านั้นทำงานในช่วงของแพลตฟอร์มการคำนวณ (รวมถึงแบบฝัง) และคอมไพเลอร์ที่แตกต่าง

นอกจากนี้ยังรองรับรูปแบบเอาต์พุตข้อความที่แตกต่างกันเช่น Subunit, Test Anything Protocol และรายงาน jUnit XML

cmocka ถูกสร้างขึ้นเพื่อใช้งานบนแพลตฟอร์มแบบฝังและรองรับ Windows ได้เช่นกัน

การทดสอบอย่างง่ายมีลักษณะดังนี้:

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>

/* A test case that does nothing and succeeds. */
static void null_test_success(void **state) {
    (void) state; /* unused */
}

int main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(null_test_success),
    };
    return cmocka_run_group_tests(tests, NULL, NULL);
}

APIเป็นเอกสารอย่างเต็มที่และหลายตัวอย่างที่เป็นส่วนหนึ่งของรหัสที่มา

ในการเริ่มต้นกับ cmocka คุณควรอ่านบทความเกี่ยวกับ LWN.net: การทดสอบหน่วยด้วยวัตถุจำลองใน C

cmocka 1.0 เปิดตัวเมื่อเดือนกุมภาพันธ์ 2558

ฉันไม่ได้ทดสอบแอปพลิเคชั่น C รุ่นเก่ามากนักก่อนที่จะเริ่มมองหาวิธีการเลียนแบบฟังก์ชั่น ฉันต้องการ mocks ไม่ดีเพื่อแยกไฟล์ C ที่ฉันต้องการทดสอบจากคนอื่น ๆ ฉันลองใช้ cmock แล้วและฉันคิดว่าฉันจะยอมรับมัน

Cmock สแกนไฟล์ส่วนหัวและสร้างฟังก์ชั่นการเยาะเย้ยตามต้นแบบที่พบ Mocks จะช่วยให้คุณทดสอบไฟล์ C ในการแยกที่สมบูรณ์แบบ สิ่งที่คุณต้องทำคือเชื่อมโยงไฟล์ทดสอบกับ mocks แทนไฟล์ออบเจ็กต์จริงของคุณ

ข้อดีอีกอย่างของ cmock คือมันจะตรวจสอบพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันที่เยาะเย้ย สิ่งนี้มีประโยชน์มากในการทดสอบโฟลว์การทำงานต่าง ๆ ในฟังก์ชันของคุณ

การทดสอบประกอบด้วยฟังก์ชั่น testA (), testB () ที่คุณสร้างความคาดหวังฟังก์ชั่นการโทรเพื่อทดสอบและตรวจสอบการยืนยัน

ขั้นตอนสุดท้ายคือการสร้างนักวิ่งสำหรับการทดสอบของคุณด้วยความสามัคคี Cmock เชื่อมโยงกับกรอบการทดสอบความสามัคคี ความสามัคคีนั้นง่ายต่อการเรียนรู้เหมือนกับกรอบการทดสอบหน่วยอื่น ๆ

คุ้มค่าที่จะลองและเข้าใจง่าย:

http://sourceforge.net/apps/trac/cmock/wiki

อัปเดต 1

อีกกรอบที่ฉันกำลังตรวจสอบคือ Cmockery

http://code.google.com/p/cmockery/

เป็นกรอบ C บริสุทธิ์ที่รองรับการทดสอบหน่วยและการเยาะเย้ย ไม่มีการพึ่งพา ruby ​​(ตรงกันข้ามกับ Cmock) และมีการพึ่งพา libs น้อยมาก

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

ไม่จำเป็นต้องมีนักวิ่งทดสอบพิเศษ คุณจะต้องสร้างอาร์เรย์ของการทดสอบและส่งไปยังฟังก์ชัน run_tests ทำงานด้วยตัวเองอีกเล็กน้อยที่นี่เช่นกัน แต่ฉันชอบแนวคิดของกรอบการทำงานแบบอิสระในตัวเอง

รวมทั้งมีเคล็ดลับ C ที่ดีที่ฉันไม่รู้

Cmockery โดยรวมต้องการความเข้าใจเพิ่มเติมเกี่ยวกับ mocks เพื่อเริ่มต้น ตัวอย่างควรช่วยคุณเอาชนะสิ่งนี้ ดูเหมือนว่าจะสามารถทำงานได้ด้วยกลไกที่ง่ายกว่า

ในฐานะมือใหม่ซีฉันพบว่าสไลด์ที่เรียกว่าTest driven development ใน Cเป็นประโยชน์อย่างมาก โดยทั่วไปจะใช้มาตรฐานassert()ร่วมกับ&&เพื่อส่งข้อความโดยไม่มีการอ้างอิงภายนอกใด ๆ หากมีคนคุ้นเคยกับกรอบการทดสอบสแต็กเต็มรูปแบบนี่อาจจะไม่เกิดขึ้น :)

เราเขียนCHEAT (โฮสต์บนGitHub ) เพื่อการใช้งานและพกพาง่าย

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

#include <cheat.h>

CHEAT_TEST(mathematics_still_work,
    cheat_assert(2 + 2 == 4);
    cheat_assert_not(2 + 2 == 5);
)

การทดสอบรวบรวมเป็นปฏิบัติการที่ดูแลการทดสอบและรายงานผลของพวกเขา

$ gcc -I . tests.c
$ ./a.out
..
---
2 successful of 2 run
SUCCESS

มันก็มีสีที่สวยเช่นกัน

นั่นคือ CUnit

และ หน่วยฝังตัวเป็นกรอบการทดสอบหน่วยสำหรับระบบ C ฝังตัว การออกแบบถูกคัดลอกมาจาก JUnit และ CUnit และอื่น ๆ จากนั้นปรับให้เหมาะสำหรับระบบสมองกลฝังตัว หน่วยฝังตัวไม่ต้องการ std C libs วัตถุทั้งหมดถูกจัดสรรให้กับพื้นที่ const

และTessyทำการทดสอบหน่วยของซอฟต์แวร์ฝังตัวโดยอัตโนมัติ

ฉันไม่ได้ใช้เฟรมเวิร์กฉันแค่ใช้ autotools "ตรวจสอบ" การสนับสนุนเป้าหมาย ใช้ "หลัก" และใช้การยืนยัน

ทดสอบ dir Makefile.am ของฉันดูเหมือนว่า:

check_PROGRAMS = test_oe_amqp

test_oe_amqp_SOURCES = test_oe_amqp.c
test_oe_amqp_LDADD = -L$(top_builddir)/components/common -loecommon
test_oe_amqp_CFLAGS = -I$(top_srcdir)/components/common -static

TESTS = test_oe_amqp

หนังสือของ Michael Feather "การทำงานอย่างมีประสิทธิภาพกับ Legacy Code" นำเสนอเทคนิคมากมายสำหรับการทดสอบหน่วยในระหว่างการพัฒนา C

มีเทคนิคที่เกี่ยวข้องกับการฉีดพึ่งพาที่เฉพาะเจาะจงกับ C ซึ่งฉันไม่ได้เห็นที่อื่น

CppUTest - เฟรมเวิร์กที่แนะนำสูงสำหรับหน่วยการทดสอบรหัส C

ตัวอย่างในหนังสือที่กล่าวถึงในหัวข้อนี้TDD สำหรับ C ฝังตัวเขียนโดยใช้ CppUTest

ฉันใช้CxxTestสำหรับสภาพแวดล้อม c / c ++ แบบฝัง (ส่วนใหญ่ C ++)

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

ดังกล่าวก่อนหน้านี้มันเป็นกรอบการทดสอบหน่วย C / C ++ ดังนั้นคุณจะต้องคอมไพเลอร์ C ++

คู่มือผู้ใช้ CxxTest CxxTest Wiki

นอกเหนือจากความลำเอียงที่ชัดเจนของฉัน

http://code.google.com/p/seatest/

เป็นวิธีง่ายๆในการทดสอบโค้ด C ของยูนิต เลียนแบบ xUnit

หลังจากอ่าน Minunit ฉันคิดว่าวิธีที่ดีกว่าคือการทดสอบใน assert macro ซึ่งฉันใช้เทคนิคการป้องกันโปรแกรมเป็นจำนวนมาก ดังนั้นฉันจึงใช้แนวคิดเดียวกันกับ Minunit ผสมกับการรับรองมาตรฐาน คุณสามารถเห็นกรอบของฉัน (ชื่อที่ดีอาจเป็น NoMinunit) ในบล็อกของ k0ga

cmockery ที่http://code.google.com/p/cmockery/

Google มีกรอบการทดสอบที่ยอดเยี่ยม https://github.com/google/googletest/blob/master/googletest/docs/primer.md

และใช่เท่าที่ฉันเห็นมันจะทำงานกับ C ธรรมดานั่นคือไม่ต้องใช้คุณสมบัติ C ++ (อาจต้องใช้คอมไพเลอร์ C ++ ไม่แน่ใจ)

Cmockeryเป็นโครงการที่เพิ่งเปิดตัวซึ่งประกอบด้วยไลบรารี C ที่ใช้งานง่ายสำหรับการเขียนการทดสอบหน่วย

อันดับแรกดูที่นี่: http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C

บริษัท ของฉันมีห้องสมุด C ที่ลูกค้าของเราใช้ เราใช้ CxxTest (ไลบรารีทดสอบหน่วย C ++) เพื่อทดสอบรหัส CppUnit จะทำงานเช่นกัน หากคุณติดอยู่ใน C ฉันขอแนะนำ RCUNIT (แต่ CUnit ก็ดีเหมือนกัน)

หากคุณคุ้นเคยกับ JUnit ฉันแนะนำ CppUnit http://cppunit.sourceforge.net/cppunit-wiki

นั่นคือสมมติว่าคุณมีคอมไพเลอร์ c ++ เพื่อทำการทดสอบหน่วย ถ้าไม่เช่นนั้นฉันต้องยอมรับกับ Adam Rosenfield ว่าการตรวจสอบเป็นสิ่งที่คุณต้องการ

ฉันใช้RCUNITทำการทดสอบหน่วยสำหรับโค้ดฝังตัวบนพีซีก่อนทดสอบเป้าหมาย อินเทอร์เฟซฮาร์ดแวร์ที่ดีเป็นสิ่งสำคัญสิ่งอื่น endianness และการลงทะเบียนหน่วยความจำแมปจะฆ่าคุณ

ลอง lcut! - http://code.google.com/p/lcut

API Sanity Checker - กรอบการทดสอบสำหรับไลบรารี C / C ++:

เครื่องกำเนิดไฟฟ้าอัตโนมัติของการทดสอบหน่วยพื้นฐานสำหรับไลบรารี C / C ++ ที่ใช้ร่วมกัน มันสามารถสร้างข้อมูลที่สมเหตุสมผล (ส่วนใหญ่ แต่น่าเสียดายที่ไม่ใช่ทุกกรณี) ข้อมูลอินพุตสำหรับพารามิเตอร์และเขียนกรณีทดสอบง่ายๆ ("สติปัญญา" หรือ "ตื้น" - คุณภาพ) สำหรับทุกฟังก์ชั่นใน API ผ่านการวิเคราะห์การประกาศในส่วนหัว ไฟล์

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

ตัวอย่าง:

• ชุดทดสอบสำหรับ fontconfig 2.8.0
• ชุดทดสอบสำหรับ FreeType 2.4.8

เทคนิคหนึ่งที่ใช้คือการพัฒนารหัสทดสอบหน่วยด้วยกรอบ C ++ xUnit (และคอมไพเลอร์ C ++) ในขณะที่รักษาแหล่งข้อมูลสำหรับระบบเป้าหมายเป็นโมดูล C

ตรวจสอบให้แน่ใจว่าคุณคอมไพล์แหล่ง C ของคุณเป็นประจำภายใต้ cross-compiler ของคุณโดยอัตโนมัติด้วยการทดสอบหน่วยของคุณถ้าเป็นไปได้

LibU ( http://koanlogic.com/libu ) มีโมดูลทดสอบหน่วยที่อนุญาตการทดสอบชุด / กรณีที่ชัดเจนการแยกการทดสอบการประมวลผลแบบขนานและฟอร์แมตรายงานที่ปรับแต่งได้ (รูปแบบเริ่มต้นคือ xml และ txt)

ไลบรารี่ได้รับอนุญาตจาก BSD และมีโมดูลที่มีประโยชน์อื่น ๆ อีกมากมาย - เครือข่าย, การดีบัก, โครงสร้างข้อมูลที่ใช้กันทั่วไป, การกำหนดค่า, ฯลฯ - หากคุณต้องการมันในโครงการของคุณ ...

ฉันประหลาดใจที่ไม่มีใครพูดถึงคัตเตอร์ (http://cutter.sourceforge.net/) คุณสามารถทดสอบ C และ C ++ ได้มันทำงานร่วมกับ autotools ได้อย่างราบรื่นและมีการสอนที่ดีมาก

ในกรณีที่คุณกำหนดเป้าหมายแพลตฟอร์ม Win32 หรือโหมดเคอร์เนล NT คุณควรมีลักษณะที่cfix

หากคุณยังอยู่ในระหว่างการหากรอบการทดสอบCUnitWin32เป็นแพลตฟอร์มสำหรับ Win32 / NT

นี่เป็นการแก้ปัญหาพื้นฐานอย่างหนึ่งที่ฉันต้องเผชิญกับกรอบการทดสอบอื่น ๆ ตัวแปรโกลบอล / สแตติกกล่าวคืออยู่ในสถานะที่กำหนดได้เนื่องจากการทดสอบแต่ละครั้งจะดำเนินการเป็นกระบวนการแยกต่างหาก