Пример #1
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;
}
Пример #2
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;
	}
}