/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/* test-gck-attributes.c - the GObject PKCS#11 wrapper library

   Copyright (C) 2011 Collabora Ltd.

   The Gnome Keyring Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public License as

   published by the Free Software Foundation; either version 2 of the

   License, or (at your option) any later version.

   The Gnome Keyring Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with the Gnome Library; see the file COPYING.LIB.  If not,

   see <http://www.gnu.org/licenses/>.

   Author: Stef Walter <stefw@collabora.co.uk>

*/

#include "config.h"

#include <glib.h>

#include <string.h>

#include "egg/egg-secure-memory.h"

#include "gck/gck.h"

#include "gck/gck-test.h"

EGG_SECURE_DECLARE (test_gck_attributes);

#define ATTR_TYPE 55

#define ATTR_DATA (const guchar *)"TEST DATA"

#define N_ATTR_DATA ((gsize)9)

static void

test_init_memory (void)

{

	GckAttribute attr;

	g_assert (sizeof (attr) == sizeof (CK_ATTRIBUTE));

	gck_attribute_init (&attr, ATTR_TYPE, (const guchar *)ATTR_DATA, N_ATTR_DATA);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == N_ATTR_DATA);

	g_assert (memcmp (attr.value, ATTR_DATA, attr.length) == 0);

	gck_attribute_clear (&attr);

}

static void

test_init_boolean (void)

{

	GckAttribute attr;

	gck_attribute_init_boolean (&attr, ATTR_TYPE, TRUE);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == sizeof (CK_BBOOL));

	g_assert (*((CK_BBOOL*)attr.value) == CK_TRUE);

	gck_attribute_clear (&attr);

}

static void

test_init_date (void)

{

	GckAttribute attr;

	CK_DATE ck_date;

	GDate *date;

	date = g_date_new_dmy(05, 06, 1960);

	memcpy (ck_date.year, "1960", 4);

	memcpy (ck_date.month, "06", 2);

	memcpy (ck_date.day, "05", 2);

	gck_attribute_init_date (&attr, ATTR_TYPE, date);

	g_date_free (date);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == sizeof (CK_DATE));

	g_assert (memcmp (attr.value, &ck_date, attr.length) == 0);

	gck_attribute_clear (&attr);

}

static void

test_init_ulong (void)

{

	GckAttribute attr;

	gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == sizeof (CK_ULONG));

	g_assert (*((CK_ULONG*)attr.value) == 88);

	gck_attribute_clear (&attr);

}

static void

test_init_string (void)

{

	GckAttribute attr;

	gck_attribute_init_string (&attr, ATTR_TYPE, "a test string");

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == strlen ("a test string"));

	g_assert (memcmp (attr.value, "a test string", attr.length) == 0);

	gck_attribute_clear (&attr);

}

static void

test_init_invalid (void)

{

	GckAttribute attr;

	gck_attribute_init_invalid (&attr, ATTR_TYPE);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == (gulong)-1);

	g_assert (attr.value == NULL);

	g_assert (gck_attribute_is_invalid (&attr));

	gck_attribute_clear (&attr);

}

static void

test_init_empty (void)

{

	GckAttribute attr;

	gck_attribute_init_empty (&attr, ATTR_TYPE);

	g_assert (attr.type == ATTR_TYPE);

	g_assert (attr.length == 0);

	g_assert (attr.value == NULL);

	gck_attribute_clear (&attr);

}

static void

test_new_memory (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new (ATTR_TYPE, ATTR_DATA, N_ATTR_DATA);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == N_ATTR_DATA);

	g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);

	gck_attribute_free (attr);

}

static void

test_new_boolean (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_boolean (ATTR_TYPE, TRUE);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_BBOOL));

	g_assert (*((CK_BBOOL*)attr->value) == CK_TRUE);

	gck_attribute_free (attr);

}

static void

test_new_date (void)

{

	GckAttribute *attr;

	CK_DATE ck_date;

	GDate *date;

	date = g_date_new_dmy(05, 06, 1800);

	memcpy (ck_date.year, "1800", 4);

	memcpy (ck_date.month, "06", 2);

	memcpy (ck_date.day, "05", 2);

	attr = gck_attribute_new_date (ATTR_TYPE, date);

	g_date_free (date);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_DATE));

	g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);

	gck_attribute_free (attr);

}

static void

test_new_ulong (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_ulong (ATTR_TYPE, 88);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_ULONG));

	g_assert (*((CK_ULONG*)attr->value) == 88);

	gck_attribute_free (attr);

}

static void

test_new_string (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_string (ATTR_TYPE, "a test string");

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == strlen ("a test string"));

	g_assert (memcmp (attr->value, "a test string", attr->length) == 0);

	gck_attribute_free (attr);

}

static void

test_new_invalid (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_invalid (ATTR_TYPE);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == (gulong)-1);

	g_assert (attr->value == NULL);

	g_assert (gck_attribute_is_invalid (attr));

	gck_attribute_free (attr);

}

static void

test_new_empty (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_empty (ATTR_TYPE);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == 0);

	g_assert (attr->value == NULL);

	gck_attribute_free (attr);

}

static void

test_get_boolean (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_boolean (ATTR_TYPE, TRUE);

	g_assert (gck_attribute_get_boolean (attr) == TRUE);

	gck_attribute_free (attr);

}

static void

test_get_date (void)

{

	GckAttribute *attr;

	CK_DATE ck_date;

	GDate date, date2;

	g_date_set_dmy(&date, 05, 06, 1800);

	memcpy (ck_date.year, "1800", 4);

	memcpy (ck_date.month, "06", 2);

	memcpy (ck_date.day, "05", 2);

	attr = gck_attribute_new_date (ATTR_TYPE, &date);

	gck_attribute_get_date (attr, &date2);

	g_assert (g_date_compare (&date, &date2) == 0);

	gck_attribute_free (attr);

}

static void

test_get_ulong (void)

{

	GckAttribute *attr;

	attr = gck_attribute_new_ulong (ATTR_TYPE, 88);

	g_assert (gck_attribute_get_ulong (attr) == 88);

	gck_attribute_free (attr);

}

static void

test_get_string (void)

{

	GckAttribute *attr;

	gchar *value;

	attr = gck_attribute_new_string (ATTR_TYPE, "a test string");

	value = gck_attribute_get_string (attr);

	g_assert (strcmp ("a test string", value) == 0);

	g_free (value);

	gck_attribute_free (attr);

	/* Should be able to store null strings */

	attr = gck_attribute_new_string (ATTR_TYPE, NULL);

	value = gck_attribute_get_string (attr);

	g_assert (value == NULL);

	gck_attribute_free (attr);

}

static void

test_dup_attribute (void)

{

	GckAttribute attr, *dup;

	gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);

	dup = gck_attribute_dup (&attr);

	gck_attribute_clear (&attr);

	g_assert (gck_attribute_get_ulong (dup) == 88);

	g_assert (dup->type == ATTR_TYPE);

	gck_attribute_free (dup);

	/* Should be able to dup null */

	dup = gck_attribute_dup (NULL);

	g_assert (dup == NULL);

}

static void

test_copy_attribute (void)

{

	GckAttribute attr, copy;

	gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);

	gck_attribute_init_copy (&copy, &attr);

	gck_attribute_clear (&attr);

	g_assert (gck_attribute_get_ulong (&copy) == 88);

	g_assert (copy.type == ATTR_TYPE);

	gck_attribute_clear (©);

}

static void

builder_add_fixtures (GckBuilder *builder,

                      guint seed)

{

	GDate *date = g_date_new_dmy (11 + seed, 12, 2008);

	gck_builder_add_boolean (builder, 0UL, (TRUE + seed) % 2);

	gck_builder_add_ulong (builder, 101UL, 888 + seed);

	gck_builder_add_string (builder, 202UL, "string");

	gck_builder_add_date (builder, 303UL, date);

	g_date_free (date);

	gck_builder_add_data (builder, 404UL, (const guchar *)ATTR_DATA, N_ATTR_DATA);

	gck_builder_add_invalid (builder, 505UL);

	gck_builder_add_empty (builder, 606UL);

}

static void

test_builder_blank (void)

{

	GckBuilder builder;

	gck_builder_init (&builder);

	g_assert (gck_builder_find (&builder, 88) == NULL);

	gck_builder_clear (&builder);

}

static void

test_build_data (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gck_builder_add_data (&builder, ATTR_TYPE, (const guchar *)"Hello", 5);

	attr = gck_builder_find (&builder, ATTR_TYPE);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == 5);

	g_assert (memcmp (attr->value, "Hello", attr->length) == 0);

	gck_builder_set_data (&builder, ATTR_TYPE, (const guchar *)ATTR_DATA, N_ATTR_DATA);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == N_ATTR_DATA);

	g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == N_ATTR_DATA);

	g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);

	gck_attributes_unref (attrs);

}

static void

test_build_data_invalid (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gck_builder_add_data (&builder, ATTR_TYPE, NULL, GCK_INVALID);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (gck_attribute_is_invalid (attr));

	gck_attributes_unref (attrs);

}

static void

test_build_data_secure (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	guchar *memory;

	memory = egg_secure_strdup ("password");

	gck_builder_add_data (&builder, ATTR_TYPE, memory, 8);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == 8);

	g_assert (memcmp (attr->value, "password", attr->length) == 0);

	g_assert (egg_secure_check (attr->value) == TRUE);

	egg_secure_free (memory);

	gck_attributes_unref (attrs);

}

static void

test_build_take (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	guchar *memory;

	memory = g_memdup (ATTR_DATA, N_ATTR_DATA);

	gck_builder_take_data (&builder, ATTR_TYPE, memory, N_ATTR_DATA);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == N_ATTR_DATA);

	g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);

	gck_attributes_unref (attrs);

}

static void

test_build_take_invalid (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gpointer memory;

	/* This memory should be freed */

	memory = g_strdup ("BLAH");

	gck_builder_take_data (&builder, ATTR_TYPE, memory, GCK_INVALID);

	/* This memory should be freed */

	memory = egg_secure_strdup ("BLAH");

	gck_builder_take_data (&builder, ATTR_TYPE, memory, GCK_INVALID);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (gck_attribute_is_invalid (attr));

	gck_attributes_unref (attrs);

}

static void

test_build_take_secure (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	guchar *memory;

	memory = egg_secure_strdup ("password");

	gck_builder_take_data (&builder, ATTR_TYPE, memory, 8);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == 8);

	g_assert (memcmp (attr->value, "password", attr->length) == 0);

	g_assert (egg_secure_check (attr->value) == TRUE);

	gck_attributes_unref (attrs);

}

static void

test_value_to_boolean (void)

{

	CK_BBOOL data = CK_TRUE;

	gboolean result = FALSE;

	if (!gck_value_to_boolean (&data, sizeof (data), &result))

		g_assert_not_reached ();

	g_assert (result == TRUE);

	if (!gck_value_to_boolean (&data, sizeof (data), NULL))

		g_assert_not_reached ();

	/* Should fail */

	if (gck_value_to_boolean (&data, 0, NULL))

		g_assert_not_reached ();

	if (gck_value_to_boolean (&data, 2, NULL))

		g_assert_not_reached ();

	if (gck_value_to_boolean (&data, (CK_ULONG)-1, NULL))

		g_assert_not_reached ();

}

static void

test_value_to_ulong (void)

{

	CK_ULONG data = 34343;

	gulong result = 0;

	if (!gck_value_to_ulong ((const guchar *)&data, sizeof (data), &result))

		g_assert_not_reached ();

	g_assert (result == 34343);

	if (!gck_value_to_ulong ((const guchar *)&data, sizeof (data), NULL))

		g_assert_not_reached ();

	/* Should fail */

	if (gck_value_to_ulong ((const guchar *)&data, 0, NULL))

		g_assert_not_reached ();

	if (gck_value_to_ulong ((const guchar *)&data, 2, NULL))

		g_assert_not_reached ();

	if (gck_value_to_ulong ((const guchar *)&data, (CK_ULONG)-1, NULL))

		g_assert_not_reached ();

}

static void

test_build_boolean (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gboolean value;

	g_assert (gck_builder_find_boolean (&builder, 5, &value) == FALSE);

	gck_builder_add_boolean (&builder, ATTR_TYPE, FALSE);

	gck_builder_set_invalid (&builder, 5);

	g_assert (gck_builder_find_boolean (&builder, 5, &value) == FALSE);

	gck_builder_set_boolean (&builder, 5, TRUE);

	attr = gck_builder_find (&builder, ATTR_TYPE);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_BBOOL));

	g_assert (*((CK_BBOOL*)attr->value) == CK_FALSE);

	if (!gck_builder_find_boolean (&builder, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == FALSE);

	gck_builder_set_boolean (&builder, ATTR_TYPE, TRUE);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_BBOOL));

	g_assert (*((CK_BBOOL*)attr->value) == CK_TRUE);

	if (!gck_builder_find_boolean (&builder, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == TRUE);

	if (!gck_builder_find_boolean (&builder, 5, &value))

		g_assert_not_reached ();

	g_assert (value == TRUE);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_BBOOL));

	g_assert (*((CK_BBOOL*)attr->value) == CK_TRUE);

	if (!gck_attributes_find_boolean (attrs, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == TRUE);

	g_assert (gck_attribute_get_boolean (attr) == TRUE);

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_build_date (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	CK_DATE ck_date;

	GDate *date, date2;

	g_assert (gck_builder_find_date (&builder, 5, &date2) == FALSE);

	date = g_date_new_dmy(8, 8, 1960);

	memcpy (ck_date.year, "1960", 4);

	memcpy (ck_date.month, "08", 2);

	memcpy (ck_date.day, "08", 2);

	gck_builder_add_date (&builder, ATTR_TYPE, date);

	gck_builder_set_invalid (&builder, 5);

	g_assert (gck_builder_find_date (&builder, 5, &date2) == FALSE);

	attr = gck_builder_find (&builder, 5);

	gck_attribute_get_date (attr, &date2);

	g_assert_cmpint (date2.day, ==, 0);

	g_assert_cmpint (date2.month, ==, 0);

	g_assert_cmpint (date2.year, ==, 0);

	gck_builder_set_date (&builder, 5, date);

	attr = gck_builder_find (&builder, ATTR_TYPE);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_DATE));

	g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);

	if (!gck_builder_find_date (&builder, ATTR_TYPE, &date2))

		g_assert_not_reached ();

	g_assert (g_date_compare (date, &date2) == 0);

	if (!gck_builder_find_date (&builder, 5, &date2))

		g_assert_not_reached ();

	g_assert (g_date_compare (date, &date2) == 0);

	g_date_free (date);

	date = g_date_new_dmy(05, 06, 1960);

	memcpy (ck_date.year, "1960", 4);

	memcpy (ck_date.month, "06", 2);

	memcpy (ck_date.day, "05", 2);

	gck_builder_set_date (&builder, ATTR_TYPE, date);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_DATE));

	g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);

	if (!gck_builder_find_date (&builder, ATTR_TYPE, &date2))

		g_assert_not_reached ();

	g_assert (g_date_compare (date, &date2) == 0);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_DATE));

	g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);

	gck_attribute_get_date (attr, &date2);

	g_assert (g_date_compare (date, &date2) == 0);

	g_date_free (date);

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_build_ulong (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gulong value;

	g_assert (gck_builder_find_ulong (&builder, 5, &value) == FALSE);

	gck_builder_add_ulong (&builder, ATTR_TYPE, 99);

	gck_builder_set_invalid (&builder, 5);

	g_assert (gck_builder_find_ulong (&builder, 5, &value) == FALSE);

	gck_builder_set_ulong (&builder, 5, 292);

	attr = gck_builder_find (&builder, ATTR_TYPE);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_ULONG));

	g_assert (*((CK_ULONG*)attr->value) == 99);

	if (!gck_builder_find_ulong (&builder, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == 99);

	gck_builder_set_ulong (&builder, ATTR_TYPE, 88);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_ULONG));

	g_assert (*((CK_ULONG*)attr->value) == 88);

	if (!gck_builder_find_ulong (&builder, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == 88);

	if (!gck_builder_find_ulong (&builder, 5, &value))

		g_assert_not_reached ();

	g_assert (value == 292);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == sizeof (CK_ULONG));

	g_assert (*((CK_ULONG*)attr->value) == 88);

	if (!gck_attributes_find_ulong (attrs, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert (value == 88);

	g_assert (gck_attribute_get_ulong (attr) == 88);

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_build_string (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gchar *value;

	g_assert (gck_builder_find_string (&builder, 5, &value) == FALSE);

	gck_builder_add_string (&builder, ATTR_TYPE, "My my");

	gck_builder_set_invalid (&builder, 5);

	g_assert (gck_builder_find_string (&builder, 5, &value) == FALSE);

	gck_builder_set_string (&builder, 5, "Hello");

	attr = gck_builder_find (&builder, ATTR_TYPE);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == strlen ("My my"));

	g_assert (memcmp (attr->value, "My my", attr->length) == 0);

	if (!gck_builder_find_string (&builder, 5, &value))

		g_assert_not_reached ();

	g_assert_cmpstr (value, ==, "Hello");

	g_free (value);

	gck_builder_set_string (&builder, ATTR_TYPE, "a test string");

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == strlen ("a test string"));

	g_assert (memcmp (attr->value, "a test string", attr->length) == 0);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr != NULL);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == strlen ("a test string"));

	g_assert (memcmp (attr->value, "a test string", attr->length) == 0);

	if (!gck_attributes_find_string (attrs, ATTR_TYPE, &value))

		g_assert_not_reached ();

	g_assert_cmpstr ("a test string", ==, value);

	g_free (value);

	value = gck_attribute_get_string (attr);

	g_assert_cmpstr ("a test string", ==, value);

	g_free (value);

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_build_string_null (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gchar *value;

	gck_builder_add_string (&builder, ATTR_TYPE, NULL);

	g_assert (gck_builder_find_string (&builder, ATTR_TYPE, &value) == FALSE);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->value == NULL);

	g_assert (attr->length == 0);

	value = gck_attribute_get_string (attr);

	g_assert (value == NULL);

	gck_attributes_unref (attrs);

}

static void

test_build_invalid (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gck_builder_add_invalid (&builder, ATTR_TYPE);

	gck_builder_set_invalid (&builder, ATTR_TYPE);

	gck_builder_set_invalid (&builder, 5);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == (gulong)-1);

	g_assert (attr->value == NULL);

	g_assert (gck_attribute_is_invalid (attr));

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_build_empty (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	const GckAttribute *attr;

	gck_builder_add_empty (&builder, ATTR_TYPE);

	gck_builder_set_empty (&builder, ATTR_TYPE);

	gck_builder_set_empty (&builder, 5);

	attr = gck_builder_find (&builder, 5);

	g_assert (attr->type == 5);

	g_assert (attr->length == 0);

	g_assert (attr->value == NULL);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (attr->type == ATTR_TYPE);

	g_assert (attr->length == 0);

	g_assert (attr->value == NULL);

	g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);

	gck_attributes_unref (attrs);

}

static void

test_builder_secure (void)

{

	GckAttributes *attrs;

	GckBuilder builder;

	const GckAttribute *attr;

	gck_builder_init_full (&builder, GCK_BUILDER_SECURE_MEMORY);

	gck_builder_add_boolean (&builder, 88, TRUE);

	attrs = gck_builder_end (&builder);

	attr = gck_attributes_at (attrs, 0);

	g_assert (egg_secure_check (attr->value));

	gck_attributes_unref (attrs);

}

static void

test_builder_copy (void)

{

	GckBuilder builder = GCK_BUILDER_INIT;

	GckAttributes *attrs;

	GckBuilder *copy;

	const GckAttribute *attr;

	gck_builder_add_ulong (&builder, ATTR_TYPE, 88);

	copy = gck_builder_copy (&builder);

	gck_builder_clear (&builder);

	attrs = gck_builder_end (copy);

	gck_builder_unref (copy);

	attr = gck_attributes_at (attrs, 0);

	g_assert (gck_attribute_get_ulong (attr) == 88);

	g_assert (attr->type == ATTR_TYPE);

	/* Should be able to copy null */

	copy = gck_builder_copy (NULL);

	g_assert (copy == NULL);

	gck_attributes_unref (attrs);

}

static void