如何为C ++项目编写单元测试

Question

I am interested in applying unit tests to a growing personal project that I am making in C++. I am not formally trained in programming, but instead learned in on my own. As a result I never really learned how unit testing is typically done in C++. I have read lots and lots of info on the web about why unit testing is important, but I have not had as much luck in finding concrete examples about how unit testing is written into a C++ project. What I am currently doing is something like the following:

I have a special 'Test' class that only contains static methods. Each method tests one aspect of a class in my project. In concrete code it looks something like:

class Test
{
  public:
    static void test1();
    static void test2();
    static void test3();
};

Then in main I just call:

int main()
{
  Test::test1();
  Test::test2();
  Test::test3();
  //etc
}

Each test prints to the console saying whether it passed or not. Each test might test my other classes by initializing them, checking their methods for correct outputs, etc...

My questions: Is this a standard way of going through unit testing? I have also heard that you write tests directly into each of your classes (so they are just extra methods that happen to do testing). Then whenever you create an object of a class or call a method it will just run your tests as part of running your program. Is this a better, more standard way, of implementing unit testing? I am basically just trying to fully understand how exactly unit testing is typically implemented so if some one were to ask me about unit testing I can competently say that I know how to do it.

Answer 1

My personal experience is that I use Boost.Test. I use the header only implementation (just a preference). It will take you a day or so to read the documentation and start being productive. The benefit of using a testing library or framework is that you only code and see your tests and not the surrounding code that runs them.

My strategy, to write tests for a library, for example, is to have a single test file for each class in the library. That file has as many test as needed. The collection of test files create a separate executable that tests the library.

I would not recommend writing tests directly into your classes. I think it would just clutter you real code.

Answer 2

By way of example, here is how I convince myself that my implementations of the SHA-2 suite are still valid. After the SHA code, which is all in one file, there is this 200 lines of validation code at the end which provides a main() to verify.

#ifdef  DBG_SHA2_LIB

/*
 * sha2_lib.cpp main ():  verification and handy hashing program
 *
 * input:
 *  either no arguments (validates against the published test cases)
 *  or a list of filenames with options for which hashes to perform.
 *      sha2_lib -1 -2 -3 -5 filename...
 *
 * output:
 *  messages such as
 *
 *  validating functionality with published examples
 *  sha-160 1(3) okay
 *  sha-160 1(56) okay
 *  sha-160 1000000(1) okay
 *  ...
 *  sha-512 1(112) okay
 *  sha-512 verification failure:  1000000 repeats of "a"
 *  5cff29098832da24 fd1be5644357305c f132f5e100eb1fa0 a0cb6f2c11dfbb4c 36f00d94d4f9
 *  93ad 2eff9f94a9fa2902 92f8982b3bd115d4 f05f67cd0a4db196: computed
 *  e718483d0ce76964 4e2e42c7bc15b463 8e1f98b13b204428 5632a803afa973eb de0ff244877e
 *  a60a 4cb0432ce577c31b eb009c5c2c49aa2e 4eadb217ad8cc09b: expected value
 *
 *  -- or --
 *
 *   * * * File sha2_lib.csm: 0.34 seconds
 *  sha256: e62aec67 d6fd18bd fa700082 547b8733 f6ef2490 61a338b0 6ee82910 2d4e0900
 *
 *  * * * File sha2_lib.exe: 0.01 seconds
 *  sha256: 52a1ea6f 33fefba9 b1d8e039 f9af9fb7 766451b6 675ec5da 7d3db868 d056e3ea
 */

static void
verify (const char *computed, const char *correct, long rpt, const char *inp, int alg)
{
    if (!strcmp (computed, correct))
        printf ("sha-%d %ld(%d) okay\n", alg, rpt, strlen (inp));
    else    printf ("sha-%d verification failure:  %ld repeats of \"%s\"\n"
            "%s: computed\n"
            "%s: expected value\n\n"
            , alg, rpt, inp, computed, correct);
}

static void
chk (int hsize, const char *s, long rpt, const char *correct_value)
{
    SHA2CB  *cb = sha2_init (hsize);
    long    n = strlen (s);
    for (long j = 0;  j < rpt;  ++j)
        sha2_upd (cb, (_u8 *) s, n);
    sha2_end (cb);
    char    outbuf [SHA2_512_FMT_LEN];
    sha2_fmt (cb, outbuf, 16);
    verify (outbuf, correct_value, rpt, s, cb -> hash_size);
    sha2_close (cb);
}



int
main (int argc, char **argv)
{
    int j, n;
    FILE    *f;
static  _u8 buf [1024*20];

    if (argc == 1)
    {
        printf ("validating functionality with published examples\n");
        chk (160, "abc", 1, "a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d");
        chk (160, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
            1, "84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1");
        chk (160, "a", 1000000L,
            "34aa973c d4c4daa4 f61eeb2b dbad2731 6534016f");

        chk (256, "abc", 1, "ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad");
        chk (256, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
            1, "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1");
        chk (256, "a", 1000000L,
            "cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0");

        chk (384, "abc", 1,
            "cb00753f45a35e8b b5a03d699ac65007 272c32ab0eded163 "
            "1a8b605a43ff5bed 8086072ba1e7cc23 58baeca134c825a7");
        chk (384, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
            1,
            "09330c33f71147e8 3d192fc782cd1b47 53111b173b3b05d2 "
            "2fa08086e3b0f712 fcc7c71a557e2db9 66c3e9fa91746039");
        chk (384, "a", 1000000L,
            "9d0e1809716474cb 086e834e310a4a1c ed149e9c00f24852 "
            "7972cec5704c2a5b 07b8b3dc38ecc4eb ae97ddd87f3d8985");

        chk (512, "abc", 1,
            "ddaf35a193617aba cc417349ae204131 12e6fa4e89a97ea2 0a9eeee64b55d39a "
            "2192992a274fc1a8 36ba3c23a3feebbd 454d4423643ce80e 2a9ac94fa54ca49f");
        chk (512, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
            1,
            "8e959b75dae313da 8cf4f72814fc143f 8f7779c6eb9f7fa1 7299aeadb6889018 "
            "501d289e4900f7e4 331b99dec4b5433a c7d329eeb6dd2654 5e96e55b874be909");
        chk (512, "a", 1000000L,
            "e718483d0ce76964 4e2e42c7bc15b463 8e1f98b13b204428 5632a803afa973eb "
            "de0ff244877ea60a 4cb0432ce577c31b eb009c5c2c49aa2e 4eadb217ad8cc09b");
        return 0;
    }

    if (argc == 2 && !strcmp (argv [1], "rot_r"))
    {
        int64   v (1);

        for (int j = 0;  j < 68;  ++j)
        {
            int64 y = v.rot_r (j);
            printf ("%d: %s\n", j, y.to_x ((char *)buf));
        }
        return 0;
    }

    int opt_160 = 0, opt_256 = 0, opt_384 = 0, opt_512 = 0;
    int opt_bufsize = sizeof buf;

    for (j = 1;  j < argc;  ++j)
    {
        HS_TIMER    t0;
        int     def = 0;

        if (argv [j][0] == '-')
        {
            switch (argv [j][1])
            {
            case '1':   ++opt_160;  break;
            case '2':   ++opt_256;  break;
            case '3':   ++opt_384;  break;
            case '5':   ++opt_512;  break;
            case 'b':
                long v = strtol (&argv [j][2], NULL, 0);
                if (v <= 0  ||  v > sizeof buf)
                    fprintf (stderr, "invalid buffer size--ignored\n");
                else    opt_bufsize = (int) v;
                break;
            }
            continue;
        }

        // sure would be nice to do wildcard processing here
        f = fopen (argv [j], "rb");
        if (!f)
        {
            fprintf (stderr, "error opening '%s'", argv [j]);
            perror (" for read");
            continue;
        }

        HS_timer_reset (&t0);
        SHA2CB  *c160, *c256, *c384, *c512;

        if (opt_160 + opt_256 + opt_384 + opt_512 == 0)
            def = 1, opt_256 = 1;
        if (opt_160)    c160 = sha2_init (160);
        if (opt_256)    c256 = sha2_init (256);
        if (opt_384)    c384 = sha2_init (384);
        if (opt_512)    c512 = sha2_init (512);

        while (!feof (f))
        {
//          char    txt [150];
            n = fread (buf, 1, opt_bufsize, f);
            if (n < 0)  break;
            if (opt_160)    sha2_upd (c160, buf, n);
            if (opt_256)    sha2_upd (c256, buf, n);
            if (opt_384)    sha2_upd (c384, buf, n);
            if (opt_512)    sha2_upd (c512, buf, n);
//printf ("processed %u bytes, total hashed so far %lu\n", n, c256->len.lo);
//printf ("%s\n",  sha2_fmt (c256, txt));
        }

        if (opt_160)    sha2_end (c160);
        if (opt_256)    sha2_end (c256);
        if (opt_384)    sha2_end (c384);
        if (opt_512)    sha2_end (c512);

        printf ("* * * File %s (%lu bytes): %.2f seconds\n",
            argv [j], ftell (f), HS_timer_elapsed (&t0) / 100.0);
        fclose (f);

        char    outbuf1 [SHA2_160_FMT_LEN];
        char    outbuf2 [SHA2_256_FMT_LEN];
        char    outbuf3 [SHA2_384_FMT_LEN];
        char    outbuf4 [SHA2_512_FMT_LEN];
        if (opt_160)    printf ("sha160: %s\n\n",  sha2_fmt (c160, outbuf1));
        if (opt_256)    printf ("sha256: %s\n\n",  sha2_fmt (c256, outbuf2));
        if (opt_384)    printf ("sha384:\n%s\n\n", sha2_fmt (c384, outbuf3, 4));
        if (opt_512)    printf ("sha512:\n%s\n\n", sha2_fmt (c512, outbuf4, 4));
        printf ("\n");
        if (opt_160)    sha2_close (c160);
        if (opt_256)    sha2_close (c256);
        if (opt_384)    sha2_close (c384);
        if (opt_512)    sha2_close (c512);
        if (def)
            opt_256 = 0;
    }
    return 0;
}
#endif /* DBG_SHA2_LIB */