static int test_bytes(void)
{
char bytes[] = { 0xDE, 0xAD, 0xBE, 0xEF };
avro_schema_t writer_schema = avro_schema_bytes();
avro_datum_t datum;
avro_datum_t expected_datum;
datum = avro_givebytes(bytes, sizeof(bytes), NULL);
write_read_check(writer_schema, datum, NULL, NULL, "bytes");
test_json(datum, "\"\\u00de\\u00ad\\u00be\\u00ef\"");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
datum = avro_givebytes(NULL, 0, NULL);
avro_givebytes_set(datum, bytes, sizeof(bytes), NULL);
expected_datum = avro_givebytes(bytes, sizeof(bytes), NULL);
if (!avro_datum_equal(datum, expected_datum)) {
fprintf(stderr,
"Expected equal bytes instances.\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(datum);
avro_datum_decref(expected_datum);
// The following should bork if we don't copy the bytes value
// correctly (since we'll try to free a static string).
datum = avro_bytes("original", 8);
avro_bytes_set(datum, "alsothis", 8);
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
return 0;
}
static int test_fixed(void)
{
char bytes[] = { 0xD, 0xA, 0xD, 0xA, 0xB, 0xA, 0xB, 0xA };
avro_schema_t schema = avro_schema_fixed("msg", sizeof(bytes));
avro_datum_t datum;
avro_datum_t expected_datum;
datum = avro_givefixed(schema, bytes, sizeof(bytes), NULL);
write_read_check(schema, datum, NULL, NULL, "fixed");
test_json(datum, "\"\\r\\n\\r\\n\\u000b\\n\\u000b\\n\"");
avro_datum_decref(datum);
datum = avro_givefixed(schema, NULL, sizeof(bytes), NULL);
avro_givefixed_set(datum, bytes, sizeof(bytes), NULL);
expected_datum = avro_givefixed(schema, bytes, sizeof(bytes), NULL);
if (!avro_datum_equal(datum, expected_datum)) {
fprintf(stderr,
"Expected equal fixed instances.\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(datum);
avro_datum_decref(expected_datum);
// The following should bork if we don't copy the fixed value
// correctly (since we'll try to free a static string).
datum = avro_fixed(schema, "original", 8);
avro_fixed_set(datum, "alsothis", 8);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
static int
array_equal(struct avro_array_datum_t *a, struct avro_array_datum_t *b)
{
if (!avro_schema_equal(a->schema, b->schema)) {
return 0;
}
long i;
if (a->els->num_entries != b->els->num_entries) {
return 0;
}
for (i = 0; i < a->els->num_entries; i++) {
union {
st_data_t data;
avro_datum_t datum;
} ael, bel;
st_lookup(a->els, i, &ael.data);
st_lookup(b->els, i, &bel.data);
if (!avro_datum_equal(ael.datum, bel.datum)) {
return 0;
}
}
return 1;
}
static int union_equal(struct avro_union_datum_t *a,
struct avro_union_datum_t *b)
{
if (!avro_schema_equal(a->schema, b->schema)) {
return 0;
}
return a->discriminant == b->discriminant && avro_datum_equal(a->value, b->value);
}
void
write_read_check(avro_schema_t writers_schema, avro_datum_t datum,
avro_schema_t readers_schema, avro_datum_t expected, char *type)
{
avro_datum_t datum_out;
int validate;
for (validate = 0; validate <= 1; validate++) {
reader = avro_reader_memory(buf, sizeof(buf));
writer = avro_writer_memory(buf, sizeof(buf));
if (!expected) {
expected = datum;
}
/* Validating read/write */
if (avro_write_data
(writer, validate ? writers_schema : NULL, datum)) {
fprintf(stderr, "Unable to write %s validate=%d\n %s\n",
type, validate, avro_strerror());
exit(EXIT_FAILURE);
}
int64_t size =
avro_size_data(writer, validate ? writers_schema : NULL,
datum);
if (size != avro_writer_tell(writer)) {
fprintf(stderr,
"Unable to calculate size %s validate=%d "
"(%"PRId64" != %"PRId64")\n %s\n",
type, validate, size, avro_writer_tell(writer),
avro_strerror());
exit(EXIT_FAILURE);
}
if (avro_read_data
(reader, writers_schema, readers_schema, &datum_out)) {
fprintf(stderr, "Unable to read %s validate=%d\n %s\n",
type, validate, avro_strerror());
fprintf(stderr, " %s\n", avro_strerror());
exit(EXIT_FAILURE);
}
if (!avro_datum_equal(expected, datum_out)) {
fprintf(stderr,
"Unable to encode/decode %s validate=%d\n %s\n",
type, validate, avro_strerror());
exit(EXIT_FAILURE);
}
avro_reader_dump(reader, stderr);
avro_datum_decref(datum_out);
avro_reader_free(reader);
avro_writer_free(writer);
}
}
static int test_union(void)
{
avro_schema_t schema = avro_schema_union();
avro_datum_t union_datum;
avro_datum_t datum;
avro_datum_t union_datum1;
avro_datum_t datum1;
avro_schema_union_append(schema, avro_schema_string());
avro_schema_union_append(schema, avro_schema_int());
avro_schema_union_append(schema, avro_schema_null());
datum = avro_givestring("Follow your bliss.", NULL);
union_datum = avro_union(schema, 0, datum);
if (avro_union_discriminant(union_datum) != 0) {
fprintf(stderr, "Unexpected union discriminant\n");
exit(EXIT_FAILURE);
}
if (avro_union_current_branch(union_datum) != datum) {
fprintf(stderr, "Unexpected union branch datum\n");
exit(EXIT_FAILURE);
}
union_datum1 = avro_datum_from_schema(schema);
avro_union_set_discriminant(union_datum1, 0, &datum1);
avro_givestring_set(datum1, "Follow your bliss.", NULL);
if (!avro_datum_equal(datum, datum1)) {
fprintf(stderr, "Union values should be equal\n");
exit(EXIT_FAILURE);
}
write_read_check(schema, union_datum, NULL, NULL, "union");
test_json(union_datum, "{\"string\": \"Follow your bliss.\"}");
avro_datum_decref(datum);
avro_union_set_discriminant(union_datum, 2, &datum);
test_json(union_datum, "null");
avro_datum_decref(union_datum);
avro_datum_decref(datum);
avro_datum_decref(union_datum1);
avro_schema_decref(schema);
return 0;
}
static int
st_equal_foreach(char *key, avro_datum_t datum, struct st_equal_args *args)
{
union {
avro_datum_t datum_other;
st_data_t data;
} val;
if (!st_lookup(args->st, (st_data_t) key, &(val.data))) {
args->rval = 0;
return ST_STOP;
}
if (!avro_datum_equal(datum, val.datum_other)) {
args->rval = 0;
return ST_STOP;
}
return ST_CONTINUE;
}
int main(int argc, char *argv[])
{
int rval;
avro_file_writer_t file_writer;
avro_file_reader_t file_reader;
char outpath[128];
FILE *fp;
char jsontext[16 * 1024];
avro_schema_t schema;
avro_schema_error_t schema_error;
avro_datum_t interop;
avro_datum_t array_datum;
avro_datum_t node_datum;
avro_datum_t union_datum;
avro_datum_t out_datum;
enum Kind {
KIND_A,
KIND_B,
KIND_C
};
if (argc != 3) {
exit(EXIT_FAILURE);
}
snprintf(outpath, sizeof(outpath), "%s/c.avro", argv[2]);
fprintf(stderr, "Writing to %s\n", outpath);
fp = fopen(argv[1], "r");
rval = fread(jsontext, 1, sizeof(jsontext) - 1, fp);
jsontext[rval] = '\0';
check(rval,
avro_schema_from_json(jsontext, rval, &schema, &schema_error));
check(rval, avro_file_writer_create(outpath, schema, &file_writer));
/* TODO: create a method for generating random data from schema */
interop = avro_record("Interop", "org.apache.avro");
avro_record_set(interop, "intField", avro_int32(42));
avro_record_set(interop, "longField", avro_int64(4242));
avro_record_set(interop, "stringField",
avro_wrapstring("Follow your bliss."));
avro_record_set(interop, "boolField", avro_boolean(1));
avro_record_set(interop, "floatField", avro_float(3.14159265));
avro_record_set(interop, "doubleField", avro_double(2.71828183));
avro_record_set(interop, "bytesField", avro_bytes("abcd", 4));
avro_record_set(interop, "nullField", avro_null());
array_datum = avro_array();
avro_array_append_datum(array_datum, avro_double(1.0));
avro_array_append_datum(array_datum, avro_double(2.0));
avro_array_append_datum(array_datum, avro_double(3.0));
avro_record_set(interop, "arrayField", array_datum);
avro_record_set(interop, "mapField", avro_map());
union_datum = avro_union(1, avro_double(1.61803399));
avro_record_set(interop, "unionField", union_datum);
avro_record_set(interop, "enumField", avro_enum("Kind", KIND_A));
avro_record_set(interop, "fixedField",
avro_fixed("MD5", "1234567890123456", 16));
node_datum = avro_record("Node", NULL);
avro_record_set(node_datum, "label",
avro_wrapstring("If you label me, you negate me."));
avro_record_set(node_datum, "children", avro_array());
avro_record_set(interop, "recordField", node_datum);
rval = avro_file_writer_append(file_writer, interop);
if (rval) {
fprintf(stderr, "Unable to append data to interop file!\n");
exit(EXIT_FAILURE);
} else {
fprintf(stderr, "Successfully appended datum to file\n");
}
check(rval, avro_file_writer_close(file_writer));
fprintf(stderr, "Closed writer.\n");
check(rval, avro_file_reader(outpath, &file_reader));
fprintf(stderr, "Re-reading datum to verify\n");
check(rval, avro_file_reader_read(file_reader, NULL, &out_datum));
fprintf(stderr, "Verifying datum...");
if (!avro_datum_equal(interop, out_datum)) {
fprintf(stderr, "fail!\n");
exit(EXIT_FAILURE);
}
fprintf(stderr, "ok\n");
check(rval, avro_file_reader_close(file_reader));
fprintf(stderr, "Closed reader.\n");
return 0;
}
