test/api/test-blob.c - third_party/harfbuzz - Git at Google

 /*
  * Copyright © 2011  Google, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  *
  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Google Author(s): Behdad Esfahbod
  */

 #include "hb-test.h"

 /* Unit tests for hb-blob.h */

 #if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT) && defined(HAVE_MMAP)

 # define TEST_MMAP 1

 #ifdef HAVE_SYS_MMAN_H
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif /* HAVE_UNISTD_H */
 #include <sys/mman.h>
 #endif /* HAVE_SYS_MMAN_H */

 #endif


 static void
 test_blob_empty (void)
 {
   hb_blob_t *blob;
   unsigned int len;
   const char *data;
   char *data_writable;

   g_assert (hb_blob_is_immutable (hb_blob_get_empty ()));
   g_assert (hb_blob_get_empty () != NULL);
   g_assert (hb_blob_get_empty () == hb_blob_create (NULL, 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
   g_assert (hb_blob_get_empty () == hb_blob_create ("asdf", 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
   g_assert (hb_blob_get_empty () == hb_blob_create (NULL, -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
   g_assert (hb_blob_get_empty () == hb_blob_create ("asdfg", -1, HB_MEMORY_MODE_READONLY, NULL, NULL));

   blob = hb_blob_get_empty ();
   g_assert (blob == hb_blob_get_empty ());

   len = hb_blob_get_length (blob);
   g_assert_cmpint (len, ==, 0);

   data = hb_blob_get_data (blob, NULL);
   g_assert (data == NULL);

   data = hb_blob_get_data (blob, &len);
   g_assert (data == NULL);
   g_assert_cmpint (len, ==, 0);

   data_writable = hb_blob_get_data_writable (blob, NULL);
   g_assert (data_writable == NULL);

   data_writable = hb_blob_get_data_writable (blob, &len);
   g_assert (data_writable == NULL);
   g_assert_cmpint (len, ==, 0);
 }

 static const char test_data[] = "test\0data";

 static const char *blob_names[] = {
   "duplicate",
   "readonly",
   "writable"
 #ifdef TEST_MMAP
    , "readonly-may-make-writable"
 #endif
 };

 typedef struct
 {
   hb_blob_t *blob;
   int freed;
   char *data;
   unsigned int len;
 } fixture_t;

 static void
 free_up (fixture_t *fixture)
 {
   g_assert_cmpint (fixture->freed, ==, 0);
   fixture->freed++;
 }

 static void
 free_up_free (fixture_t *fixture)
 {
   free_up (fixture);
   free (fixture->data);
 }


 #ifdef TEST_MMAP
 static uintptr_t
 get_pagesize (void)
 {
   uintptr_t pagesize = -1;

 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
   pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE);
 #elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
   pagesize = (uintptr_t) sysconf (_SC_PAGESIZE);
 #elif defined(HAVE_GETPAGESIZE)
   pagesize = (uintptr_t) getpagesize ();
 #endif

   g_assert (pagesize != (uintptr_t) -1);

   return pagesize;
 }

 static void
 free_up_munmap (fixture_t *fixture)
 {
   free_up (fixture);
   munmap (fixture->data, get_pagesize ());
 }
 #endif

 #include <errno.h>
 static void
 fixture_init (fixture_t *fixture, gconstpointer user_data)
 {
   hb_memory_mode_t mm = (hb_memory_mode_t) GPOINTER_TO_INT (user_data);
   unsigned int len;
   const char *data;
   hb_destroy_func_t free_func;

   switch (GPOINTER_TO_INT (user_data))
   {
     case HB_MEMORY_MODE_DUPLICATE:
       data = test_data;
       len = sizeof (test_data);
       free_func = (hb_destroy_func_t) free_up;
       break;

     case HB_MEMORY_MODE_READONLY:
       data = test_data;
       len = sizeof (test_data);
       free_func = (hb_destroy_func_t) free_up;
       break;

     case HB_MEMORY_MODE_WRITABLE:
       data = malloc (sizeof (test_data));
       memcpy ((char *) data, test_data, sizeof (test_data));
       len = sizeof (test_data);
       free_func = (hb_destroy_func_t) free_up_free;
       break;

 #ifdef TEST_MMAP
     case HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE:
     {
       uintptr_t pagesize = get_pagesize ();

       data = mmap (NULL, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
       g_assert (data != (char *) -1);
       memcpy ((char *) data, test_data, sizeof (test_data));
       mprotect ((char *) data, pagesize, PROT_READ);
       len = sizeof (test_data);
       free_func = (hb_destroy_func_t) free_up_munmap;
       break;
     }
 #endif

     default:
       g_assert_not_reached ();
   }

   fixture->freed = 0;
   fixture->data = (char *) data;
   fixture->len = len;
   fixture->blob = hb_blob_create (data, len, mm, fixture, free_func);
 }

 static void
 fixture_finish (fixture_t *fixture, gconstpointer user_data)
 {
   hb_blob_destroy (fixture->blob);
   g_assert_cmpint (fixture->freed, ==, 1);
 }


 static void
 test_blob (fixture_t *fixture, gconstpointer user_data)
 {
   hb_blob_t *b = fixture->blob;
   hb_memory_mode_t mm = GPOINTER_TO_INT (user_data);
   unsigned int len;
   const char *data;
   char *data_writable;
   unsigned int i;

   g_assert (b);

   len = hb_blob_get_length (b);
   g_assert_cmpint (len, ==, fixture->len);

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len);
   if (mm == HB_MEMORY_MODE_DUPLICATE) {
     g_assert (data != fixture->data);
     g_assert_cmpint (fixture->freed, ==, 1);
     mm = HB_MEMORY_MODE_WRITABLE;
   } else {
     g_assert (data == fixture->data);
     g_assert_cmpint (fixture->freed, ==, 0);
   }

   data_writable = hb_blob_get_data_writable (b, &len);
   g_assert_cmpint (len, ==, fixture->len);
   g_assert (data_writable);
   g_assert (0 == memcmp (data_writable, fixture->data, fixture->len));
   if (mm == HB_MEMORY_MODE_READONLY) {
     g_assert (data_writable != data);
     g_assert_cmpint (fixture->freed, ==, 1);
   } else {
     g_assert (data_writable == data);
   }

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len);
   g_assert (data == data_writable);

   memset (data_writable, 0, fixture->len);

   /* Now, make it immutable and watch get_data_writable() fail */

   g_assert (!hb_blob_is_immutable (b));
   hb_blob_make_immutable (b);
   g_assert (hb_blob_is_immutable (b));

   data_writable = hb_blob_get_data_writable (b, &len);
   g_assert (!data_writable);
   g_assert_cmpint (len, ==, 0);

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len);
   for (i = 0; i < len; i++)
     g_assert ('\0' == data[i]);
 }

 static void
 test_blob_subblob (fixture_t *fixture, gconstpointer user_data)
 {
   hb_blob_t *b = fixture->blob;
   hb_memory_mode_t mm = GPOINTER_TO_INT (user_data);
   unsigned int len;
   const char *data;
   char *data_writable;
   unsigned int i;

   if (mm == HB_MEMORY_MODE_DUPLICATE) {
     g_assert_cmpint (fixture->freed, ==, 1);
     fixture->data = (char *) hb_blob_get_data (b, NULL);
   } else {
     g_assert_cmpint (fixture->freed, ==, 0);
   }
   fixture->blob = hb_blob_create_sub_blob (b, 1, fixture->len - 2);
   hb_blob_destroy (b);
   b = fixture->blob;

   /* A sub-blob is always created READONLY. */

   g_assert (b);

   len = hb_blob_get_length (b);
   g_assert_cmpint (len, ==, fixture->len - 2);

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len - 2);
   g_assert (data == fixture->data + 1);

   data_writable = hb_blob_get_data_writable (b, &len);
   g_assert_cmpint (len, ==, fixture->len - 2);
   g_assert (data_writable);
   if (mm == HB_MEMORY_MODE_READONLY)
     g_assert (0 == memcmp (data_writable, fixture->data + 1, fixture->len - 2));
   g_assert (data_writable != data);
   g_assert_cmpint (fixture->freed, ==, 1);

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len - 2);
   g_assert (data == data_writable);

   memset (data_writable, 0, fixture->len - 2);

   /* Now, make it immutable and watch get_data_writable() fail */

   g_assert (!hb_blob_is_immutable (b));
   hb_blob_make_immutable (b);
   g_assert (hb_blob_is_immutable (b));

   data_writable = hb_blob_get_data_writable (b, &len);
   g_assert (!data_writable);
   g_assert_cmpint (len, ==, 0);

   data = hb_blob_get_data (b, &len);
   g_assert_cmpint (len, ==, fixture->len - 2);
   for (i = 0; i < len; i++)
     g_assert ('\0' == data[i]);
 }


 int
 main (int argc, char **argv)
 {
   unsigned int i;

   hb_test_init (&argc, &argv);

   hb_test_add (test_blob_empty);

   for (i = 0; i < G_N_ELEMENTS (blob_names); i++)
   {
     const void *blob_type = GINT_TO_POINTER (i);
     const char *blob_name = blob_names[i];

     hb_test_add_fixture_flavor (fixture, blob_type, blob_name, test_blob);
     hb_test_add_fixture_flavor (fixture, blob_type, blob_name, test_blob_subblob);
   }

   /*
    * create_sub_blob
    */

   return hb_test_run ();
 }
	/*
	* Copyright © 2011 Google, Inc.
	*
	* This is part of HarfBuzz, a text shaping library.
	*
	* Permission is hereby granted, without written agreement and without
	* license or royalty fees, to use, copy, modify, and distribute this
	* software and its documentation for any purpose, provided that the
	* above copyright notice and the following two paragraphs appear in
	* all copies of this software.
	*
	* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
	* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
	* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
	* DAMAGE.
	*
	* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
	* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
	* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
	* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
	* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
	*
	* Google Author(s): Behdad Esfahbod
	*/

	#include "hb-test.h"

	/* Unit tests for hb-blob.h */

	#if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT) && defined(HAVE_MMAP)

	# define TEST_MMAP 1

	#ifdef HAVE_SYS_MMAN_H
	#ifdef HAVE_UNISTD_H
	#include <unistd.h>
	#endif /* HAVE_UNISTD_H */
	#include <sys/mman.h>
	#endif /* HAVE_SYS_MMAN_H */

	#endif


	static void
	test_blob_empty (void)
	{
	hb_blob_t *blob;
	unsigned int len;
	const char *data;
	char *data_writable;

	g_assert (hb_blob_is_immutable (hb_blob_get_empty ()));
	g_assert (hb_blob_get_empty () != NULL);
	g_assert (hb_blob_get_empty () == hb_blob_create (NULL, 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
	g_assert (hb_blob_get_empty () == hb_blob_create ("asdf", 0, HB_MEMORY_MODE_READONLY, NULL, NULL));
	g_assert (hb_blob_get_empty () == hb_blob_create (NULL, -1, HB_MEMORY_MODE_READONLY, NULL, NULL));
	g_assert (hb_blob_get_empty () == hb_blob_create ("asdfg", -1, HB_MEMORY_MODE_READONLY, NULL, NULL));

	blob = hb_blob_get_empty ();
	g_assert (blob == hb_blob_get_empty ());

	len = hb_blob_get_length (blob);
	g_assert_cmpint (len, ==, 0);

	data = hb_blob_get_data (blob, NULL);
	g_assert (data == NULL);

	data = hb_blob_get_data (blob, &len);
	g_assert (data == NULL);
	g_assert_cmpint (len, ==, 0);

	data_writable = hb_blob_get_data_writable (blob, NULL);
	g_assert (data_writable == NULL);

	data_writable = hb_blob_get_data_writable (blob, &len);
	g_assert (data_writable == NULL);
	g_assert_cmpint (len, ==, 0);
	}

	static const char test_data[] = "test\0data";

	static const char *blob_names[] = {
	"duplicate",
	"readonly",
	"writable"
	#ifdef TEST_MMAP
	, "readonly-may-make-writable"
	#endif
	};

	typedef struct
	{
	hb_blob_t *blob;
	int freed;
	char *data;
	unsigned int len;
	} fixture_t;

	static void
	free_up (fixture_t *fixture)
	{
	g_assert_cmpint (fixture->freed, ==, 0);
	fixture->freed++;
	}

	static void
	free_up_free (fixture_t *fixture)
	{
	free_up (fixture);
	free (fixture->data);
	}


	#ifdef TEST_MMAP
	static uintptr_t
	get_pagesize (void)
	{
	uintptr_t pagesize = -1;

	#if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
	pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE);
	#elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
	pagesize = (uintptr_t) sysconf (_SC_PAGESIZE);
	#elif defined(HAVE_GETPAGESIZE)
	pagesize = (uintptr_t) getpagesize ();
	#endif

	g_assert (pagesize != (uintptr_t) -1);

	return pagesize;
	}

	static void
	free_up_munmap (fixture_t *fixture)
	{
	free_up (fixture);
	munmap (fixture->data, get_pagesize ());
	}
	#endif

	#include <errno.h>
	static void
	fixture_init (fixture_t *fixture, gconstpointer user_data)
	{
	hb_memory_mode_t mm = (hb_memory_mode_t) GPOINTER_TO_INT (user_data);
	unsigned int len;
	const char *data;
	hb_destroy_func_t free_func;

	switch (GPOINTER_TO_INT (user_data))
	{
	case HB_MEMORY_MODE_DUPLICATE:
	data = test_data;
	len = sizeof (test_data);
	free_func = (hb_destroy_func_t) free_up;
	break;

	case HB_MEMORY_MODE_READONLY:
	data = test_data;
	len = sizeof (test_data);
	free_func = (hb_destroy_func_t) free_up;
	break;

	case HB_MEMORY_MODE_WRITABLE:
	data = malloc (sizeof (test_data));
	memcpy ((char *) data, test_data, sizeof (test_data));
	len = sizeof (test_data);
	free_func = (hb_destroy_func_t) free_up_free;
	break;

	#ifdef TEST_MMAP
	case HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE:
	{
	uintptr_t pagesize = get_pagesize ();

	data = mmap (NULL, pagesize, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANON, -1, 0);
	g_assert (data != (char *) -1);
	memcpy ((char *) data, test_data, sizeof (test_data));
	mprotect ((char *) data, pagesize, PROT_READ);
	len = sizeof (test_data);
	free_func = (hb_destroy_func_t) free_up_munmap;
	break;
	}
	#endif

	default:
	g_assert_not_reached ();
	}

	fixture->freed = 0;
	fixture->data = (char *) data;
	fixture->len = len;
	fixture->blob = hb_blob_create (data, len, mm, fixture, free_func);
	}

	static void
	fixture_finish (fixture_t *fixture, gconstpointer user_data)
	{
	hb_blob_destroy (fixture->blob);
	g_assert_cmpint (fixture->freed, ==, 1);
	}


	static void
	test_blob (fixture_t *fixture, gconstpointer user_data)
	{
	hb_blob_t *b = fixture->blob;
	hb_memory_mode_t mm = GPOINTER_TO_INT (user_data);
	unsigned int len;
	const char *data;
	char *data_writable;
	unsigned int i;

	g_assert (b);

	len = hb_blob_get_length (b);
	g_assert_cmpint (len, ==, fixture->len);

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len);
	if (mm == HB_MEMORY_MODE_DUPLICATE) {
	g_assert (data != fixture->data);
	g_assert_cmpint (fixture->freed, ==, 1);
	mm = HB_MEMORY_MODE_WRITABLE;
	} else {
	g_assert (data == fixture->data);
	g_assert_cmpint (fixture->freed, ==, 0);
	}

	data_writable = hb_blob_get_data_writable (b, &len);
	g_assert_cmpint (len, ==, fixture->len);
	g_assert (data_writable);
	g_assert (0 == memcmp (data_writable, fixture->data, fixture->len));
	if (mm == HB_MEMORY_MODE_READONLY) {
	g_assert (data_writable != data);
	g_assert_cmpint (fixture->freed, ==, 1);
	} else {
	g_assert (data_writable == data);
	}

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len);
	g_assert (data == data_writable);

	memset (data_writable, 0, fixture->len);

	/* Now, make it immutable and watch get_data_writable() fail */

	g_assert (!hb_blob_is_immutable (b));
	hb_blob_make_immutable (b);
	g_assert (hb_blob_is_immutable (b));

	data_writable = hb_blob_get_data_writable (b, &len);
	g_assert (!data_writable);
	g_assert_cmpint (len, ==, 0);

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len);
	for (i = 0; i < len; i++)
	g_assert ('\0' == data[i]);
	}

	static void
	test_blob_subblob (fixture_t *fixture, gconstpointer user_data)
	{
	hb_blob_t *b = fixture->blob;
	hb_memory_mode_t mm = GPOINTER_TO_INT (user_data);
	unsigned int len;
	const char *data;
	char *data_writable;
	unsigned int i;

	if (mm == HB_MEMORY_MODE_DUPLICATE) {
	g_assert_cmpint (fixture->freed, ==, 1);
	fixture->data = (char *) hb_blob_get_data (b, NULL);
	} else {
	g_assert_cmpint (fixture->freed, ==, 0);
	}
	fixture->blob = hb_blob_create_sub_blob (b, 1, fixture->len - 2);
	hb_blob_destroy (b);
	b = fixture->blob;

	/* A sub-blob is always created READONLY. */

	g_assert (b);

	len = hb_blob_get_length (b);
	g_assert_cmpint (len, ==, fixture->len - 2);

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len - 2);
	g_assert (data == fixture->data + 1);

	data_writable = hb_blob_get_data_writable (b, &len);
	g_assert_cmpint (len, ==, fixture->len - 2);
	g_assert (data_writable);
	if (mm == HB_MEMORY_MODE_READONLY)
	g_assert (0 == memcmp (data_writable, fixture->data + 1, fixture->len - 2));
	g_assert (data_writable != data);
	g_assert_cmpint (fixture->freed, ==, 1);

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len - 2);
	g_assert (data == data_writable);

	memset (data_writable, 0, fixture->len - 2);

	/* Now, make it immutable and watch get_data_writable() fail */

	g_assert (!hb_blob_is_immutable (b));
	hb_blob_make_immutable (b);
	g_assert (hb_blob_is_immutable (b));

	data_writable = hb_blob_get_data_writable (b, &len);
	g_assert (!data_writable);
	g_assert_cmpint (len, ==, 0);

	data = hb_blob_get_data (b, &len);
	g_assert_cmpint (len, ==, fixture->len - 2);
	for (i = 0; i < len; i++)
	g_assert ('\0' == data[i]);
	}


	int
	main (int argc, char **argv)
	{
	unsigned int i;

	hb_test_init (&argc, &argv);

	hb_test_add (test_blob_empty);

	for (i = 0; i < G_N_ELEMENTS (blob_names); i++)
	{
	const void *blob_type = GINT_TO_POINTER (i);
	const char *blob_name = blob_names[i];

	hb_test_add_fixture_flavor (fixture, blob_type, blob_name, test_blob);
	hb_test_add_fixture_flavor (fixture, blob_type, blob_name, test_blob_subblob);
	}

	/*
	* create_sub_blob
	*/

	return hb_test_run ();
	}