static int test_string(void)
{
unsigned int i;
const char *strings[] = { "Four score and seven years ago",
"our father brought forth on this continent",
"a new nation", "conceived in Liberty",
"and dedicated to the proposition that all men are created equal."
};
avro_schema_t writer_schema = avro_schema_string();
for (i = 0; i < sizeof(strings) / sizeof(strings[0]); i++) {
avro_datum_t datum = avro_givestring(strings[i], NULL);
write_read_check(writer_schema, datum, NULL, NULL, "string");
avro_datum_decref(datum);
}
avro_datum_t datum = avro_givestring(strings[0], NULL);
test_json(datum, "\"Four score and seven years ago\"");
avro_datum_decref(datum);
// The following should bork if we don't copy the string value
// correctly (since we'll try to free a static string).
datum = avro_string("this should be copied");
avro_string_set(datum, "also this");
avro_datum_decref(datum);
avro_schema_decref(writer_schema);
return 0;
}
static int test_record(void)
{
avro_schema_t schema = avro_schema_record("person", NULL);
avro_schema_record_field_append(schema, "name", avro_schema_string());
avro_schema_record_field_append(schema, "age", avro_schema_int());
avro_datum_t datum = avro_record(schema);
avro_datum_t name_datum, age_datum;
name_datum = avro_givestring("Joseph Campbell", NULL);
age_datum = avro_int32(83);
avro_record_set(datum, "name", name_datum);
avro_record_set(datum, "age", age_datum);
write_read_check(schema, datum, NULL, NULL, "record");
test_json(datum, "{\"name\": \"Joseph Campbell\", \"age\": 83}");
int rc;
avro_record_set_field_value(rc, datum, int32, "age", 104);
int32_t age = 0;
avro_record_get_field_value(rc, datum, int32, "age", &age);
if (age != 104) {
fprintf(stderr, "Incorrect age value\n");
exit(EXIT_FAILURE);
}
avro_datum_decref(name_datum);
avro_datum_decref(age_datum);
avro_datum_decref(datum);
avro_schema_decref(schema);
return 0;
}
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;
}
avro_datum_t avro_datum_from_schema(const avro_schema_t schema)
{
check_param(NULL, is_avro_schema(schema), "schema");
switch (avro_typeof(schema)) {
case AVRO_STRING:
return avro_givestring("", NULL);
case AVRO_BYTES:
return avro_givebytes("", 0, NULL);
case AVRO_INT32:
return avro_int32(0);
case AVRO_INT64:
return avro_int64(0);
case AVRO_FLOAT:
return avro_float(0);
case AVRO_DOUBLE:
return avro_double(0);
case AVRO_BOOLEAN:
return avro_boolean(0);
case AVRO_NULL:
return avro_null();
case AVRO_RECORD:
{
const struct avro_record_schema_t *record_schema =
avro_schema_to_record(schema);
avro_datum_t rec = avro_record(schema);
int i;
for (i = 0; i < record_schema->fields->num_entries; i++) {
union {
st_data_t data;
struct avro_record_field_t *field;
} val;
st_lookup(record_schema->fields, i, &val.data);
avro_datum_t field =
avro_datum_from_schema(val.field->type);
avro_record_set(rec, val.field->name, field);
avro_datum_decref(field);
}
return rec;
}
case AVRO_ENUM:
return avro_enum(schema, 0);
case AVRO_FIXED:
{
const struct avro_fixed_schema_t *fixed_schema =
avro_schema_to_fixed(schema);
return avro_givefixed(schema, NULL, fixed_schema->size, NULL);
}
case AVRO_MAP:
return avro_map(schema);
case AVRO_ARRAY:
return avro_array(schema);
case AVRO_UNION:
return avro_union(schema, -1, NULL);
case AVRO_LINK:
{
const struct avro_link_schema_t *link_schema =
avro_schema_to_link(schema);
return avro_datum_from_schema(link_schema->to);
}
default:
avro_set_error("Unknown schema type");
return NULL;
}
}
