Added three tests in test_tgk_store_mem.c

This commit is contained in:
Carl Niklas Rydberg 2025-12-21 20:24:34 +01:00
parent c298481025
commit eedbe65957

View file

@ -323,6 +323,237 @@ static int test_init_rejects_unsupported_encoding(void) {
return 0; return 0;
} }
static int test_init_rejects_duplicate_hash_id(void) {
amduat_tgk_store_mem_t mem;
amduat_tgk_store_config_t config;
amduat_tgk_identity_domain_t domains[2];
memset(&mem, 0, sizeof(mem));
memset(&config, 0, sizeof(config));
domains[0].encoding_profile = AMDUAT_ENC_ASL1_CORE_V1;
domains[0].hash_id = AMDUAT_HASH_ASL1_ID_SHA256;
domains[1].encoding_profile = AMDUAT_ENC_ASL1_CORE_V1;
domains[1].hash_id = AMDUAT_HASH_ASL1_ID_SHA256;
config.id_space.domains = domains;
config.id_space.domains_len = 2;
if (amduat_tgk_store_mem_init(&mem, config, NULL, 0)) {
fprintf(stderr, "init accepted duplicate hash_id domains\n");
amduat_tgk_store_mem_free(&mem);
return 1;
}
return 0;
}
static int test_duplicate_edge_ref_same_artifact(void) {
amduat_tgk_store_mem_t mem;
amduat_tgk_store_t store;
amduat_tgk_store_config_t config;
amduat_tgk_identity_domain_t domains[1];
uint32_t edge_tags[1];
amduat_tgk_edge_type_id_t edge_types[1];
amduat_asl_encoding_profile_id_t encodings[1];
amduat_tgk_store_mem_artifact_t artifacts[2];
amduat_tgk_edge_body_t edge;
amduat_reference_t from_refs[1];
amduat_reference_t to_refs[1];
amduat_reference_t ref_edge;
amduat_reference_t node_a;
amduat_reference_t node_b;
amduat_reference_t payload;
amduat_octets_t edge_bytes;
amduat_tgk_edge_body_t body;
amduat_tgk_graph_scan_result_t scan;
uint8_t digest_edge[32];
uint8_t digest_a[32];
uint8_t digest_b[32];
uint8_t digest_payload[32];
memset(&mem, 0, sizeof(mem));
memset(&config, 0, sizeof(config));
memset(&edge, 0, sizeof(edge));
edge_bytes = amduat_octets(NULL, 0);
domains[0].encoding_profile = AMDUAT_ENC_ASL1_CORE_V1;
domains[0].hash_id = AMDUAT_HASH_ASL1_ID_SHA256;
edge_tags[0] = TYPE_TAG_TGK1_EDGE_V1;
edge_types[0] = 0x10;
encodings[0] = TGK1_EDGE_ENC_V1;
config.id_space.domains = domains;
config.id_space.domains_len = 1;
config.tgk_profiles.edge_tags = edge_tags;
config.tgk_profiles.edge_tags_len = 1;
config.tgk_profiles.edge_types = edge_types;
config.tgk_profiles.edge_types_len = 1;
config.tgk_profiles.encodings = encodings;
config.tgk_profiles.encodings_len = 1;
ref_edge = make_ref(0x71, digest_edge);
node_a = make_ref(0xa1, digest_a);
node_b = make_ref(0xb1, digest_b);
payload = make_ref(0xe1, digest_payload);
edge.type = 0x10;
from_refs[0] = node_a;
edge.from = from_refs;
edge.from_len = 1;
to_refs[0] = node_b;
edge.to = to_refs;
edge.to_len = 1;
edge.payload = payload;
if (!amduat_enc_tgk1_edge_encode_v1(&edge, &edge_bytes)) {
fprintf(stderr, "duplicate ref encode failed\n");
return 1;
}
artifacts[0].ref = ref_edge;
artifacts[0].artifact =
amduat_artifact_with_type(edge_bytes,
amduat_type_tag(TYPE_TAG_TGK1_EDGE_V1));
artifacts[1].ref = ref_edge;
artifacts[1].artifact =
amduat_artifact_with_type(edge_bytes,
amduat_type_tag(TYPE_TAG_TGK1_EDGE_V1));
if (!amduat_tgk_store_mem_init(&mem, config, artifacts, 2)) {
fprintf(stderr, "init rejected duplicate identical artifacts\n");
free((void *)edge_bytes.data);
return 1;
}
amduat_tgk_store_init(&store, config, amduat_tgk_store_mem_ops(), &mem);
if (amduat_tgk_store_resolve_edge(&store, ref_edge, &body) != 0) {
fprintf(stderr, "resolve_edge failed for duplicate ref\n");
amduat_tgk_store_mem_free(&mem);
free((void *)edge_bytes.data);
return 1;
}
amduat_tgk_edge_body_free(&body);
if (!amduat_tgk_store_scan_edges(&store,
(amduat_tgk_edge_type_filter_t){0},
amduat_octets(NULL, 0), false, &scan)) {
fprintf(stderr, "scan_edges failed for duplicate ref\n");
amduat_tgk_store_mem_free(&mem);
free((void *)edge_bytes.data);
return 1;
}
if (scan.edges.len != 1) {
fprintf(stderr, "duplicate ref scan count mismatch\n");
amduat_tgk_graph_scan_result_free(&scan);
amduat_tgk_store_mem_free(&mem);
free((void *)edge_bytes.data);
return 1;
}
amduat_tgk_graph_scan_result_free(&scan);
amduat_tgk_store_mem_free(&mem);
free((void *)edge_bytes.data);
return 0;
}
static int test_duplicate_edge_ref_conflict(void) {
amduat_tgk_store_mem_t mem;
amduat_tgk_store_config_t config;
amduat_tgk_identity_domain_t domains[1];
uint32_t edge_tags[1];
amduat_tgk_edge_type_id_t edge_types[1];
amduat_asl_encoding_profile_id_t encodings[1];
amduat_tgk_store_mem_artifact_t artifacts[2];
amduat_tgk_edge_body_t edge_a;
amduat_tgk_edge_body_t edge_b;
amduat_reference_t from_refs[1];
amduat_reference_t to_refs[1];
amduat_reference_t ref_edge;
amduat_reference_t node_a;
amduat_reference_t node_b;
amduat_reference_t payload_a;
amduat_reference_t payload_b;
amduat_octets_t bytes_a;
amduat_octets_t bytes_b;
uint8_t digest_edge[32];
uint8_t digest_a[32];
uint8_t digest_b[32];
uint8_t digest_payload_a[32];
uint8_t digest_payload_b[32];
memset(&mem, 0, sizeof(mem));
memset(&config, 0, sizeof(config));
memset(&edge_a, 0, sizeof(edge_a));
memset(&edge_b, 0, sizeof(edge_b));
bytes_a = amduat_octets(NULL, 0);
bytes_b = amduat_octets(NULL, 0);
domains[0].encoding_profile = AMDUAT_ENC_ASL1_CORE_V1;
domains[0].hash_id = AMDUAT_HASH_ASL1_ID_SHA256;
edge_tags[0] = TYPE_TAG_TGK1_EDGE_V1;
edge_types[0] = 0x10;
encodings[0] = TGK1_EDGE_ENC_V1;
config.id_space.domains = domains;
config.id_space.domains_len = 1;
config.tgk_profiles.edge_tags = edge_tags;
config.tgk_profiles.edge_tags_len = 1;
config.tgk_profiles.edge_types = edge_types;
config.tgk_profiles.edge_types_len = 1;
config.tgk_profiles.encodings = encodings;
config.tgk_profiles.encodings_len = 1;
ref_edge = make_ref(0x72, digest_edge);
node_a = make_ref(0xa1, digest_a);
node_b = make_ref(0xb1, digest_b);
payload_a = make_ref(0xe1, digest_payload_a);
payload_b = make_ref(0xe2, digest_payload_b);
edge_a.type = 0x10;
from_refs[0] = node_a;
edge_a.from = from_refs;
edge_a.from_len = 1;
to_refs[0] = node_b;
edge_a.to = to_refs;
edge_a.to_len = 1;
edge_a.payload = payload_a;
edge_b.type = 0x10;
edge_b.from = from_refs;
edge_b.from_len = 1;
edge_b.to = to_refs;
edge_b.to_len = 1;
edge_b.payload = payload_b;
if (!amduat_enc_tgk1_edge_encode_v1(&edge_a, &bytes_a) ||
!amduat_enc_tgk1_edge_encode_v1(&edge_b, &bytes_b)) {
fprintf(stderr, "conflict encode failed\n");
free((void *)bytes_a.data);
free((void *)bytes_b.data);
return 1;
}
artifacts[0].ref = ref_edge;
artifacts[0].artifact =
amduat_artifact_with_type(bytes_a,
amduat_type_tag(TYPE_TAG_TGK1_EDGE_V1));
artifacts[1].ref = ref_edge;
artifacts[1].artifact =
amduat_artifact_with_type(bytes_b,
amduat_type_tag(TYPE_TAG_TGK1_EDGE_V1));
if (amduat_tgk_store_mem_init(&mem, config, artifacts, 2)) {
fprintf(stderr, "init accepted conflicting duplicate artifacts\n");
amduat_tgk_store_mem_free(&mem);
free((void *)bytes_a.data);
free((void *)bytes_b.data);
return 1;
}
free((void *)bytes_a.data);
free((void *)bytes_b.data);
return 0;
}
static int test_resolve_edge_unsupported(const test_env_t *env) { static int test_resolve_edge_unsupported(const test_env_t *env) {
amduat_reference_t ref; amduat_reference_t ref;
amduat_tgk_edge_body_t body; amduat_tgk_edge_body_t body;
@ -534,6 +765,9 @@ int main(void) {
test_resolve_edge_missing(&env) != 0 || test_resolve_edge_missing(&env) != 0 ||
test_resolve_edge_unsupported(&env) != 0 || test_resolve_edge_unsupported(&env) != 0 ||
test_init_rejects_unsupported_encoding() != 0 || test_init_rejects_unsupported_encoding() != 0 ||
test_init_rejects_duplicate_hash_id() != 0 ||
test_duplicate_edge_ref_same_artifact() != 0 ||
test_duplicate_edge_ref_conflict() != 0 ||
test_type_filter(&env) != 0 || test_type_filter(&env) != 0 ||
test_ordering(&env) != 0 || test_ordering(&env) != 0 ||
test_adjacency(&env) != 0 || test_adjacency(&env) != 0 ||