framework/delibs/debase/deSha1.c - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Base Portability Library
  * -------------------------------------
  *
  * Copyright 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief SHA1 hash functions.
  *//*--------------------------------------------------------------------*/

 #include "deSha1.h"

 #include "deMemory.h"

 DE_BEGIN_EXTERN_C

 enum
 {
 	CHUNK_BIT_SIZE	= 512,
 	CHUNK_BYTE_SIZE	= CHUNK_BIT_SIZE / 8
 };

 static deUint32 leftRotate (deUint32 val, deUint32 count)
 {
 	DE_ASSERT(count < 32);

 	return (val << count) | (val >> (32 - count));
 }

 void deSha1Stream_init (deSha1Stream* stream)
 {
 	stream->size = 0;

 	/* Set the initial 16 deUint32s that contain real data to zeros. */
 	deMemset(stream->data, 0, 16 * sizeof(deUint32));

 	stream->hash[0] = 0x67452301u;
 	stream->hash[1] = 0xEFCDAB89u;
 	stream->hash[2] = 0x98BADCFEu;
 	stream->hash[3] = 0x10325476u;
 	stream->hash[4] = 0xC3D2E1F0u;
 }

 static void deSha1Stream_flushChunk (deSha1Stream* stream)
 {
 	DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0 && stream->size > 0);

 	{
 		size_t ndx;

 		/* Expand the 16 uint32s that contain the data to 80. */
 		for (ndx = 16; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
 		{
 			stream->data[ndx] = leftRotate(stream->data[ndx - 3]
 										   ^ stream->data[ndx - 8]
 										   ^ stream->data[ndx - 14]
 										   ^ stream->data[ndx - 16], 1);
 		}
 	}

 	{
 		deUint32	a = stream->hash[0];
 		deUint32	b = stream->hash[1];
 		deUint32	c = stream->hash[2];
 		deUint32	d = stream->hash[3];
 		deUint32	e = stream->hash[4];
 		size_t		ndx;

 		for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
 		{
 			deUint32 f;
 			deUint32 k;

 			if (ndx < 20)
 			{
 				f = (b & c) | ((~b) & d);
 				k = 0x5A827999u;
 			}
 			else if (ndx < 40)
 			{
 				f = b ^ c ^ d;
 				k = 0x6ED9EBA1u;
 			}
 			else if (ndx < 60)
 			{
 				f = (b & c) | (b & d) | (c & d);
 				k = 0x8F1BBCDCu;
 			}
 			else
 			{
 				f = b ^ c ^ d;
 				k = 0xCA62C1D6u;
 			}

 			{
 				const deUint32 tmp = leftRotate(a, 5) + f + e + k + stream->data[ndx];

 				e = d;
 				d = c;
 				c = leftRotate(b, 30);
 				b = a;
 				a = tmp;
 			}
 		}

 		stream->hash[0] += a;
 		stream->hash[1] += b;
 		stream->hash[2] += c;
 		stream->hash[3] += d;
 		stream->hash[4] += e;

 		/* Set the initial 16 deUint32s that contain the real data to zeros. */
 		deMemset(stream->data, 0, 16 * sizeof(deUint32));
 	}
 }

 void deSha1Stream_process (deSha1Stream* stream, size_t size, const void* data_)
 {
 	const deUint8* const	data			= (const deUint8*)data_;
 	size_t					bytesProcessed	= 0;

 	while (bytesProcessed < size)
 	{
 		do
 		{
 			const size_t bitOffset = (size_t)(8 * (4 - (1 + (stream->size % 4))));

 			stream->data[(stream->size / 4) % 16] |= ((deUint32)data[bytesProcessed]) << (deUint32)bitOffset;

 			stream->size++;
 			bytesProcessed++;
 		}
 		while (stream->size % CHUNK_BYTE_SIZE != 0 && bytesProcessed < size);

 		if (stream->size % CHUNK_BYTE_SIZE == 0)
 			deSha1Stream_flushChunk(stream);
 	}

 	DE_ASSERT(bytesProcessed == size);
 }

 void deSha1Stream_finalize (deSha1Stream* stream, deSha1* hash)
 {
 	/* \note First element is initialized to 0x80u and rest to 0x0. */
 	static const deUint8	padding[CHUNK_BYTE_SIZE]	= { 0x80u };
 	const deUint64			length						= stream->size * 8;
 	deUint8					lengthData[sizeof(deUint64)];
 	size_t					ndx;

 	DE_ASSERT(padding[0] == 0x80u);
 	DE_ASSERT(padding[1] == 0x0u);

 	for (ndx = 0; ndx < sizeof(deUint64); ndx++)
 		lengthData[ndx] = (deUint8)(0xffu & (length >> (8 * (sizeof(deUint64) - 1 - ndx))));

 	{
 		const deUint64 spaceLeftInChunk = CHUNK_BYTE_SIZE - (stream->size % CHUNK_BYTE_SIZE);

 		if (spaceLeftInChunk >= 1 + sizeof(lengthData))
 			deSha1Stream_process(stream, (size_t)(spaceLeftInChunk - sizeof(lengthData)), padding);
 		else
 			deSha1Stream_process(stream, (size_t)(CHUNK_BYTE_SIZE - (sizeof(lengthData)) - spaceLeftInChunk), padding);
 	}

 	deSha1Stream_process(stream, sizeof(lengthData), lengthData);
 	DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0);

 	deMemcpy(hash->hash, stream->hash, sizeof(hash->hash));
 }

 void deSha1_compute (deSha1* hash, size_t size, const void* data)
 {
 	deSha1Stream stream;

 	deSha1Stream_init(&stream);
 	deSha1Stream_process(&stream, size, data);
 	deSha1Stream_finalize(&stream, hash);
 }

 void deSha1_render (const deSha1* hash, char* buffer)
 {
 	size_t charNdx;

 	for (charNdx = 0; charNdx < 40; charNdx++)
 	{
 		const deUint32	val32	= hash->hash[charNdx / 8];
 		const deUint8	val8	= (deUint8)(0x0fu & (val32 >> (4 * (8 - 1 - (charNdx % 8)))));

 		if (val8 < 10)
 			buffer[charNdx] = (char)('0' + val8);
 		else
 			buffer[charNdx] = (char)('a' + val8 - 10);
 	}
 }

 deBool deSha1_parse (deSha1* hash, const char* buffer)
 {
 	size_t charNdx;

 	deMemset(hash->hash, 0, sizeof(hash->hash));

 	for (charNdx = 0; charNdx < 40; charNdx++)
 	{
 		deUint8 val4;

 		if (buffer[charNdx] >= '0' && buffer[charNdx] <= '9')
 			val4 = (deUint8)(buffer[charNdx] - '0');
 		else if (buffer[charNdx] >= 'a' && buffer[charNdx] <= 'f')
 			val4 = (deUint8)(10 + (buffer[charNdx] - 'a'));
 		else if (buffer[charNdx] >= 'A' && buffer[charNdx] <= 'F')
 			val4 = (deUint8)(10 + (buffer[charNdx] - 'A'));
 		else
 			return DE_FALSE;

 		hash->hash[charNdx / 8] |= ((deUint32)val4) << (4 * (8u - 1u - (charNdx % 8u)));
 	}

 	return DE_TRUE;
 }

 deBool deSha1_equal (const deSha1* a, const deSha1* b)
 {
 	/* \note deMemcmp() can only be used for equality. It doesn't provide correct ordering between hashes. */
 	return deMemCmp(a->hash, b->hash, sizeof(b->hash)) == 0;
 }

 void deSha1_selfTest (void)
 {
 	const char* const validHashStrings[] =
 	{
 		"ac890cfca05717c05dc831996b2289251da2984e",
 		"0f87ba807acb3e6effe617249f30453a524a2ea3",
 		"6f483cc3fa820e58ed9f83c83bdf8d213293b3ad"
 	};

 	const char* const invalidHashStrings[] =
 	{
 		" c890cfca05717c05dc831996b2289251da2984e",
 		"0f87ba807acb3e6 ffe617249f30453a524a2ea3",
 		"6f483cc3fa820e58ed9f83c83bdf8d213293b3a ",

 		"mc890cfca05717c05dc831996b2289251da2984e",
 		"0f87ba807acb3e6effe617249fm0453a524a2ea3",
 		"6f483cc3fa820e58ed9f83c83bdf8d213293b3an",

 		"ac890cfca05717c05dc83\n996b2289251da2984e",
 		"0f87ba807acb3e6effe617\t49f30453a524a2ea3",
 		"ac890cfca05717c05dc831\096b2289251da2984e",
 		"6f483cc3fa{20e58ed9f83c83bdf8d213293b3ad"
 	};

 	const struct
 	{
 		const char* const hash;
 		const char* const data;
 	} stringHashPairs[] =
 	{
 		/* Generated using sha1sum. */
 		{ "da39a3ee5e6b4b0d3255bfef95601890afd80709", "" },
 		{ "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d", "hello" },
 		{ "ec1919e856540f42bd0e6f6c1ffe2fbd73419975",
 			"Cherry is a browser-based GUI for controlling deqp test runs and analysing the test results."
 		}
 	};

 	const int garbage = 0xde;

 	/* Test parsing valid sha1 strings. */
 	{
 		size_t stringNdx;

 		for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
 		{
 			deSha1 hash;
 			deMemset(&hash, garbage, sizeof(deSha1));
 			DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
 		}
 	}

 	/* Test parsing invalid sha1 strings. */
 	{
 		size_t stringNdx;

 		for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(invalidHashStrings); stringNdx++)
 		{
 			deSha1 hash;
 			deMemset(&hash, garbage, sizeof(deSha1));
 			DE_TEST_ASSERT(!deSha1_parse(&hash, invalidHashStrings[stringNdx]));
 		}
 	}

 	/* Compare valid hash strings for equality. */
 	{
 		size_t stringNdx;

 		for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
 		{
 			deSha1 hashA;
 			deSha1 hashB;

 			deMemset(&hashA, garbage, sizeof(deSha1));
 			deMemset(&hashB, garbage, sizeof(deSha1));

 			DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringNdx]));
 			DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringNdx]));

 			DE_TEST_ASSERT(deSha1_equal(&hashA, &hashA));
 			DE_TEST_ASSERT(deSha1_equal(&hashA, &hashB));
 			DE_TEST_ASSERT(deSha1_equal(&hashB, &hashA));
 		}
 	}

 	/* Compare valid different hash strings for equality. */
 	{
 		size_t stringANdx;
 		size_t stringBNdx;

 		for (stringANdx = 0; stringANdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringANdx++)
 		for (stringBNdx = 0; stringBNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringBNdx++)
 		{
 			deSha1 hashA;
 			deSha1 hashB;

 			if (stringANdx == stringBNdx)
 				continue;

 			deMemset(&hashA, garbage, sizeof(deSha1));
 			deMemset(&hashB, garbage, sizeof(deSha1));

 			DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringANdx]));
 			DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringBNdx]));

 			DE_TEST_ASSERT(!deSha1_equal(&hashA, &hashB));
 			DE_TEST_ASSERT(!deSha1_equal(&hashB, &hashA));
 		}
 	}

 	/* Test rendering hash as string. */
 	{
 		size_t stringNdx;

 		for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
 		{
 			char	result[40];
 			deSha1	hash;

 			deMemset(&hash, garbage, sizeof(hash));
 			deMemset(&result, garbage, sizeof(result));

 			DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
 			deSha1_render(&hash, result);

 			DE_TEST_ASSERT(strncmp(result, validHashStrings[stringNdx], 40) == 0);
 		}
 	}

 	/* Test hash against few pre-computed cases. */
 	{
 		size_t ndx;

 		for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
 		{
 			deSha1 result;
 			deSha1 reference;

 			deSha1_compute(&result, strlen(stringHashPairs[ndx].data),  stringHashPairs[ndx].data);
 			DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));

 			DE_TEST_ASSERT(deSha1_equal(&reference, &result));
 		}
 	}

 	/* Test hash stream against few pre-computed cases. */
 	{
 		size_t ndx;

 		for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
 		{
 			const char* const	data	= stringHashPairs[ndx].data;
 			const size_t		size	= strlen(data);

 			deSha1Stream		stream;
 			deSha1				result;
 			deSha1				reference;

 			deSha1Stream_init(&stream);

 			deSha1Stream_process(&stream, size/2, data);
 			deSha1Stream_process(&stream, size - (size/2), data + size/2);

 			deSha1Stream_finalize(&stream, &result);

 			deSha1_compute(&result, strlen(stringHashPairs[ndx].data),  stringHashPairs[ndx].data);
 			DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));

 			DE_TEST_ASSERT(deSha1_equal(&reference, &result));
 		}
 	}
 }

 DE_END_EXTERN_C
	/*-------------------------------------------------------------------------
	* drawElements Base Portability Library
	* -------------------------------------
	*
	* Copyright 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief SHA1 hash functions.
	//--------------------------------------------------------------------*/

	#include "deSha1.h"

	#include "deMemory.h"

	DE_BEGIN_EXTERN_C

	enum
	{
	CHUNK_BIT_SIZE = 512,
	CHUNK_BYTE_SIZE = CHUNK_BIT_SIZE / 8
	};

	static deUint32 leftRotate (deUint32 val, deUint32 count)
	{
	DE_ASSERT(count < 32);

	return (val << count) \| (val >> (32 - count));
	}

	void deSha1Stream_init (deSha1Stream* stream)
	{
	stream->size = 0;

	/* Set the initial 16 deUint32s that contain real data to zeros. */
	deMemset(stream->data, 0, 16 * sizeof(deUint32));

	stream->hash[0] = 0x67452301u;
	stream->hash[1] = 0xEFCDAB89u;
	stream->hash[2] = 0x98BADCFEu;
	stream->hash[3] = 0x10325476u;
	stream->hash[4] = 0xC3D2E1F0u;
	}

	static void deSha1Stream_flushChunk (deSha1Stream* stream)
	{
	DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0 && stream->size > 0);

	{
	size_t ndx;

	/* Expand the 16 uint32s that contain the data to 80. */
	for (ndx = 16; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
	{
	stream->data[ndx] = leftRotate(stream->data[ndx - 3]
	^ stream->data[ndx - 8]
	^ stream->data[ndx - 14]
	^ stream->data[ndx - 16], 1);
	}
	}

	{
	deUint32 a = stream->hash[0];
	deUint32 b = stream->hash[1];
	deUint32 c = stream->hash[2];
	deUint32 d = stream->hash[3];
	deUint32 e = stream->hash[4];
	size_t ndx;

	for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
	{
	deUint32 f;
	deUint32 k;

	if (ndx < 20)
	{
	f = (b & c) \| ((~b) & d);
	k = 0x5A827999u;
	}
	else if (ndx < 40)
	{
	f = b ^ c ^ d;
	k = 0x6ED9EBA1u;
	}
	else if (ndx < 60)
	{
	f = (b & c) \| (b & d) \| (c & d);
	k = 0x8F1BBCDCu;
	}
	else
	{
	f = b ^ c ^ d;
	k = 0xCA62C1D6u;
	}

	{
	const deUint32 tmp = leftRotate(a, 5) + f + e + k + stream->data[ndx];

	e = d;
	d = c;
	c = leftRotate(b, 30);
	b = a;
	a = tmp;
	}
	}

	stream->hash[0] += a;
	stream->hash[1] += b;
	stream->hash[2] += c;
	stream->hash[3] += d;
	stream->hash[4] += e;

	/* Set the initial 16 deUint32s that contain the real data to zeros. */
	deMemset(stream->data, 0, 16 * sizeof(deUint32));
	}
	}

	void deSha1Stream_process (deSha1Stream* stream, size_t size, const void* data_)
	{
	const deUint8* const data = (const deUint8*)data_;
	size_t bytesProcessed = 0;

	while (bytesProcessed < size)
	{
	do
	{
	const size_t bitOffset = (size_t)(8 * (4 - (1 + (stream->size % 4))));

	stream->data[(stream->size / 4) % 16] \|= ((deUint32)data[bytesProcessed]) << (deUint32)bitOffset;

	stream->size++;
	bytesProcessed++;
	}
	while (stream->size % CHUNK_BYTE_SIZE != 0 && bytesProcessed < size);

	if (stream->size % CHUNK_BYTE_SIZE == 0)
	deSha1Stream_flushChunk(stream);
	}

	DE_ASSERT(bytesProcessed == size);
	}

	void deSha1Stream_finalize (deSha1Stream* stream, deSha1* hash)
	{
	/* \note First element is initialized to 0x80u and rest to 0x0. */
	static const deUint8 padding[CHUNK_BYTE_SIZE] = { 0x80u };
	const deUint64 length = stream->size * 8;
	deUint8 lengthData[sizeof(deUint64)];
	size_t ndx;

	DE_ASSERT(padding[0] == 0x80u);
	DE_ASSERT(padding[1] == 0x0u);

	for (ndx = 0; ndx < sizeof(deUint64); ndx++)
	lengthData[ndx] = (deUint8)(0xffu & (length >> (8 * (sizeof(deUint64) - 1 - ndx))));

	{
	const deUint64 spaceLeftInChunk = CHUNK_BYTE_SIZE - (stream->size % CHUNK_BYTE_SIZE);

	if (spaceLeftInChunk >= 1 + sizeof(lengthData))
	deSha1Stream_process(stream, (size_t)(spaceLeftInChunk - sizeof(lengthData)), padding);
	else
	deSha1Stream_process(stream, (size_t)(CHUNK_BYTE_SIZE - (sizeof(lengthData)) - spaceLeftInChunk), padding);
	}

	deSha1Stream_process(stream, sizeof(lengthData), lengthData);
	DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0);

	deMemcpy(hash->hash, stream->hash, sizeof(hash->hash));
	}

	void deSha1_compute (deSha1* hash, size_t size, const void* data)
	{
	deSha1Stream stream;

	deSha1Stream_init(&stream);
	deSha1Stream_process(&stream, size, data);
	deSha1Stream_finalize(&stream, hash);
	}

	void deSha1_render (const deSha1* hash, char* buffer)
	{
	size_t charNdx;

	for (charNdx = 0; charNdx < 40; charNdx++)
	{
	const deUint32 val32 = hash->hash[charNdx / 8];
	const deUint8 val8 = (deUint8)(0x0fu & (val32 >> (4 * (8 - 1 - (charNdx % 8)))));

	if (val8 < 10)
	buffer[charNdx] = (char)('0' + val8);
	else
	buffer[charNdx] = (char)('a' + val8 - 10);
	}
	}

	deBool deSha1_parse (deSha1* hash, const char* buffer)
	{
	size_t charNdx;

	deMemset(hash->hash, 0, sizeof(hash->hash));

	for (charNdx = 0; charNdx < 40; charNdx++)
	{
	deUint8 val4;

	if (buffer[charNdx] >= '0' && buffer[charNdx] <= '9')
	val4 = (deUint8)(buffer[charNdx] - '0');
	else if (buffer[charNdx] >= 'a' && buffer[charNdx] <= 'f')
	val4 = (deUint8)(10 + (buffer[charNdx] - 'a'));
	else if (buffer[charNdx] >= 'A' && buffer[charNdx] <= 'F')
	val4 = (deUint8)(10 + (buffer[charNdx] - 'A'));
	else
	return DE_FALSE;

	hash->hash[charNdx / 8] \|= ((deUint32)val4) << (4 * (8u - 1u - (charNdx % 8u)));
	}

	return DE_TRUE;
	}

	deBool deSha1_equal (const deSha1* a, const deSha1* b)
	{
	/* \note deMemcmp() can only be used for equality. It doesn't provide correct ordering between hashes. */
	return deMemCmp(a->hash, b->hash, sizeof(b->hash)) == 0;
	}

	void deSha1_selfTest (void)
	{
	const char* const validHashStrings[] =
	{
	"ac890cfca05717c05dc831996b2289251da2984e",
	"0f87ba807acb3e6effe617249f30453a524a2ea3",
	"6f483cc3fa820e58ed9f83c83bdf8d213293b3ad"
	};

	const char* const invalidHashStrings[] =
	{
	" c890cfca05717c05dc831996b2289251da2984e",
	"0f87ba807acb3e6 ffe617249f30453a524a2ea3",
	"6f483cc3fa820e58ed9f83c83bdf8d213293b3a ",

	"mc890cfca05717c05dc831996b2289251da2984e",
	"0f87ba807acb3e6effe617249fm0453a524a2ea3",
	"6f483cc3fa820e58ed9f83c83bdf8d213293b3an",

	"ac890cfca05717c05dc83\n996b2289251da2984e",
	"0f87ba807acb3e6effe617\t49f30453a524a2ea3",
	"ac890cfca05717c05dc831\096b2289251da2984e",
	"6f483cc3fa{20e58ed9f83c83bdf8d213293b3ad"
	};

	const struct
	{
	const char* const hash;
	const char* const data;
	} stringHashPairs[] =
	{
	/* Generated using sha1sum. */
	{ "da39a3ee5e6b4b0d3255bfef95601890afd80709", "" },
	{ "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d", "hello" },
	{ "ec1919e856540f42bd0e6f6c1ffe2fbd73419975",
	"Cherry is a browser-based GUI for controlling deqp test runs and analysing the test results."
	}
	};

	const int garbage = 0xde;

	/* Test parsing valid sha1 strings. */
	{
	size_t stringNdx;

	for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
	{
	deSha1 hash;
	deMemset(&hash, garbage, sizeof(deSha1));
	DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
	}
	}

	/* Test parsing invalid sha1 strings. */
	{
	size_t stringNdx;

	for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(invalidHashStrings); stringNdx++)
	{
	deSha1 hash;
	deMemset(&hash, garbage, sizeof(deSha1));
	DE_TEST_ASSERT(!deSha1_parse(&hash, invalidHashStrings[stringNdx]));
	}
	}

	/* Compare valid hash strings for equality. */
	{
	size_t stringNdx;

	for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
	{
	deSha1 hashA;
	deSha1 hashB;

	deMemset(&hashA, garbage, sizeof(deSha1));
	deMemset(&hashB, garbage, sizeof(deSha1));

	DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringNdx]));
	DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringNdx]));

	DE_TEST_ASSERT(deSha1_equal(&hashA, &hashA));
	DE_TEST_ASSERT(deSha1_equal(&hashA, &hashB));
	DE_TEST_ASSERT(deSha1_equal(&hashB, &hashA));
	}
	}

	/* Compare valid different hash strings for equality. */
	{
	size_t stringANdx;
	size_t stringBNdx;

	for (stringANdx = 0; stringANdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringANdx++)
	for (stringBNdx = 0; stringBNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringBNdx++)
	{
	deSha1 hashA;
	deSha1 hashB;

	if (stringANdx == stringBNdx)
	continue;

	deMemset(&hashA, garbage, sizeof(deSha1));
	deMemset(&hashB, garbage, sizeof(deSha1));

	DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringANdx]));
	DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringBNdx]));

	DE_TEST_ASSERT(!deSha1_equal(&hashA, &hashB));
	DE_TEST_ASSERT(!deSha1_equal(&hashB, &hashA));
	}
	}

	/* Test rendering hash as string. */
	{
	size_t stringNdx;

	for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
	{
	char result[40];
	deSha1 hash;

	deMemset(&hash, garbage, sizeof(hash));
	deMemset(&result, garbage, sizeof(result));

	DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
	deSha1_render(&hash, result);

	DE_TEST_ASSERT(strncmp(result, validHashStrings[stringNdx], 40) == 0);
	}
	}

	/* Test hash against few pre-computed cases. */
	{
	size_t ndx;

	for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
	{
	deSha1 result;
	deSha1 reference;

	deSha1_compute(&result, strlen(stringHashPairs[ndx].data), stringHashPairs[ndx].data);
	DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));

	DE_TEST_ASSERT(deSha1_equal(&reference, &result));
	}
	}

	/* Test hash stream against few pre-computed cases. */
	{
	size_t ndx;

	for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
	{
	const char* const data = stringHashPairs[ndx].data;
	const size_t size = strlen(data);

	deSha1Stream stream;
	deSha1 result;
	deSha1 reference;

	deSha1Stream_init(&stream);

	deSha1Stream_process(&stream, size/2, data);
	deSha1Stream_process(&stream, size - (size/2), data + size/2);

	deSha1Stream_finalize(&stream, &result);

	deSha1_compute(&result, strlen(stringHashPairs[ndx].data), stringHashPairs[ndx].data);
	DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));

	DE_TEST_ASSERT(deSha1_equal(&reference, &result));
	}
	}
	}

	DE_END_EXTERN_C