utf8proc/test/iterate.c

#include "tests.h"
#include <ctype.h>
#include <wchar.h>

static  int     tests;
static  int     error;

#define CHECKVALID(pos, val, len) buf[pos] = val; testbytes(buf,len,len,__LINE__)
#define CHECKINVALID(pos, val, len) buf[pos] = val; testbytes(buf,len,UTF8PROC_ERROR_INVALIDUTF8,__LINE__)

static void testbytes(unsigned char *buf, int len, utf8proc_ssize_t retval, int line)
{
    utf8proc_int32_t out[16];
    utf8proc_ssize_t ret;

    /* Make a copy to ensure that memory is left uninitialized after "len"
     * bytes. This way, Valgrind can detect overreads.
     */
    unsigned char tmp[16];
    memcpy(tmp, buf, len);

    tests++;
    if ((ret = utf8proc_iterate(tmp, len, out)) != retval) {
        fprintf(stderr, "Failed (%d):", line);
        for (int i = 0; i < len ; i++) {
            fprintf(stderr, " 0x%02x", tmp[i]);
        }
        fprintf(stderr, " -> %zd\n", ret);
        error++;
    }
}

int main(int argc, char **argv)
{
    uint32_t byt;
    unsigned char buf[16];

    tests = error = 0;

    // Check valid sequences that were considered valid erroneously before
    buf[0] = 0xef;
    buf[1] = 0xb7;
    for (byt = 0x90; byt < 0xa0; byt++) {
        CHECKVALID(2, byt, 3);
    }
    // Check 0xfffe and 0xffff
    buf[1] = 0xbf;
    CHECKVALID(2, 0xbe, 3);
    CHECKVALID(2, 0xbf, 3);
    // Check 0x??fffe & 0x??ffff
    for (byt = 0x1fffe; byt < 0x110000; byt += 0x10000) {
        buf[0] = 0xf0 | (byt >> 18);
        buf[1] = 0x80 | ((byt >> 12) & 0x3f);
        CHECKVALID(3, 0xbe, 4);
        CHECKVALID(3, 0xbf, 4);
    }
    
    // Continuation byte not after lead
    for (byt = 0x80; byt < 0xc0; byt++) {
        CHECKINVALID(0, byt, 1);
    }

    // Continuation byte not after lead
    for (byt = 0x80; byt < 0xc0; byt++) {
        CHECKINVALID(0, byt, 1);
    }

    // Test lead bytes
    for (byt = 0xc0; byt <= 0xff; byt++) {
	// Single lead byte at end of string
        CHECKINVALID(0, byt, 1);
        // Lead followed by non-continuation character < 0x80
        CHECKINVALID(1, 65, 2);
	// Lead followed by non-continuation character > 0xbf
        CHECKINVALID(1, 0xc0, 2);
    }

    // Test overlong 2-byte
    buf[0] = 0xc0;
    for (byt = 0x81; byt <= 0xbf; byt++) {
        CHECKINVALID(1, byt, 2);
    }
    buf[0] = 0xc1;
    for (byt = 0x80; byt <= 0xbf; byt++) {
        CHECKINVALID(1, byt, 2);
    }

    // Test overlong 3-byte
    buf[0] = 0xe0;
    buf[2] = 0x80;
    for (byt = 0x80; byt <= 0x9f; byt++) {
        CHECKINVALID(1, byt, 3);
    }

    // Test overlong 4-byte
    buf[0] = 0xf0;
    buf[2] = 0x80;
    buf[3] = 0x80;
    for (byt = 0x80; byt <= 0x8f; byt++) {
        CHECKINVALID(1, byt, 4);
    }

    // Test 4-byte > 0x10ffff
    buf[0] = 0xf4;
    buf[2] = 0x80;
    buf[3] = 0x80;
    for (byt = 0x90; byt <= 0xbf; byt++) {
        CHECKINVALID(1, byt, 4);
    }
    buf[1] = 0x80;
    for (byt = 0xf5; byt <= 0xf7; byt++) {
        CHECKINVALID(0, byt, 4);
    }

    // Test 5-byte
    buf[4] = 0x80;
    for (byt = 0xf8; byt <= 0xfb; byt++) {
        CHECKINVALID(0, byt, 5);
    }

    // Test 6-byte
    buf[5] = 0x80;
    for (byt = 0xfc; byt <= 0xfd; byt++) {
        CHECKINVALID(0, byt, 6);
    }

    // Test 7-byte
    buf[6] = 0x80;
    CHECKINVALID(0, 0xfe, 7);

    // Three and above byte sequences
    for (byt = 0xe0; byt < 0xf0; byt++) {
        // Lead followed by only 1 continuation byte
        CHECKINVALID(0, byt, 2);
        // Lead ended by non-continuation character < 0x80
        CHECKINVALID(2, 65, 3);
        // Lead ended by non-continuation character > 0xbf
        CHECKINVALID(2, 0xc0, 3);
    }

    // 3-byte encoded surrogate character(s)
    buf[0] = 0xed; buf[2] = 0x80;
    // Single surrogate
    CHECKINVALID(1, 0xa0, 3);
    // Trailing surrogate first
    CHECKINVALID(1, 0xb0, 3);

    // Four byte sequences
    buf[1] = 0x80;
    for (byt = 0xf0; byt < 0xf5; byt++) {
        // Lead followed by only 1 continuation bytes
        CHECKINVALID(0, byt, 2);
        // Lead followed by only 2 continuation bytes
        CHECKINVALID(0, byt, 3);
        // Lead followed by non-continuation character < 0x80
        CHECKINVALID(3, 65, 4);
        // Lead followed by non-continuation character > 0xbf
        CHECKINVALID(3, 0xc0, 4);

    }

     check(!error, "utf8proc_iterate FAILED %d tests out of %d", error, tests);
     printf("utf8proc_iterate tests SUCCEEDED, (%d) tests passed.\n", tests);

     return 0;
}