Ищу набор тестов для проверки парсера UTF-8

parse_utf8(uchar const *src, size_t srcsz) {
  uchar c1, c2, c3, c4;
  uint32 uc;
  while(srcsz) {
    c1 = *src;
    if(c1<=0x7F) { printf("Symbol: %02X\n", c1); src++; srcsz--; continue; }
    if(c1<=0xBF || c1>0xF7) { printf("Invalid input: %02X\n", c1); src++; srcsz--; continue; }
    if(srcsz<2) { printf("Truncated input: %02X\n", c1); break; }
    if(((c2=src[1])&0xC0)!=0x80) { printf("Invalid input: %02X\n", c1); src++; srcsz--; continue; }
    if(c1<=0xDF) { uc = ((c1&0x1F)<<6) | (c2&0x3F); len = 2; }
    else {
      if(srcsz<3) { printf("Truncated input: %02X %02X\n", c1, c2); break; }
      if(((c3=src[2])&0xC0)!=0x80) { printf("Invalid input: %02X %02X\n", c1, c2); src+=2; srcsz-=2; continue; }
      if(c1<=0xEF) { uc = ((c1&0x0F)<<12) | ((c2&0x3F)<<6) | (c3&0x3F); len = 3; }
      else {
        if(srcsz<4) { printf("Truncated input: %02X %02X %02X\n", c1, c2, c3); break; }
        if(((c4=src[3])&0xC0)!=0x80) { printf("Invalid input: %02X %02X %02X\n", c1, c2, c3); src+=3; srcsz-=3; continue; }
        uc = ((((uint32)c1)&7)<<18) | ((((uint32)c2)&0x3F)<<12) | ((c3&0x3F)<<6) | (c4&0x3F); len = 4;
      }
    }
    if(uc<=0x7F || uc<=0x7FF && len>2 || uc<=0xFFFF && len>3 || uc>0x10FFFF || uc>=0xFDD0 && uc<=0xFDEF || (uc&0xFFFE)==0xFFFE || uc>=0xD800 && uc<=0xDFFF)
      printf("Malformed symbol: %08lX\n", (ulong)uc);
    else
      printf("Symbol: %08lX\n", (ulong)uc);
    src+=len; srcsz-=len;
  }
}

#include <stdio.h>
#include <stdint.h>

struct utf8Decoder{
	const char*   text;
	unsigned char isValid;
	uint32_t      char32;
};

/**
  Функция декодирования символов из utf-8.
  
  text - входная строка с текстом в формате utf-8. Строка должна
  заканчиваться NULL-терминатором.
  
  isValid - флаг, указывающий на допустимость декодированной
  последовательности байт. Нулевое значение говорит о недопустимости
  последовательности, ненулевое - о допустимости. Недопустимый символ
  следует игнорировать и заменить на "битый" символ.
  
  char32 - декодированный символ.
  
  Функция возвращает количество реально декодированных байт - ширину 
  символа. В случае достижения конца строки, функция вернёт 0.
*/
int decodeUtf8( struct utf8Decoder* decoder ){
	
	unsigned char charWidth;
	
	decoder->isValid = 0xff;
	
	/*
	Байты, которые никогда не встречаются в UTF-8: 0xC0, 0xC1, 0xF5–0xFF
	Байт продолжения (0x80–0xBF) в качестве начала последовательности
	A non-continuation byte (or the string ending) before the end of a character
	An overlong encoding (0xE0 followed by less than 0xA0, or 0xF0 followed by less than 0x90)
	Слишком длинное кодирование (0xE0, за которым следует менее 0xA0, или 0xF0, за которым следует менее 0x90)
	Последовательность из 4 байтов, которая декодируется в значение больше, чем U+10FFFF (0xF4, за которым следует 0x90 или больше)
	
	Декодер не должен потреблять допустимые последующие байты, если
	встречается недопустимая последовательность.
	
	Заменяющий символ � находится на позиции U+FFFD
	
	1-byte  0x000000 - 0x00007f
	2-byte  0x000080 - 0x0007ff
	3-byte  0x000800 - 0x00ffff
	4-byte  0x010000 - 0x10ffff
	*/
	
	//TODO: орагнизовать поддержку 5 и 6 байта из вредности! =P
	
	/// первый байт
	
	//проверяем нуль-терминатор
	if( !decoder->text[0] ) return 0;
	
	//по маске определяем количество байт
	
	//1 байт
	if( !(decoder->text[0] & 0x80) ){
		//Дополнительные проверки не нужны. Если старший бит 0, то это 
		//может быть только однобайтовый символ, который может принимать
		//значения от 0x01 до 0x7F. Проверка на 0x00 была выше.
		decoder->char32 = decoder->text[0];
		return 1;
	}
	
	//2 байта
	if( (decoder->text[0] & 0xE0) == 0xC0 ){
		decoder->char32 = ( decoder->text[0] & 0x1F ) << 6;
		charWidth = 2;
	}
	
	//3 байта
	else if( (decoder->text[0] & 0xF0) == 0xE0 ){
		decoder->char32 = ( decoder->text[0] & 0x0F ) << ( 6 * 2 );
		charWidth = 3;
	}
	
	//4 байта
	else if( (decoder->text[0] & 0xF8) == 0xF0 ){
		decoder->char32 = ( decoder->text[0] & 0x07 ) << ( 6 * 3 );
		charWidth = 4;
	}
	
	//битьё
	else{
		decoder->isValid = 0x00;
		return 1;
	}
	
	/// второй байт
	
	//проверяем заголовок
	if( (decoder->text[1] & 0xC0) != 0x80 ){
		decoder->isValid = 0x00;
		return 1;
	}
	
	//делаем выборку данных
	decoder->char32 |= ( decoder->text[1] & 0x3F ) << ( 6 * (charWidth - 2) );
	
	if( charWidth == 2 ){
		
		//проверка допустимости для ширины 2 байта 0x000080 - 0x0007ff
		if( decoder->char32 <   0x80 ) decoder->isValid = 0x00; 
		if( decoder->char32 > 0x07FF ) decoder->isValid = 0x00;
		return 2;
	}
	
	
	/// третий байт
	
	//проверяем заголовок
	if( (decoder->text[2] & 0xC0) != 0x80 ){
		decoder->isValid = 0x00;
		return 2;
	}
	
	//делаем выборку данных
	decoder->char32 |= ( decoder->text[2] & 0x3F ) << ( 6 * (charWidth - 3) );
	
	if( charWidth == 3 ){
		
		//проверка допустимости для ширины 3 байта 0x000800 - 0x00ffff
		if( decoder->char32 < 0x0800 ) decoder->isValid = 0x00;
		if( decoder->char32 > 0xFFFF ) decoder->isValid = 0x00;
		return 3;
	}
	
	/// четвёртый байт
	
	//проверяем заголовок
	if( (decoder->text[3] & 0xC0) != 0x80 ){
		decoder->isValid = 0x00;
		return 3;
	}
	
	//делаем выборку данных
	decoder->char32 |= ( decoder->text[3] & 0x3F ) << ( 6 *(charWidth - 4) );
	
	//проверка допустимости для ширины 4 байта 0x010000 - 0x10ffff
	if( decoder->char32 < 0x010000 ) decoder->isValid = 0x00;
	if( decoder->char32 > 0x10FFFF ) decoder->isValid = 0x00;
	return 4;
}