avro-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mas...@apache.org
Subject svn commit: r900960 - in /hadoop/avro/trunk: CHANGES.txt lang/c/src/avro.h lang/c/src/datum.c lang/c/src/datum.h lang/c/src/encoding_binary.c lang/c/src/schema.h lang/c/tests/Makefile.am lang/c/tests/test_avro_data.c lang/c/version.sh
Date Tue, 19 Jan 2010 21:13:05 GMT
Author: massie
Date: Tue Jan 19 21:13:05 2010
New Revision: 900960

URL: http://svn.apache.org/viewvc?rev=900960&view=rev
Log:
AVRO-352.  Incorrect binary encoding for strings and bytes

Modified:
    hadoop/avro/trunk/CHANGES.txt
    hadoop/avro/trunk/lang/c/src/avro.h
    hadoop/avro/trunk/lang/c/src/datum.c
    hadoop/avro/trunk/lang/c/src/datum.h
    hadoop/avro/trunk/lang/c/src/encoding_binary.c
    hadoop/avro/trunk/lang/c/src/schema.h
    hadoop/avro/trunk/lang/c/tests/Makefile.am
    hadoop/avro/trunk/lang/c/tests/test_avro_data.c
    hadoop/avro/trunk/lang/c/version.sh

Modified: hadoop/avro/trunk/CHANGES.txt
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/CHANGES.txt?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/CHANGES.txt (original)
+++ hadoop/avro/trunk/CHANGES.txt Tue Jan 19 21:13:05 2010
@@ -333,6 +333,8 @@
  
     AVRO-347. Add the --unsafe flag to asciidoc in order to include source/header files (massie)
 
+    AVRO-352. Incorrect binary encoding for strings and bytes (massie)
+
 Avro 1.2.0 (14 October 2009)
 
   INCOMPATIBLE CHANGES

Modified: hadoop/avro/trunk/lang/c/src/avro.h
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/src/avro.h?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/src/avro.h (original)
+++ hadoop/avro/trunk/lang/c/src/avro.h Tue Jan 19 21:13:05 2010
@@ -194,10 +194,12 @@
 
   void avro_datum_print (avro_datum_t value, FILE * fp);
 
-  int schema_match (avro_schema_t writers_schema,
+  int avro_datum_equal (avro_datum_t a, avro_datum_t b);
+
+  int avro_schema_match (avro_schema_t writers_schema,
 		    avro_schema_t readers_schema);
 
-  int schema_datum_validate (avro_schema_t expected_schema,
+  int avro_schema_datum_validate (avro_schema_t expected_schema,
 			     avro_datum_t datum);
 
   int avro_read_data (avro_reader_t reader, avro_schema_t writer_schema,

Modified: hadoop/avro/trunk/lang/c/src/datum.c
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/src/datum.c?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/src/datum.c (original)
+++ hadoop/avro/trunk/lang/c/src/datum.c Tue Jan 19 21:13:05 2010
@@ -20,6 +20,7 @@
 #include <string.h>
 #include <errno.h>
 #include <limits.h>
+#include <assert.h>
 #include "avro.h"
 #include "schema.h"
 #include "datum.h"
@@ -33,6 +34,52 @@
   datum->refcount = 1;
 }
 
+int
+avro_datum_equal (avro_datum_t a, avro_datum_t b)
+{
+  if (!(is_avro_datum (a) && is_avro_datum (b)))
+    {
+      return 0;
+    }
+  if (avro_typeof (a) != avro_typeof (b))
+    {
+      return 0;
+    }
+  switch (avro_typeof (a))
+    {
+    case AVRO_STRING:
+      return strcmp (avro_datum_to_string (a)->s,
+		     avro_datum_to_string (b)->s) == 0;
+    case AVRO_BYTES:
+      return (avro_datum_to_bytes (a)->size == avro_datum_to_bytes (b)->size)
+	&& memcmp (avro_datum_to_bytes (a)->bytes,
+		   avro_datum_to_bytes (b)->bytes,
+		   avro_datum_to_bytes (a)->size) == 0;
+    case AVRO_INT:
+      return avro_datum_to_int (a)->i == avro_datum_to_int (b)->i;
+    case AVRO_LONG:
+      return avro_datum_to_long (a)->l == avro_datum_to_long (b)->l;
+    case AVRO_FLOAT:
+      return avro_datum_to_float (a)->f == avro_datum_to_float (b)->f;
+    case AVRO_DOUBLE:
+      return avro_datum_to_double (a)->d == avro_datum_to_double (b)->d;
+    case AVRO_BOOLEAN:
+      return avro_datum_to_boolean (a)->i == avro_datum_to_boolean (b)->i;
+    case AVRO_NULL:
+      return 1;
+    case AVRO_RECORD:
+    case AVRO_ENUM:
+    case AVRO_FIXED:
+    case AVRO_MAP:
+    case AVRO_ARRAY:
+    case AVRO_UNION:
+    case AVRO_LINK:
+      /* TODO */
+      return 0;
+    }
+  return 0;
+}
+
 avro_datum_t
 avro_string (const char *str)
 {
@@ -49,7 +96,7 @@
 }
 
 avro_datum_t
-avro_bytes (const char *buf, int64_t len)
+avro_bytes (const char *bytes, int64_t size)
 {
   struct avro_bytes_datum_t *datum =
     malloc (sizeof (struct avro_bytes_datum_t));
@@ -57,14 +104,14 @@
     {
       return NULL;
     }
-  datum->buf = malloc (len);
-  if (!datum->buf)
+  datum->bytes = malloc (size);
+  if (!datum->bytes)
     {
       free (datum);
       return NULL;
     }
-  memcpy (datum->buf, buf, len);
-  datum->len = len;
+  memcpy (datum->bytes, bytes, size);
+  datum->size = size;
 
   avro_datum_init (&datum->obj, AVRO_BYTES);
   return &datum->obj;
@@ -282,7 +329,7 @@
 }
 
 int
-schema_match (avro_schema_t writers_schema, avro_schema_t readers_schema)
+avro_schema_match (avro_schema_t writers_schema, avro_schema_t readers_schema)
 {
   if (is_avro_union (writers_schema) || is_avro_union (readers_schema))
     {
@@ -408,7 +455,16 @@
   int rval = EINVAL;
   const avro_encoding_t *enc = &avro_binary_encoding;
 
-  if (!reader || !schema_match (writers_schema, readers_schema) || !datum)
+  if (!reader || !is_avro_schema (writers_schema) || !datum)
+    {
+      return EINVAL;
+    }
+
+  if (readers_schema == NULL)
+    {
+      readers_schema = writers_schema;
+    }
+  else if (!avro_schema_match (writers_schema, readers_schema))
     {
       return EINVAL;
     }
@@ -423,7 +479,7 @@
       for (branch = STAILQ_FIRST (&union_schema->branches);
 	   branch != NULL; branch = STAILQ_NEXT (branch, branches))
 	{
-	  if (schema_match (writers_schema, branch->schema))
+	  if (avro_schema_match (writers_schema, branch->schema))
 	    {
 	      return avro_read_data (reader, writers_schema, branch->schema,
 				     datum);
@@ -520,7 +576,9 @@
       break;
 
     case AVRO_LINK:
-      /* TODO */
+      rval =
+	avro_read_data (reader, (avro_schema_to_link (writers_schema))->to,
+			readers_schema, datum);
       break;
     }
 
@@ -537,7 +595,7 @@
 schema_map_validate_foreach (char *key, avro_datum_t datum,
 			     struct validate_st *vst)
 {
-  if (!schema_datum_validate (vst->expected_schema, datum))
+  if (!avro_schema_datum_validate (vst->expected_schema, datum))
     {
       vst->rval = 0;
       return ST_STOP;
@@ -546,150 +604,323 @@
 }
 
 int
-schema_datum_validate (avro_schema_t expected_schema, avro_datum_t datum)
+avro_schema_datum_validate (avro_schema_t expected_schema, avro_datum_t datum)
 {
   if (!is_avro_schema (expected_schema) || !is_avro_datum (datum))
     {
       return EINVAL;
     }
-  /* null */
-  if (is_avro_null (expected_schema) && is_avro_null (datum))
-    {
-      return 1;
-    }
-  /* boolean */
-  else if (is_avro_boolean (expected_schema) && is_avro_boolean (datum))
-    {
-      return 1;
-    }
-  /* string */
-  else if (is_avro_string (expected_schema) && is_avro_boolean (datum))
-    {
-      return 1;
-    }
-  /* bytes */
-  else if (is_avro_bytes (expected_schema) && is_avro_bytes (datum))
-    {
-      return 1;
-    }
-  /* int */
-  else if (is_avro_int (expected_schema)
-	   && (is_avro_int (datum)
-	       || (is_avro_long (datum)
-		   && (INT_MIN <= (avro_datum_to_long (datum))->l
-		       && (avro_datum_to_long (datum))->l <= INT_MAX))))
-    {
-      return 1;
-    }
-  /* long */
-  else if (is_avro_long (expected_schema)
-	   && (is_avro_int (datum) || is_avro_long (datum)))
-    {
-      return 1;
-    }
-  /* float or double */
-  else
-    if ((is_avro_float (expected_schema) || is_avro_double (expected_schema))
-	&& (is_avro_int (datum) || is_avro_long (datum)
-	    || is_avro_float (datum)))
-    {
-      return 1;
-    }
-  /* fixed */
-  else if (is_avro_fixed (expected_schema)
-	   && (is_avro_fixed (datum)
-	       && ((avro_schema_to_fixed (expected_schema))->size ==
-		   (avro_datum_to_fixed (datum))->size)))
-    {
-      return 1;
-    }
-  /* enum */
-  else if (is_avro_enum (expected_schema))
-    {
-      struct avro_enum_schema_t *enump =
-	avro_schema_to_enum (expected_schema);
-      struct avro_enum_symbol_t *symbol = STAILQ_FIRST (&enump->symbols);
-      while (symbol)
-	{
-	  if (!strcmp (symbol->symbol, (avro_datum_to_enum (datum))->symbol))
-	    {
-	      return 1;
-	    }
-	  symbol = STAILQ_NEXT (symbol, symbols);
-	}
-      return 0;
-    }
-  /* array */
-  else if (is_avro_array (expected_schema) && is_avro_array (datum))
-    {
-      struct avro_array_datum_t *array = avro_datum_to_array (datum);
-      struct avro_array_element_t *el = STAILQ_FIRST (&array->els);
-      while (el)
-	{
-	  if (!schema_datum_validate
-	      ((avro_schema_to_array (expected_schema))->items, el->datum))
-	    {
-	      return 0;
-	    }
-	  el = STAILQ_NEXT (el, els);
-	}
-      return 1;
-    }
-  /* map */
-  else if (is_avro_map (expected_schema) && is_avro_map (datum))
-    {
-      struct validate_st vst = { expected_schema, 1 };
-      st_foreach ((avro_datum_to_map (datum))->map,
-		  schema_map_validate_foreach, (st_data_t) & vst);
-      return vst.rval;
-    }
-  /* union */
-  else if (is_avro_union (expected_schema))
+
+  switch (avro_typeof (expected_schema))
     {
-      struct avro_union_schema_t *union_schema =
-	avro_schema_to_union (expected_schema);
-      struct avro_union_branch_t *branch;
+    case AVRO_NULL:
+      return is_avro_null (datum);
 
-      for (branch = STAILQ_FIRST (&union_schema->branches);
-	   branch != NULL; branch = STAILQ_NEXT (branch, branches))
+    case AVRO_BOOLEAN:
+      return is_avro_boolean (datum);
+
+    case AVRO_STRING:
+      return is_avro_string (datum);
+
+    case AVRO_BYTES:
+      return is_avro_bytes (datum);
+
+    case AVRO_INT:
+      return is_avro_int (datum)
+	|| (is_avro_long (datum)
+	    && (INT_MIN <= avro_datum_to_long (datum)->l
+		&& avro_datum_to_long (datum)->l <= INT_MAX));
+
+    case AVRO_LONG:
+      return is_avro_int (datum) || is_avro_long (datum);
+
+    case AVRO_FLOAT:
+      return is_avro_int (datum) || is_avro_long (datum)
+	|| is_avro_float (datum);
+
+    case AVRO_DOUBLE:
+      return is_avro_int (datum) || is_avro_long (datum)
+	|| is_avro_float (datum) || is_avro_double (datum);
+
+    case AVRO_FIXED:
+      return (is_avro_fixed (datum)
+	      && (avro_schema_to_fixed (expected_schema)->size ==
+		  avro_datum_to_fixed (datum)->size));
+
+    case AVRO_ENUM:
+      {
+	struct avro_enum_schema_t *enump =
+	  avro_schema_to_enum (expected_schema);
+	struct avro_enum_symbol_t *symbol = STAILQ_FIRST (&enump->symbols);
+	while (symbol)
+	  {
+	    if (!strcmp (symbol->symbol, avro_datum_to_enum (datum)->symbol))
+	      {
+		return 1;
+	      }
+	    symbol = STAILQ_NEXT (symbol, symbols);
+	  }
+	return 0;
+      }
+      break;
+
+    case AVRO_ARRAY:
+      {
+	if (is_avro_array (datum))
+	  {
+	    struct avro_array_datum_t *array = avro_datum_to_array (datum);
+	    struct avro_array_element_t *el = STAILQ_FIRST (&array->els);
+	    while (el)
+	      {
+		if (!avro_schema_datum_validate
+		    ((avro_schema_to_array (expected_schema))->items,
+		     el->datum))
+		  {
+		    return 0;
+		  }
+		el = STAILQ_NEXT (el, els);
+	      }
+	    return 1;
+	  }
+	return 0;
+      }
+      break;
+
+    case AVRO_MAP:
+      if (is_avro_map (datum))
 	{
-	  if (schema_datum_validate (branch->schema, datum))
-	    {
-	      return 1;
-	    }
+	  struct validate_st vst = { expected_schema, 1 };
+	  st_foreach (avro_datum_to_map (datum)->map,
+		      schema_map_validate_foreach, (st_data_t) & vst);
+	  return vst.rval;
 	}
-      return 0;
-    }
-  /* record */
-  else if (is_avro_record (expected_schema) && is_avro_record (datum))
-    {
-      struct avro_record_schema_t *record_schema =
-	avro_schema_to_record (expected_schema);
-      struct avro_record_field_t *field;
-      for (field = STAILQ_FIRST (&record_schema->fields);
-	   field != NULL; field = STAILQ_NEXT (field, fields))
+      break;
+
+    case AVRO_UNION:
+      {
+	struct avro_union_schema_t *union_schema =
+	  avro_schema_to_union (expected_schema);
+	struct avro_union_branch_t *branch;
+
+	for (branch = STAILQ_FIRST (&union_schema->branches);
+	     branch != NULL; branch = STAILQ_NEXT (branch, branches))
+	  {
+	    if (avro_schema_datum_validate (branch->schema, datum))
+	      {
+		return 1;
+	      }
+	  }
+	return 0;
+      }
+      break;
+
+    case AVRO_RECORD:
+      if (is_avro_record (datum))
 	{
-	  avro_datum_t field_datum =
-	    avro_record_field_get (datum, field->name);
-	  if (!field_datum)
+	  struct avro_record_schema_t *record_schema =
+	    avro_schema_to_record (expected_schema);
+	  struct avro_record_field_t *field;
+	  for (field = STAILQ_FIRST (&record_schema->fields);
+	       field != NULL; field = STAILQ_NEXT (field, fields))
 	    {
-	      /* TODO: check for default values */
-	      return 0;
-	    }
-	  if (!schema_datum_validate (field->type, field_datum))
-	    {
-	      return 0;
+	      avro_datum_t field_datum =
+		avro_record_field_get (datum, field->name);
+	      if (!field_datum)
+		{
+		  /* TODO: check for default values */
+		  return 0;
+		}
+	      if (!avro_schema_datum_validate (field->type, field_datum))
+		{
+		  return 0;
+		}
 	    }
+	  return 1;
 	}
-      return 1;
+      break;
+
+    case AVRO_LINK:
+      {
+	return
+	  avro_schema_datum_validate ((avro_schema_to_link (expected_schema))->to,
+				 datum);
+      }
+      break;
     }
   return 0;
 }
 
+static int
+write_record (avro_writer_t writer, const avro_encoding_t * enc,
+	      avro_schema_t writer_schema, avro_datum_t datum)
+{
+  /* TODO */
+  return EINVAL;
+}
+
+static int
+write_enum (avro_writer_t writer, const avro_encoding_t * enc,
+	    avro_schema_t writer_schema, avro_datum_t datum)
+{
+  /* TODO */
+  return EINVAL;
+}
+
+static int
+write_fixed (avro_writer_t writer, const avro_encoding_t * enc,
+	     avro_schema_t writer_schema, avro_datum_t datum)
+{
+  /* TODO */
+  return EINVAL;
+}
+
+static int
+write_map (avro_writer_t writer, const avro_encoding_t * enc,
+	   avro_schema_t writer_schema, avro_datum_t datum)
+{
+  /* TODO */
+  return EINVAL;
+}
+
+static int
+write_array (avro_writer_t writer, const avro_encoding_t * enc,
+	     avro_schema_t writer_schema, avro_datum_t datum)
+{
+  /* TODO */
+  return EINVAL;
+}
+
 int
 avro_write_data (avro_writer_t writer, avro_schema_t writer_schema,
 		 avro_datum_t datum)
 {
-  /* TODO */
-  return 1;
+  const avro_encoding_t *enc = &avro_binary_encoding;
+  int rval = -1;
+
+  if (!(is_avro_schema (writer_schema) && is_avro_datum (datum)))
+    {
+      return EINVAL;
+    }
+  if (!avro_schema_datum_validate (writer_schema, datum))
+    {
+      return EINVAL;
+    }
+  switch (avro_typeof (writer_schema))
+    {
+    case AVRO_NULL:
+      rval = enc->write_null (writer);
+      break;
+    case AVRO_BOOLEAN:
+      rval = enc->write_boolean (writer, avro_datum_to_boolean (datum)->i);
+      break;
+    case AVRO_STRING:
+      rval = enc->write_string (writer, avro_datum_to_string (datum)->s);
+      break;
+    case AVRO_BYTES:
+      rval = enc->write_bytes (writer, avro_datum_to_bytes (datum)->bytes,
+			       avro_datum_to_bytes (datum)->size);
+      break;
+    case AVRO_INT:
+      {
+	int32_t i;
+	if (is_avro_int (datum))
+	  {
+	    i = avro_datum_to_int (datum)->i;
+	  }
+	else if (is_avro_long (datum))
+	  {
+	    i = (int32_t) avro_datum_to_long (datum)->l;
+	  }
+	else
+	  {
+	    assert (0 && "Serious bug in schema validation code");
+	  }
+	rval = enc->write_int (writer, i);
+      }
+      break;
+    case AVRO_LONG:
+      rval = enc->write_long (writer, avro_datum_to_long (datum)->l);
+      break;
+    case AVRO_FLOAT:
+      {
+	float f;
+	if (is_avro_int (datum))
+	  {
+	    f = (float) (avro_datum_to_int (datum)->i);
+	  }
+	else if (is_avro_long (datum))
+	  {
+	    f = (float) (avro_datum_to_long (datum)->l);
+	  }
+	else if (is_avro_float (datum))
+	  {
+	    f = avro_datum_to_float (datum)->f;
+	  }
+	else if (is_avro_double (datum))
+	  {
+	    f = (float) (avro_datum_to_double (datum)->d);
+	  }
+	else
+	  {
+	    assert (0 && "Serious bug in schema validation code");
+	  }
+	rval = enc->write_float (writer, f);
+      }
+      break;
+    case AVRO_DOUBLE:
+      {
+	double d;
+	if (is_avro_int (datum))
+	  {
+	    d = (double) (avro_datum_to_int (datum)->i);
+	  }
+	else if (is_avro_long (datum))
+	  {
+	    d = (double) (avro_datum_to_long (datum)->l);
+	  }
+	else if (is_avro_float (datum))
+	  {
+	    d = (double) (avro_datum_to_float (datum)->f);
+	  }
+	else if (is_avro_double (datum))
+	  {
+	    d = avro_datum_to_double (datum)->d;
+	  }
+	else
+	  {
+	    assert (0 && "Bug in schema validation code");
+	  }
+	rval = enc->write_double (writer, d);
+      }
+      break;
+
+    case AVRO_RECORD:
+      rval = write_record (writer, enc, writer_schema, datum);
+      break;
+    case AVRO_ENUM:
+      rval = write_enum (writer, enc, writer_schema, datum);
+      break;
+    case AVRO_FIXED:
+      rval = write_fixed (writer, enc, writer_schema, datum);
+      break;
+    case AVRO_MAP:
+      rval = write_map (writer, enc, writer_schema, datum);
+      break;
+    case AVRO_ARRAY:
+      rval = write_array (writer, enc, writer_schema, datum);
+      break;
+
+    case AVRO_UNION:
+      {
+	assert (0 && "Bug in schema validation code");
+      }
+      break;
+
+    case AVRO_LINK:
+      rval =
+	avro_write_data (writer, (avro_schema_to_link (writer_schema))->to,
+			 datum);
+      break;
+    }
+  return rval;
 }

Modified: hadoop/avro/trunk/lang/c/src/datum.h
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/src/datum.h?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/src/datum.h (original)
+++ hadoop/avro/trunk/lang/c/src/datum.h Tue Jan 19 21:13:05 2010
@@ -33,8 +33,8 @@
 struct avro_bytes_datum_t
 {
   struct avro_obj_t obj;
-  char *buf;
-  size_t len;
+  char *bytes;
+  int64_t size;
 };
 
 struct avro_int_datum_t
@@ -107,17 +107,17 @@
     STAILQ_HEAD (els, avro_array_element_t) els;
 };
 
-#define avro_datum_to_string(datum_)    container_of(datum_, struct avro_string_datum_t,
obj)
-#define avro_datum_to_bytes(datum_)     container_of(datum_, struct avro_bytes_datum_t, obj)
-#define avro_datum_to_int(datum_)       container_of(datum_, struct avro_int_datum_t, obj)
-#define avro_datum_to_long(datum_)      container_of(datum_, struct avro_long_datum_t, obj)
-#define avro_datum_to_float(datum_)     container_of(datum_, struct avro_float_datum_t, obj)
-#define avro_datum_to_double(datum_)    container_of(datum_, struct avro_double_datum_t,
obj)
-#define avro_datum_to_boolean(datum_)   container_of(datum_, struct avro_boolean_datum_t,
obj)
-#define avro_datum_to_fixed(datum_)     container_of(datum_, struct avro_fixed_datum_t, obj)
-#define avro_datum_to_map(datum_)       container_of(datum_, struct avro_map_datum_t, obj)
-#define avro_datum_to_record(datum_)    container_of(datum_, struct avro_record_datum_t,
obj)
-#define avro_datum_to_enum(datum_)      container_of(datum_, struct avro_enum_datum_t, obj)
-#define avro_datum_to_array(datum_)     container_of(datum_, struct avro_array_datum_t, obj)
+#define avro_datum_to_string(datum_)    (container_of(datum_, struct avro_string_datum_t,
obj))
+#define avro_datum_to_bytes(datum_)     (container_of(datum_, struct avro_bytes_datum_t,
obj))
+#define avro_datum_to_int(datum_)       (container_of(datum_, struct avro_int_datum_t, obj))
+#define avro_datum_to_long(datum_)      (container_of(datum_, struct avro_long_datum_t, obj))
+#define avro_datum_to_float(datum_)     (container_of(datum_, struct avro_float_datum_t,
obj))
+#define avro_datum_to_double(datum_)    (container_of(datum_, struct avro_double_datum_t,
obj))
+#define avro_datum_to_boolean(datum_)   (container_of(datum_, struct avro_boolean_datum_t,
obj))
+#define avro_datum_to_fixed(datum_)     (container_of(datum_, struct avro_fixed_datum_t,
obj))
+#define avro_datum_to_map(datum_)       (container_of(datum_, struct avro_map_datum_t, obj))
+#define avro_datum_to_record(datum_)    (container_of(datum_, struct avro_record_datum_t,
obj))
+#define avro_datum_to_enum(datum_)      (container_of(datum_, struct avro_enum_datum_t, obj))
+#define avro_datum_to_array(datum_)     (container_of(datum_, struct avro_array_datum_t,
obj))
 
 #endif

Modified: hadoop/avro/trunk/lang/c/src/encoding_binary.c
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/src/encoding_binary.c?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/src/encoding_binary.c (original)
+++ hadoop/avro/trunk/lang/c/src/encoding_binary.c Tue Jan 19 21:13:05 2010
@@ -27,7 +27,7 @@
 static int
 read_long (avro_reader_t reader, int64_t * l)
 {
-  uint64_t n = 0;
+  uint64_t value = 0;
   uint8_t b;
   int offset = 0;
   do
@@ -38,11 +38,11 @@
 	  return EILSEQ;
 	}
       AVRO_READ (reader, &b, 1);
-      n |= (int64_t) (b & 0x7F) << (7 * offset);
+      value |= (int64_t) (b & 0x7F) << (7 * offset);
       ++offset;
     }
   while (b & 0x80);
-  *l = (n >> 1) ^ -(n & 1);
+  *l = ((value >> 1) ^ -(value & 1));
   return 0;
 }
 
@@ -69,7 +69,7 @@
 {
   uint8_t b;
   uint64_t n = (l << 1) ^ (l >> 63);
-  while ((n & ~0x7F) != 0)
+  while (n & ~0x7F)
     {
       b = ((((uint8_t) n) & 0x7F) | 0x80);
       AVRO_WRITE (writer, &b, 1);
@@ -123,7 +123,7 @@
     {
       return ENOMEM;
     }
-  *bytes[*len] = '\0';
+  (*bytes)[*len] = '\0';
   AVRO_READ (reader, *bytes, *len);
   return 0;
 }
@@ -144,10 +144,16 @@
 static int
 write_bytes (avro_writer_t writer, const char *bytes, const int64_t len)
 {
+  int rval;
   if (len < 0)
     {
       return EINVAL;
     }
+  rval = write_long (writer, len);
+  if (rval)
+    {
+      return rval;
+    }
   AVRO_WRITE (writer, (char *) bytes, len);
   return 0;
 }

Modified: hadoop/avro/trunk/lang/c/src/schema.h
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/src/schema.h?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/src/schema.h (original)
+++ hadoop/avro/trunk/lang/c/src/schema.h Tue Jan 19 21:13:05 2010
@@ -88,13 +88,13 @@
   avro_schema_t to;
 };
 
-#define avro_schema_to_record(schema_)  container_of(schema_, struct avro_record_schema_t,
obj)
-#define avro_schema_to_enum(schema_)    container_of(schema_, struct avro_enum_schema_t,
obj)
-#define avro_schema_to_array(schema_)   container_of(schema_, struct avro_array_schema_t,
obj)
-#define avro_schema_to_map(schema_)     container_of(schema_, struct avro_map_schema_t, obj)
-#define avro_schema_to_union(schema_)   container_of(schema_, struct avro_union_schema_t,
obj)
-#define avro_schema_to_fixed(schema_)   container_of(schema_, struct avro_fixed_schema_t,
obj)
-#define avro_schema_to_link(schema_)    container_of(schema_, struct avro_link_schema_t,
obj)
+#define avro_schema_to_record(schema_)  (container_of(schema_, struct avro_record_schema_t,
obj))
+#define avro_schema_to_enum(schema_)    (container_of(schema_, struct avro_enum_schema_t,
obj))
+#define avro_schema_to_array(schema_)   (container_of(schema_, struct avro_array_schema_t,
obj))
+#define avro_schema_to_map(schema_)     (container_of(schema_, struct avro_map_schema_t,
obj))
+#define avro_schema_to_union(schema_)   (container_of(schema_, struct avro_union_schema_t,
obj))
+#define avro_schema_to_fixed(schema_)   (container_of(schema_, struct avro_fixed_schema_t,
obj))
+#define avro_schema_to_link(schema_)    (container_of(schema_, struct avro_link_schema_t,
obj))
 
 static inline avro_schema_t
 avro_schema_incref (avro_schema_t schema)

Modified: hadoop/avro/trunk/lang/c/tests/Makefile.am
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/tests/Makefile.am?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/tests/Makefile.am (original)
+++ hadoop/avro/trunk/lang/c/tests/Makefile.am Tue Jan 19 21:13:05 2010
@@ -5,7 +5,7 @@
 
 EXTRA_DIST=schema_tests
 
-check_PROGRAMS=test_avro_schema
+check_PROGRAMS=test_avro_schema test_avro_data
 
 test_LDADD=$(top_builddir)/src/libavro.la
 

Modified: hadoop/avro/trunk/lang/c/tests/test_avro_data.c
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/tests/test_avro_data.c?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/tests/test_avro_data.c (original)
+++ hadoop/avro/trunk/lang/c/tests/test_avro_data.c Tue Jan 19 21:13:05 2010
@@ -20,8 +20,10 @@
 #include <stdint.h>
 #include <time.h>
 #include <string.h>
+#include <assert.h>
 #include "avro.h"
 #include "dump.h"
+#include "datum.h"
 
 char buf[4096];
 
@@ -51,7 +53,6 @@
 test_string (void)
 {
   int i;
-  int status;
   const char *strings[] = { "Four score and seven years ago",
     "our father brought forth on this continent",
     "a new nation", "conceived in Liberty",
@@ -59,8 +60,38 @@
   };
   for (i = 0; i < sizeof (strings) / sizeof (strings[0]); i++)
     {
-      avro_binary_encode_to_memory (buf, sizeof (buf), avro_schema_string (),
-				    avro_string (strings[i]));
+      avro_reader_t reader;
+      avro_writer_t writer;
+      avro_schema_t writer_schema = avro_schema_string ();
+      avro_datum_t datum_in = avro_string (strings[i]);
+      avro_datum_t datum_out;
+
+      reader = avro_reader_memory (buf, sizeof (buf));
+      if (!reader)
+	{
+	  assert (0 && "Can't create a memory reader");
+	}
+      writer = avro_writer_memory (buf, sizeof (buf));
+      if (!writer)
+	{
+	  assert (0 && "Can't create a memory writer");
+	}
+      if (avro_write_data (writer, writer_schema, datum_in))
+	{
+	  assert (0 && "Can't write string");
+	}
+      if (avro_read_data (reader, writer_schema, NULL, &datum_out))
+	{
+	  assert (0 && "Can't read string");
+	}
+      if (!avro_datum_equal (datum_in, datum_out))
+	{
+	  assert (0 && "String didn't survive encoding/decoding");
+	}
+      avro_datum_decref (datum_in);
+      avro_datum_decref (datum_out);
+      avro_reader_free (reader);
+      avro_writer_free (writer);
     }
   return 0;
 }
@@ -68,136 +99,155 @@
 static int
 test_bytes (void)
 {
-  int status;
   char bytes[] = { 0xDE, 0xAD, 0xBE, 0xEF };
-  char *read_bytes;
+  avro_reader_t reader = avro_reader_memory (buf, sizeof (buf));
+  avro_writer_t writer = avro_writer_memory (buf, sizeof (buf));
+  avro_schema_t writer_schema = avro_schema_bytes ();
+  avro_datum_t datum_in = avro_bytes (bytes, sizeof (bytes));
+  avro_datum_t datum_out;
 
-#if 0
-  status = avro_write_bytes (encoder, bytes, sizeof (bytes));
-  if (status != 0)
+  if (avro_write_data (writer, writer_schema, datum_in))
     {
-      return status;
+      assert (0 && "Unable to write bytes");
     }
-  status = avro_read_bytes (decoder, pool, (void *) &read_bytes, &len);
-  if (status != 0)
+  if (avro_read_data (reader, writer_schema, NULL, &datum_out))
     {
-      return status;
+      assert (0 && "Unable to read bytes");
     }
-  if (len != sizeof (bytes))
+  if (!avro_datum_equal (datum_in, datum_out))
     {
-      return 1;
+      assert (0 && "Byte did not encode/decode correctly");
     }
-  if (memcmp (bytes, read_bytes, len))
+  avro_datum_decref (datum_in);
+  avro_datum_decref (datum_out);
+  avro_reader_free (reader);
+  avro_writer_free (writer);
+  return 0;
+}
+
+static int
+test_int_long (int long_test)
+{
+  int i;
+  for (i = 0; i < 100; i++)
     {
-      return 1;
+      avro_reader_t reader = avro_reader_memory (buf, sizeof (buf));
+      avro_writer_t writer = avro_writer_memory (buf, sizeof (buf));
+      avro_schema_t writer_schema =
+	long_test ? avro_schema_long () : avro_schema_int ();
+      avro_datum_t datum_in = long_test ? avro_long (rand ()) :
+	avro_int (rand ());
+      avro_datum_t datum_out;
+
+      if (avro_write_data (writer, writer_schema, datum_in))
+	{
+	  assert (0 && "Unable to write int/long");
+	}
+      if (avro_read_data (reader, writer_schema, NULL, &datum_out))
+	{
+	  assert (0 && "Unable to read int/long");
+	}
+      if (!avro_datum_equal (datum_in, datum_out))
+	{
+	  assert (0 && "Unable to encode/decode int/long");
+	}
+      avro_datum_decref (datum_in);
+      avro_datum_decref (datum_out);
+      avro_reader_free (reader);
+      avro_writer_free (writer);
     }
-#endif
   return 0;
 }
 
 static int
 test_int (void)
 {
-  return 0;
+  return test_int_long (0);
 }
 
 static int
 test_long (void)
 {
-  return 0;
+  return test_int_long (1);
 }
 
-static int
-test_float (void)
+static
+test_float_double (int double_test)
 {
-  int status;
-  float input, output;
   int i;
-  int const num_rand_tests = 25;
 
-#if 0
-  for (i = 0; i < num_rand_tests; i++)
+  for (i = 0; i < 100; i++)
     {
-      input = random () * 1.1;
-      status = avro_write_float (encoder, input);
-      if (status != 0)
+      avro_reader_t reader = avro_reader_memory (buf, sizeof (buf));
+      avro_writer_t writer = avro_writer_memory (buf, sizeof (buf));
+      avro_schema_t schema =
+	double_test ? avro_schema_double () : avro_schema_float ();
+      avro_datum_t datum_in =
+	double_test ? avro_double ((double) (rand ())) :
+	avro_float ((float) (rand ()));
+      avro_datum_t datum_out;
+
+      if (avro_write_data (writer, schema, datum_in))
 	{
-	  return status;
+	  assert (0 && "Unable to write float/double");
 	}
-      status = avro_read_float (decoder, &output);
-      if (status != 0)
+      if (avro_read_data (reader, schema, NULL, &datum_out))
 	{
-	  return status;
+	  assert (0 && "Unable to read float/double");
 	}
-      if (input != output)
+      if (!avro_datum_equal (datum_in, datum_out))
 	{
-	  fprintf (stderr, "%f != %f\n", input, output);
-	  return 1;
+	  assert (0 && "Unable to encode/decode float/double");
 	}
+
+      avro_datum_decref (datum_in);
+      avro_datum_decref (datum_out);
+      avro_reader_free (reader);
+      avro_writer_free (writer);
     }
-#endif
   return 0;
 }
 
 static int
-test_double (void)
+test_float (void)
 {
-  int status;
-  double input, output;
-  int i;
-  int const num_rand_tests = 25;
+  return test_float_double (0);
+}
 
-#if 0
-  for (i = 0; i < num_rand_tests; i++)
-    {
-      input = random () * 1.1;
-      status = avro_write_double (encoder, input);
-      if (status != 0)
-	{
-	  return status;
-	}
-      status = avro_read_double (decoder, &output);
-      if (status != 0)
-	{
-	  return status;
-	}
-      if (input != output)
-	{
-	  fprintf (stderr, "%f != %f\n", input, output);
-	  return 1;
-	}
-    }
-#endif
-  return 0;
+static int
+test_double (void)
+{
+  return test_float_double (1);
 }
 
 static int
 test_boolean (void)
 {
-  int status;
-  int i, bool_in, bool_out;
-
-#if 0
-  for (i = 0; i < 2; i++)
+  int i;
+  for (i = 0; i < 1000; i++)
     {
-      bool_in = i;
-      status = avro_write_bool (encoder, bool_in);
-      if (status != 0)
+      avro_reader_t reader = avro_reader_memory (buf, sizeof (buf));
+      avro_writer_t writer = avro_writer_memory (buf, sizeof (buf));
+      avro_schema_t schema = avro_schema_boolean ();
+      avro_datum_t datum_in = avro_boolean (rand () % 2);
+      avro_datum_t datum_out;
+
+      if (avro_write_data (writer, schema, datum_in))
 	{
-	  return status;
+	  assert (0 && "Unable to write boolean");
 	}
-      status = avro_read_bool (decoder, &bool_out);
-      if (status != 0)
+      if (avro_read_data (reader, schema, schema, &datum_out))
 	{
-	  return status;
+	  assert (0 && "Unable to read boolean");
 	}
-      if (bool_in != bool_out)
+      if (!avro_datum_equal (datum_in, datum_out))
 	{
-	  fprintf (stderr, "%d != %d\n", bool_in, bool_out);
-	  return 1;
+	  assert (0 && "Unable to encode/decode boolean");
 	}
+
+      avro_reader_free (reader);
+      avro_writer_free (writer);
     }
-#endif
   return 0;
 }
 
@@ -210,36 +260,42 @@
 int
 test_record (void)
 {
+  /* TODO */
   return 0;
 }
 
 int
 test_enum (void)
 {
+  /* TODO */
   return 0;
 }
 
 int
 test_array (void)
 {
+  /* TODO */
   return 0;
 }
 
 int
 test_map (void)
 {
+  /* TODO */
   return 0;
 }
 
 int
 test_union (void)
 {
+  /* TODO */
   return 0;
 }
 
 int
 test_fixed (void)
 {
+  /* TODO */
   return 0;
 }
 

Modified: hadoop/avro/trunk/lang/c/version.sh
URL: http://svn.apache.org/viewvc/hadoop/avro/trunk/lang/c/version.sh?rev=900960&r1=900959&r2=900960&view=diff
==============================================================================
--- hadoop/avro/trunk/lang/c/version.sh (original)
+++ hadoop/avro/trunk/lang/c/version.sh Tue Jan 19 21:13:05 2010
@@ -18,9 +18,9 @@
 #         libavro_binary_age = 0
 #         libavro_interface_age = 0
 #
-libavro_micro_version=4
+libavro_micro_version=5
 libavro_interface_age=0
-libavro_binary_age=1
+libavro_binary_age=0
 
 # IGNORE EVERYTHING ELSE FROM HERE DOWN.........
 if test $# != 1; then



Mime
View raw message