rle_test.c

#include "rle.c"

int rletests(void);

static int
testmemfillrepeat(void)
{
	/* Fill with a pattern shorter than the destination (pattern repeats) */
	uchar dst[6];
	uchar pat[] = {0xAB, 0xCD};
	uchar want[] = {0xAB, 0xCD, 0xAB, 0xCD, 0xAB, 0xCD};
	int i;

	memfill(dst, sizeof dst, pat, sizeof pat);
	for(i = 0; i < (int)sizeof dst; i++)
		if(dst[i] != want[i])
			sysfatal("testmemfillrepeat: dst[%d]: want 0x%x, got 0x%x", i, want[i], dst[i]);
	return 0;
}

static int
testmemfillexact(void)
{
	/* Fill with a pattern equal in length to the destination */
	uchar dst[4];
	uchar pat[] = {0x01, 0x02, 0x03, 0x04};
	int i;

	memfill(dst, sizeof dst, pat, sizeof pat);
	for(i = 0; i < (int)sizeof dst; i++)
		if(dst[i] != pat[i])
			sysfatal("testmemfillexact: dst[%d]: want 0x%x, got 0x%x", i, pat[i], dst[i]);
	return 0;
}

static int
testmemfill1byte(void)
{
	/* Fill a single byte with a single-byte pattern */
	uchar dst[1] = {0x00};
	uchar pat[] = {0x42};

	memfill(dst, sizeof dst, pat, sizeof pat);
	if(dst[0] != 0x42)
		sysfatal("testmemfill1byte: dst[0]: want 0x42, got 0x%x", dst[0]);
	return 0;
}

static int
testmemfillempty(void)
{
	/* Zero-length destination: no bytes written, returns a1 */
	uchar dst[1] = {0x99};
	uchar pat[] = {0x42};
	void *ret;

	ret = memfill(dst, 0, pat, sizeof pat);
	if(ret != dst)
		sysfatal("testmemfillempty: return value: want dst, got something else");
	if(dst[0] != 0x99)
		sysfatal("testmemfillempty: dst[0]: want 0x99, got 0x%x", dst[0]);
	return 0;
}

static int
testmemxorbasic(void)
{
	/* Basic XOR of two equal-length arrays */
	uchar a[] = {0xFF, 0x0F, 0xAA};
	uchar b[] = {0x0F, 0xFF, 0x55};
	uchar want[] = {0xF0, 0xF0, 0xFF};
	int i;

	memxor(a, b, sizeof a);
	for(i = 0; i < (int)sizeof a; i++)
		if((uchar)a[i] != want[i])
			sysfatal("testmemxorbasic: a[%d]: want 0x%x, got 0x%x", i, want[i], (uchar)a[i]);
	return 0;
}

static int
testmemxorempty(void)
{
	/* XOR with zero-length: no bytes modified */
	uchar a[] = {0xAB, 0xCD};
	uchar b[] = {0xFF, 0xFF};

	memxor(a, b, 0);
	if(a[0] != 0xAB || a[1] != 0xCD)
		sysfatal("testmemxorempty: unexpected modification: got 0x%x 0x%x", a[0], a[1]);
	return 0;
}

static int
testmemxorself(void)
{
	/* XOR with self yields all zeros */
	uchar a[] = {0x12, 0x34, 0x56};
	int i;

	memxor(a, a, sizeof a);
	for(i = 0; i < (int)sizeof a; i++)
		if(a[i] != 0)
			sysfatal("testmemxorself: a[%d]: want 0, got 0x%x", i, a[i]);
	return 0;
}

static int
testmemxorzero(void)
{
	/* XOR with all-zero array leaves original unchanged */
	uchar a[] = {0xDE, 0xAD, 0xBE, 0xEF};
	uchar z[] = {0x00, 0x00, 0x00, 0x00};
	uchar orig[] = {0xDE, 0xAD, 0xBE, 0xEF};
	int i;

	memxor(a, z, sizeof a);
	for(i = 0; i < (int)sizeof a; i++)
		if(a[i] != orig[i])
			sysfatal("testmemxorzero: a[%d]: want 0x%x, got 0x%x", i, orig[i], a[i]);
	return 0;
}

static int
testunrlebpix(void)
{
	/* Bpix extended opcode (0xFE): sets the current pixel to zero */
	uchar src[] = {0xFE};
	uchar dst[1];
	uchar *end;

	end = unrle(dst, sizeof dst, src, sizeof src, 2, 1);
	if(end == nil)
		sysfatal("testunrlebpix: unexpected error: %r");
	if(end - dst != 1)
		sysfatal("testunrlebpix: length: want 1, got %d", (int)(end - dst));
	if(dst[0] != 0)
		sysfatal("testunrlebpix: pixel: want 0, got %d", dst[0]);
	return 0;
}

static int
testunrlebg1(void)
{
	/*
	 * Bg opcode on the first scan line (no previous line):
	 * memset(wp, 0, len) zero-fills the output.
	 * hdr=0x01: standard header, code=0 (Bg), raw_len=1 → len=1 pixel.
	 */
	uchar src[] = {0x01};
	uchar dst[1];
	uchar *end;

	end = unrle(dst, sizeof dst, src, sizeof src, 4, 1);
	if(end == nil)
		sysfatal("testunrlebg1: unexpected error: %r");
	if(end - dst != 1)
		sysfatal("testunrlebg1: length: want 1, got %d", (int)(end - dst));
	if(dst[0] != 0)
		sysfatal("testunrlebg1: pixel: want 0, got %d", dst[0]);
	return 0;
}

static int
testunrlemixzero(void)
{
	/*
	 * Mix opcode on the first scan line with an all-zero mask byte:
	 * memset(wp, 0, pixelsize) zero-fills each pixel whose mask bit is 0.
	 * hdr=0x41: standard header, code=4 (Mix), raw_len=1 → len=8 pixels.
	 * mask=0x00: all bits 0, so all 8 pixels are zero-filled.
	 */
	uchar src[] = {0x41, 0x00};
	uchar dst[8];
	uchar *end;
	int i;

	memset(dst, 0xFF, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlemixzero: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlemixzero: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != 0)
			sysfatal("testunrlemixzero: dst[%d]: want 0, got %d", i, dst[i]);
	return 0;
}

static int
testunrlelit(void)
{
	/*
	 * Lit opcode: code=8, bits=Bits5=31, raw_len=3 → len=3 pixels.
	 * hdr=0x83: copies 3 literal bytes verbatim into output.
	 */
	uchar src[] = {0x83, 0xAA, 0xBB, 0xCC};
	uchar dst[3];
	uchar *end;

	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlelit: unexpected error: %r");
	if(end - dst != 3)
		sysfatal("testunrlelit: length: want 3, got %d", (int)(end - dst));
	if(dst[0] != 0xAA || dst[1] != 0xBB || dst[2] != 0xCC)
		sysfatal("testunrlelit: pixels: want AA BB CC, got %02x %02x %02x",
			dst[0], dst[1], dst[2]);
	return 0;
}

static int
testunrlefg1(void)
{
	/*
	 * Fg opcode on the first scan line (no previous line):
	 * fills with the initial pen (DWhite=0xFF for pixelsize=1), no XOR.
	 * hdr=0x24: code=2 (Fg), raw_len=4 → len=4 pixels.
	 */
	uchar src[] = {0x24};
	uchar dst[4];
	uchar *end;
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlefg1: unexpected error: %r");
	if(end - dst != 4)
		sysfatal("testunrlefg1: length: want 4, got %d", (int)(end - dst));
	for(i = 0; i < 4; i++)
		if(dst[i] != 0xFF)
			sysfatal("testunrlefg1: dst[%d]: want 0xFF, got 0x%02x", i, dst[i]);
	return 0;
}

static int
testunrlefgs(void)
{
	/*
	 * FgS opcode: code=12, bits=Bits4=15, raw_len=1 → len=1 pixel.
	 * hdr=0xC1: reads 1-byte pen (0x42), then fills 1 pixel with it.
	 * First scan line: no XOR with previous row.
	 */
	uchar src[] = {0xC1, 0x42};
	uchar dst[1];
	uchar *end;

	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlefgs: unexpected error: %r");
	if(end - dst != 1)
		sysfatal("testunrlefgs: length: want 1, got %d", (int)(end - dst));
	if(dst[0] != 0x42)
		sysfatal("testunrlefgs: pixel: want 0x42, got 0x%02x", dst[0]);
	return 0;
}

static int
testunrlefill(void)
{
	/*
	 * Fill opcode: code=6, bits=Bits5=31, raw_len=3 → len=3 pixels.
	 * hdr=0x63: reads 1-byte fill colour (0x55), fills 3 pixels with it.
	 */
	uchar src[] = {0x63, 0x55};
	uchar dst[3];
	uchar *end;
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlefill: unexpected error: %r");
	if(end - dst != 3)
		sysfatal("testunrlefill: length: want 3, got %d", (int)(end - dst));
	for(i = 0; i < 3; i++)
		if(dst[i] != 0x55)
			sysfatal("testunrlefill: dst[%d]: want 0x55, got 0x%02x", i, dst[i]);
	return 0;
}

static int
testunrledith(void)
{
	/*
	 * Dith opcode: code=14, bits=Bits4=15, raw_len=1 → len=1 (×pixelsize).
	 * hdr=0xE1: inside Dith, len doubles to 2; reads two 1-byte colours
	 * {0xAA, 0xBB} and fills output with the alternating pattern.
	 */
	uchar src[] = {0xE1, 0xAA, 0xBB};
	uchar dst[2];
	uchar *end;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrledith: unexpected error: %r");
	if(end - dst != 2)
		sysfatal("testunrledith: length: want 2, got %d", (int)(end - dst));
	if(dst[0] != 0xAA || dst[1] != 0xBB)
		sysfatal("testunrledith: pixels: want AA BB, got %02x %02x", dst[0], dst[1]);
	return 0;
}

static int
testunrlewpix(void)
{
	/*
	 * Wpix extended opcode (0xFD): sets the current pixel to DWhite (0xFF).
	 */
	uchar src[] = {0xFD};
	uchar dst[1];
	uchar *end;

	dst[0] = 0;
	end = unrle(dst, sizeof dst, src, sizeof src, 2, 1);
	if(end == nil)
		sysfatal("testunrlewpix: unexpected error: %r");
	if(end - dst != 1)
		sysfatal("testunrlewpix: length: want 1, got %d", (int)(end - dst));
	if(dst[0] != 0xFF)
		sysfatal("testunrlewpix: pixel: want 0xFF, got 0x%02x", dst[0]);
	return 0;
}

static int
testunrlemixmask(void)
{
	/*
	 * Mix opcode with non-trivial mask (0xAA = 10101010):
	 * hdr=0x41: code=4 (Mix), raw_len=1 → len=8 pixels.
	 * Even-indexed pixels (bit=0) are zero-filled; odd-indexed (bit=1)
	 * get the initial pen (DWhite=0xFF). No previous scan line, no XOR.
	 */
	uchar src[] = {0x41, 0xAA};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF};
	int i;

	memset(dst, 0x55, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlemixmask: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlemixmask: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != want[i])
			sysfatal("testunrlemixmask: dst[%d]: want 0x%02x, got 0x%02x",
				i, want[i], dst[i]);
	return 0;
}

static int
testunrlemixs(void)
{
	/*
	 * MixS opcode: code=13, bits=Bits4=15, raw_len=1 → len=8 pixels.
	 * hdr=0xD1: reads 1-byte pen (0x42), mask=0xFF (all bits set).
	 * First scan line, all bits 1: every pixel written with new pen, no XOR.
	 */
	uchar src[] = {0xD1, 0x42, 0xFF};
	uchar dst[8];
	uchar *end;
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlemixs: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlemixs: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != 0x42)
			sysfatal("testunrlemixs: dst[%d]: want 0x42, got 0x%02x", i, dst[i]);
	return 0;
}

static int
testunrlemix3(void)
{
	/*
	 * Mix3 extended opcode (0xF9): fixed bitmask sreg=3 (00000011).
	 * Produces 8 pixels: first two get pen (DWhite=0xFF), rest are zero.
	 * First scan line: no XOR with previous row.
	 */
	uchar src[] = {0xF9};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	int i;

	memset(dst, 0x55, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlemix3: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlemix3: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != want[i])
			sysfatal("testunrlemix3: dst[%d]: want 0x%02x, got 0x%02x",
				i, want[i], dst[i]);
	return 0;
}

static int
testunrlemix5(void)
{
	/*
	 * Mix5 extended opcode (0xFA): fixed bitmask sreg=5 (00000101).
	 * Produces 8 pixels: pixels 0 and 2 get pen (DWhite=0xFF), rest zero.
	 * First scan line: no XOR with previous row.
	 */
	uchar src[] = {0xFA};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00};
	int i;

	memset(dst, 0x55, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrlemix5: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlemix5: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != want[i])
			sysfatal("testunrlemix5: dst[%d]: want 0x%02x, got 0x%02x",
				i, want[i], dst[i]);
	return 0;
}

static int
testunrlebg2(void)
{
	/*
	 * Bg on second scan line: copies pixels from the previous scan line.
	 * First opcode: Lit 4 pixels {0x11,0x22,0x33,0x44}.
	 * Second opcode: hdr=0x04 (Bg, raw_len=4) — on second scan line
	 * wp-bpl points into the already-written first scan line, so
	 * memmove copies it verbatim (no XOR for Bg).
	 */
	uchar src[] = {0x84, 0x11, 0x22, 0x33, 0x44, 0x04};
	uchar dst[8];
	uchar *end;
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 4, 1);
	if(end == nil)
		sysfatal("testunrlebg2: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlebg2: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 4; i++)
		if(dst[4+i] != dst[i])
			sysfatal("testunrlebg2: dst[%d]: want 0x%02x, got 0x%02x",
				4+i, dst[i], dst[4+i]);
	return 0;
}

static int
testunrlefg2(void)
{
	/*
	 * Fg on second scan line: fills with pen (DWhite) then XORs with
	 * the previous scan line.
	 * First opcode: Lit 4 pixels {0x11,0x22,0x33,0x44}.
	 * Second opcode: hdr=0x24 (Fg, raw_len=4) — pen=0xFF XOR prev.
	 * Expected: {0xFF^0x11, 0xFF^0x22, 0xFF^0x33, 0xFF^0x44}
	 *         = {0xEE, 0xDD, 0xCC, 0xBB}.
	 */
	uchar src[] = {0x84, 0x11, 0x22, 0x33, 0x44, 0x24};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0xEE, 0xDD, 0xCC, 0xBB};
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 4, 1);
	if(end == nil)
		sysfatal("testunrlefg2: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlefg2: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 4; i++)
		if(dst[4+i] != want[i])
			sysfatal("testunrlefg2: dst[%d]: want 0x%02x, got 0x%02x",
				4+i, want[i], dst[4+i]);
	return 0;
}

static int
testunrlefgs2(void)
{
	/*
	 * FgS on second scan line: sets a new pen (0xF0) then XORs with
	 * the previous scan line.
	 * First opcode: Lit 4 pixels {0x11,0x22,0x33,0x44}.
	 * Second opcode: hdr=0xC4 (FgS, raw_len=4), pen byte=0xF0.
	 * Expected: {0xF0^0x11, 0xF0^0x22, 0xF0^0x33, 0xF0^0x44}
	 *         = {0xE1, 0xD2, 0xC3, 0xB4}.
	 */
	uchar src[] = {0x84, 0x11, 0x22, 0x33, 0x44, 0xC4, 0xF0};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0xE1, 0xD2, 0xC3, 0xB4};
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 4, 1);
	if(end == nil)
		sysfatal("testunrlefgs2: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrlefgs2: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 4; i++)
		if(dst[4+i] != want[i])
			sysfatal("testunrlefgs2: dst[%d]: want 0x%02x, got 0x%02x",
				4+i, want[i], dst[4+i]);
	return 0;
}

static int
testunrlebgcons(void)
{
	/*
	 * Consecutive Bg runs (wasbg flag): after a Bg run sets wasbg=1, the
	 * next Bg run on the following scan line starts its first pixel using
	 * pen XOR previous-line-pixel, then copies the rest of the prev line.
	 * Lit 4: {0x11,0x22,0x33,0x44}; Bg 4 (copies prev → same); Bg 4.
	 * Third Bg (wasbg=1): pixel[8] = pen(0xFF) XOR dst[4](0x11) = 0xEE,
	 * pixels[9..11] copied from dst[5..7] = {0x22,0x33,0x44}.
	 */
	uchar src[] = {0x84, 0x11, 0x22, 0x33, 0x44, 0x04, 0x04};
	uchar dst[12];
	uchar *end;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 4, 1);
	if(end == nil)
		sysfatal("testunrlebgcons: unexpected error: %r");
	if(end - dst != 12)
		sysfatal("testunrlebgcons: length: want 12, got %d", (int)(end - dst));
	if(dst[8] != 0xEE)
		sysfatal("testunrlebgcons: dst[8]: want 0xEE, got 0x%02x", dst[8]);
	if(dst[9] != 0x22 || dst[10] != 0x33 || dst[11] != 0x44)
		sysfatal("testunrlebgcons: dst[9..11]: want 22 33 44, got %02x %02x %02x",
			dst[9], dst[10], dst[11]);
	return 0;
}

static int
testunrleoverrun(void)
{
	/*
	 * Overrun detection: output buffer is smaller than the decoded data.
	 * Lit 4 bytes into a 3-byte buffer must return nil with an error.
	 */
	uchar src[] = {0x84, 0xAA, 0xBB, 0xCC, 0xDD};
	uchar dst[3];
	uchar *end;

	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end != nil)
		sysfatal("testunrleoverrun: expected nil return on overrun, got non-nil");
	return 0;
}

static int
testunrleextbg(void)
{
	/*
	 * Extended Bg opcode (0xF0): len taken from following 2-byte little-
	 * endian field. hdr=0xF0, len=4; first scan line → zero-fills 4 bytes.
	 */
	uchar src[] = {0xF0, 0x04, 0x00};
	uchar dst[4];
	uchar *end;
	int i;

	memset(dst, 0xFF, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrleextbg: unexpected error: %r");
	if(end - dst != 4)
		sysfatal("testunrleextbg: length: want 4, got %d", (int)(end - dst));
	for(i = 0; i < 4; i++)
		if(dst[i] != 0)
			sysfatal("testunrleextbg: dst[%d]: want 0, got 0x%02x", i, dst[i]);
	return 0;
}

static int
testunrleextfg(void)
{
	/*
	 * Extended Fg opcode (0xF1): len from 2-byte field.
	 * hdr=0xF1, len=3; pen=DWhite (0xFF), first scan line → no XOR.
	 * Output: 3 bytes of 0xFF.
	 */
	uchar src[] = {0xF1, 0x03, 0x00};
	uchar dst[3];
	uchar *end;
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrleextfg: unexpected error: %r");
	if(end - dst != 3)
		sysfatal("testunrleextfg: length: want 3, got %d", (int)(end - dst));
	for(i = 0; i < 3; i++)
		if(dst[i] != 0xFF)
			sysfatal("testunrleextfg: dst[%d]: want 0xFF, got 0x%02x", i, dst[i]);
	return 0;
}

static int
testunrleextlit(void)
{
	/*
	 * Extended Lit opcode (0xF4): len from 2-byte field.
	 * hdr=0xF4, len=3; copies next 3 bytes verbatim.
	 */
	uchar src[] = {0xF4, 0x03, 0x00, 0xAA, 0xBB, 0xCC};
	uchar dst[3];
	uchar *end;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 10, 1);
	if(end == nil)
		sysfatal("testunrleextlit: unexpected error: %r");
	if(end - dst != 3)
		sysfatal("testunrleextlit: length: want 3, got %d", (int)(end - dst));
	if(dst[0] != 0xAA || dst[1] != 0xBB || dst[2] != 0xCC)
		sysfatal("testunrleextlit: pixels: want AA BB CC, got %02x %02x %02x",
			dst[0], dst[1], dst[2]);
	return 0;
}

static int
testunrleextfill32(void)
{
	/*
	 * Extended Fill opcode (0xF3) with pixelsize=4 (32-bpp):
	 * hdr=0xF3, len=2 pixels → 8 bytes; fill colour = {0x12,0x34,0x56,0x78}.
	 * Output: two copies of the 4-byte pixel.
	 */
	uchar src[] = {0xF3, 0x02, 0x00, 0x12, 0x34, 0x56, 0x78};
	uchar dst[8];
	uchar *end;
	uchar want[] = {0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78};
	int i;

	memset(dst, 0, sizeof dst);
	end = unrle(dst, sizeof dst, src, sizeof src, 8, 4);
	if(end == nil)
		sysfatal("testunrleextfill32: unexpected error: %r");
	if(end - dst != 8)
		sysfatal("testunrleextfill32: length: want 8, got %d", (int)(end - dst));
	for(i = 0; i < 8; i++)
		if(dst[i] != want[i])
			sysfatal("testunrleextfill32: dst[%d]: want 0x%02x, got 0x%02x",
				i, want[i], dst[i]);
	return 0;
}

int
rletests(void)
{
	testmemfillrepeat();
	testmemfillexact();
	testmemfill1byte();
	testmemfillempty();
	testmemxorbasic();
	testmemxorempty();
	testmemxorself();
	testmemxorzero();
	testunrlebpix();
	testunrlebg1();
	testunrlemixzero();
	testunrlelit();
	testunrlefg1();
	testunrlefgs();
	testunrlefill();
	testunrledith();
	testunrlewpix();
	testunrlemixmask();
	testunrlemixs();
	testunrlemix3();
	testunrlemix5();
	testunrlebg2();
	testunrlefg2();
	testunrlefgs2();
	testunrlebgcons();
	testunrleoverrun();
	testunrleextbg();
	testunrleextfg();
	testunrleextlit();
	testunrleextfill32();
	return 0;
}