static void test_isEqualRefCount(void)
{
int data2 = 0xbad00bad;
RefCount *refCount1 = NULL;
RefCount *refCount2 = NULL;
// initialize refcount1
RefCountNew(&refCount1);
assert_int_equal(0, refCount1->user_count);
assert_true(refCount1->last == NULL);
assert_true(refCount1->users == NULL);
// initialize refcount2 as a copy of refcount1
refCount2 = refCount1;
// isEqual should return true
assert_true(RefCountIsEqual(refCount1, refCount2));
/* Initialize refcount2 on its own */
RefCountNew(&refCount2);
assert_int_equal(0, refCount2->user_count);
assert_true(refCount2->last == NULL);
assert_true(refCount2->users == NULL);
// isEqual should return false
assert_false(RefCountIsEqual(refCount1, refCount2));
// Add one to refcount1
RefCountAttach(refCount1, &data2);
// isEqual should return false
assert_false(RefCountIsEqual(refCount1, refCount2));
// Add the same to refcount2
RefCountAttach(refCount2, &data2);
// isEqual should return false
assert_false(RefCountIsEqual(refCount1, refCount2));
// Try one NULL
assert_false(RefCountIsEqual(refCount1, NULL));
assert_false(RefCountIsEqual(NULL, refCount2));
// Both NULL
assert_false(RefCountIsEqual(NULL, NULL));
// Destroy both refcounts
RefCountDestroy(&refCount1);
RefCountDestroy(&refCount2);
}
int BufferEqual(Buffer *buffer1, Buffer *buffer2)
{
/*
* Rules for comparison:
* 1. First check the refcount elements, if they are the same
* then the elements are the same.
* 2. Look at the mode, even if the content is the same the interpretation might be different.
* 3. Look at the content. For BUFFER_BEHAVIOR_CSTRING mode we stop at the first '\0'.
*/
if (RefCountIsEqual(buffer1->ref_count, buffer2->ref_count))
{
return 1;
}
if (buffer1->mode != buffer2->mode)
{
return 0;
}
int mode = buffer1->mode;
if (buffer1->used == buffer2->used)
{
int i = 0;
int equal = 1;
for (i = 0; (i < buffer1->used); i++)
{
if (buffer1->buffer[i] != buffer2->buffer[i])
{
equal = 0;
break;
}
if (('\0' == buffer1->buffer[i]) && (mode == BUFFER_BEHAVIOR_CSTRING))
{
break;
}
}
return equal;
}
return 0;
}
int BufferCompare(Buffer *buffer1, Buffer *buffer2)
{
/*
* Quick safety check. If buffer1 is NULL, then it is immediately smaller than buffer2.
* Same if buffer2 is NULL. If both are NULL, then they are equal.
*/
if (!buffer1 && !buffer2)
{
return 0;
}
else if (!buffer1 && buffer2)
{
return -1;
}
else if (buffer1 && !buffer2)
{
return 1;
}
/*
* Rules for comparison:
* 1. First check the refcount elements, if they are the same
* then the elements are the same.
* 2. Check the content
* 2.1. If modes are different, check until the first '\0'
* 2.2. If sizes are different, check until the first buffer ends.
*/
if (RefCountIsEqual(buffer1->ref_count, buffer2->ref_count))
{
return 0;
}
if (buffer1->mode == buffer2->mode)
{
if (buffer1->mode == BUFFER_BEHAVIOR_CSTRING)
{
/*
* C String comparison
*/
return strcmp(buffer1->buffer, buffer2->buffer);
}
else
{
/*
* BUFFER_BEHAVIOR_BYTEARRAY
* Byte by byte comparison
*/
unsigned int i = 0;
if (buffer1->used < buffer2->used)
{
for (i = 0; i < buffer1->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
return -1;
}
else if (buffer1->used == buffer2->used)
{
for (i = 0; i < buffer1->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
}
else
{
for (i = 0; i < buffer2->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
return 1;
}
}
}
else
{
/*
* Mixed comparison
* Notice that every BYTEARRAY was born as a CSTRING.
* When we switch back to CSTRING we adjust the length to
* match the first '\0'.
*/
unsigned int i = 0;
if (buffer1->used < buffer2->used)
{
for (i = 0; i < buffer1->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
return -1;
}
else if (buffer1->used == buffer2->used)
{
for (i = 0; i < buffer1->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
}
else
{
for (i = 0; i < buffer2->used; ++i)
{
if (buffer1->buffer[i] < buffer2->buffer[i])
{
return -1;
}
else if (buffer1->buffer[i] > buffer2->buffer[i])
{
return 1;
}
}
return 1;
}
}
/*
* We did all we could and the buffers seems to be equal.
*/
return 0;
}
