aws-sdk-for-zig/src/xml_shaper.zig

const std = @import("std");
const xml = @import("xml.zig");
const date = @import("date.zig");

const log = std.log.scoped(.xml_shaper);

pub const Element = xml.Element;

pub fn Parsed(comptime T: type) type {
    return struct {
        // Forcing an arean allocator isn't my favorite choice here, but
        // is the simplest way to handle deallocation in the event of
        // an error
        allocator: std.heap.ArenaAllocator,
        parsed_value: T,
        document: xml.Document,

        const Self = @This();

        pub fn init(allocator: std.heap.ArenaAllocator, parsedObj: T, document: xml.Document) Self {
            return .{
                .allocator = allocator,
                .parsed_value = parsedObj,
                .document = document,
            };
        }

        pub fn deinit(self: Self) void {
            self.allocator.deinit();
            // deinitObject(self.allocator, self.parsed_value);
            // self.document.deinit();
        }
    };
}

// This is dead code and can be removed with the move to ArenaAllocator
fn deinitObject(allocator: std.mem.Allocator, obj: anytype) void {
    switch (@typeInfo(@TypeOf(obj))) {
        .Optional => if (obj) |o| deinitObject(allocator, o),
        .Union => |union_info| {
            inline for (union_info.fields) |field| {
                std.debug.print("{s}", field); // need to find active field and deinit it
            }
        },
        .Struct => |struct_info| {
            inline for (struct_info.fields) |field| {
                deinitObject(allocator, @field(obj, field.name));
            }
        },
        .Array => {}, // Not implemented below
        .Pointer => |ptr_info| {
            switch (ptr_info.size) {
                .One => {
                    deinitObject(allocator, obj.*);
                    allocator.free(obj);
                },
                .Many => {},
                .C => {},
                .Slice => {
                    for (obj) |child|
                        deinitObject(allocator, child);
                    allocator.free(obj);
                },
            }
        },
        //.Bool, .Float, .ComptimeFloat, .Int, .ComptimeInt, .Enum, .Opaque => {}, // no allocations here
        else => {},
    }
}

// should we just use json parse options?
pub const ParseOptions = struct {
    allocator: ?std.mem.Allocator = null,
    match_predicate_ptr: ?*const fn (a: []const u8, b: []const u8, options: xml.PredicateOptions) anyerror!bool = null,
    /// defines a function to use to locate an element other than the root of the document for parsing
    elementToParse: ?*const fn (element: *Element, options: ParseOptions) *Element = null,
};

pub fn parse(comptime T: type, source: []const u8, options: ParseOptions) !Parsed(T) {
    if (options.allocator == null)
        return error.AllocatorRequired; // we are only leaving it be null for compatibility with json
    const allocator = options.allocator.?;
    var arena_allocator = std.heap.ArenaAllocator.init(allocator);
    const aa = arena_allocator.allocator();
    errdefer arena_allocator.deinit();
    const parsed = try xml.parse(aa, source);
    errdefer parsed.deinit();
    const opts = ParseOptions{
        .allocator = aa,
        .match_predicate_ptr = options.match_predicate_ptr,
    };

    const root = if (options.elementToParse) |e| e(parsed.root, opts) else parsed.root;
    return Parsed(T).init(arena_allocator, try parseInternal(T, root, opts), parsed);
}

fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) !T {
    switch (@typeInfo(T)) {
        .Bool => {
            if (std.ascii.eqlIgnoreCase("true", element.children.items[0].CharData))
                return true;
            if (std.ascii.eqlIgnoreCase("false", element.children.items[0].CharData))
                return false;
            return error.UnexpectedToken;
        },
        .Float, .ComptimeFloat => {
            return std.fmt.parseFloat(T, element.children.items[0].CharData) catch |e| {
                if (log_parse_traces) {
                    std.log.err(
                        "Could not parse '{s}' as float in element '{s}': {any}",
                        .{
                            element.children.items[0].CharData,
                            element.tag,
                            e,
                        },
                    );
                    if (@errorReturnTrace()) |trace| {
                        std.debug.dumpStackTrace(trace.*);
                    }
                }
                return e;
            };
        },
        .Int, .ComptimeInt => {
            // 2021-10-05T16:39:45.000Z
            return std.fmt.parseInt(T, element.children.items[0].CharData, 10) catch |e| {
                if (element.children.items[0].CharData[element.children.items[0].CharData.len - 1] == 'Z') {
                    // We have an iso8601 in an integer field (we think)
                    // Try to coerce this into our type
                    const timestamp = try date.parseIso8601ToTimestamp(element.children.items[0].CharData);
                    return std.math.cast(T, timestamp).?;
                }
                if (log_parse_traces) {
                    std.log.err(
                        "Could not parse '{s}' as integer in element '{s}': {any}",
                        .{
                            element.children.items[0].CharData,
                            element.tag,
                            e,
                        },
                    );
                    if (@errorReturnTrace()) |trace| {
                        std.debug.dumpStackTrace(trace.*);
                    }
                }
                return e;
            };
        },
        .Optional => |optional_info| {
            if (element.children.items.len == 0) {
                // This is almost certainly incomplete. Empty strings? xsi:nil?
                return null;
            }
            if (element.children.items.len > 0) {
                // return try parseInternal(optional_info.child, element.elements().next().?, options);
                return try parseInternal(optional_info.child, element, options);
            }
        },
        .Enum => |enum_info| {
            _ = enum_info;
            // const numeric: ?enum_info.tag_type = std.fmt.parseInt(enum_info.tag_type, element.children.items[0].CharData, 10) catch null;
            // if (numeric) |num| {
            //     return std.meta.intToEnum(T, num);
            // } else {
            //     // json parser handles escaping - could this happen here or does chardata handle?
            //     return std.meta.stringToEnum(T, element.CharData);
            // }
        },
        .Union => |union_info| {
            if (union_info.tag_type) |_| {
                // try each of the union fields until we find one that matches
                // inline for (union_info.fields) |u_field| {
                //     // take a copy of tokens so we can withhold mutations until success
                //     var tokens_copy = tokens.*;
                //     if (parseInternal(u_field.type, token, &tokens_copy, options)) |value| {
                //         tokens.* = tokens_copy;
                //         return @unionInit(T, u_field.name, value);
                //     } else |err| {
                //         // Bubble up error.OutOfMemory
                //         // Parsing some types won't have OutOfMemory in their
                //         // error-sets, for the condition to be valid, merge it in.
                //         if (@as(@TypeOf(err) || error{OutOfMemory}, err) == error.OutOfMemory) return err;
                //         // Bubble up AllocatorRequired, as it indicates missing option
                //         if (@as(@TypeOf(err) || error{AllocatorRequired}, err) == error.AllocatorRequired) return err;
                //         // otherwise continue through the `inline for`
                //     }
                // }
                return error.NoUnionMembersMatched;
            }
            @compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'");
        },
        .Struct => |struct_info| {
            var r: T = undefined;
            var fields_seen = [_]bool{false} ** struct_info.fields.len;
            var fields_set: u64 = 0;
            // errdefer {
            //     // TODO: why so high here? This was needed for ec2 describe instances
            //     @setEvalBranchQuota(100000);
            //     inline for (struct_info.fields) |field, i| {
            //         if (fields_seen[i] and !field.is_comptime) {
            //             parseFree(field.type, @field(r, field.name), options);
            //         }
            //     }
            // }

            // XML parser provides CharData for whitespace around elements.
            // We shall ignore extra data for the moment as a performance thing
            // if (element.children.items.len > struct_info.fields.len) {
            //     std.debug.print("element children: {d}, struct fields: {d}\n", .{ element.children.items.len, struct_info.fields.len });
            //     for (element.children.items) |child, i| {
            //         switch (child) {
            //             .CharData => std.debug.print("{d}: {s}\n", .{ i, child }),
            //             .Comment => {},
            //             .Element => {},
            //         }
            //     }
            //     return error.MoreElementsThanFields;
            // }

            log.debug("Processing fields in struct: {s}", .{@typeName(T)});
            inline for (struct_info.fields, 0..) |field, i| {
                var name: []const u8 = field.name;
                var found_value = false;
                if (comptime std.meta.hasFn(T, "fieldNameFor"))
                    name = r.fieldNameFor(field.name);
                log.debug("Field name: {s}, Element: {s}, Adjusted field name: {s}", .{ field.name, element.tag, name });
                var iterator = element.findChildrenByTag(name);
                if (options.match_predicate_ptr) |predicate_ptr| {
                    iterator.predicate = predicate_ptr;
                    iterator.predicate_options = .{ .allocator = options.allocator.? };
                }
                if (try iterator.next()) |child| {
                    // I don't know that we would use comptime here. I'm also
                    // not sure the nuance of setting this...
                    // if (field.is_comptime) {
                    //     if (!try parsesTo(field.type, field.default_value.?, tokens, options)) {
                    //         return error.UnexpectedValue;
                    //     }
                    // } else {
                    log.debug("Found child element {s}", .{child.tag});
                    // TODO: how do we errdefer this?
                    @field(r, field.name) = try parseInternal(field.type, child, options);
                    fields_seen[i] = true;
                    fields_set = fields_set + 1;
                    found_value = true;
                }
                if (@typeInfo(field.type) == .Optional) {
                    // Test "compiler assertion failure 2"
                    // Zig compiler bug circa 0.9.0. Using "and !found_value"
                    // in the if statement above will trigger assertion failure
                    if (!found_value) {
                        log.debug("Child element not found, but field optional. Setting {s}=null", .{field.name});
                        // @compileLog("Optional: Field name ", field.name, ", type ", field.type);
                        @field(r, field.name) = null;
                        fields_set = fields_set + 1;
                        found_value = true;
                    }
                }
                // Using this else clause breaks zig, so we'll use a boolean instead
                if (!found_value) {
                    log.err("Could not find a value for field {s}. Looking for {s} in element {s}", .{ field.name, name, element.tag });
                    return error.NoValueForField;
                }
                // } else {
                //     return error.NoValueForField;
                // }
            }
            if (fields_set != struct_info.fields.len)
                return error.FieldElementMismatch; // see fields_seen for details
            return r;
        },
        .Array => //|array_info| {
        return error.ArrayNotImplemented,
        // switch (token) {
        //     .ArrayBegin => {
        //         var r: T = undefined;
        //         var i: usize = 0;
        //         errdefer {
        //             while (true) : (i -= 1) {
        //                 parseFree(arrayInfo.child, r[i], options);
        //                 if (i == 0) break;
        //             }
        //         }
        //         while (i < r.len) : (i += 1) {
        //             r[i] = try parse(arrayInfo.child, tokens, options);
        //         }
        //         const tok = (try tokens.next()) orelse return error.UnexpectedEndOfJson;
        //         switch (tok) {
        //             .ArrayEnd => {},
        //             else => return error.UnexpectedToken,
        //         }
        //         return r;
        //     },
        //     .String => |stringToken| {
        //         if (arrayInfo.child != u8) return error.UnexpectedToken;
        //         var r: T = undefined;
        //         const source_slice = stringToken.slice(tokens.slice, tokens.i - 1);
        //         switch (stringToken.escapes) {
        //             .None => mem.copy(u8, &r, source_slice),
        //             .Some => try unescapeValidString(&r, source_slice),
        //         }
        //         return r;
        //     },
        //     else => return error.UnexpectedToken,
        // }
        // },
        .Pointer => |ptr_info| {
            const allocator = options.allocator orelse return error.AllocatorRequired;
            switch (ptr_info.size) {
                .One => {
                    const r: T = try allocator.create(ptr_info.child);
                    errdefer allocator.free(r);
                    r.* = try parseInternal(ptr_info.child, element, options);
                    return r;
                },
                .Slice => {
                    // TODO: Detect and deal with arrays. This will require two
                    //       passes through the element children - one to
                    //       determine if it is an array, one to parse the elements
                    // <Items>
                    //   <Item>foo</Item>
                    //   <Item>bar</Item>
                    // <Items>
                    if (ptr_info.child != u8) {
                        log.debug("type = {s}, ptr_info.child == {s}, element = {s}", .{ @typeName(T), @typeName(ptr_info.child), element.tag });
                        var iterator = element.elements();
                        var children = std.ArrayList(ptr_info.child).init(allocator);
                        defer children.deinit();
                        while (iterator.next()) |child_element| {
                            try children.append(try parseInternal(ptr_info.child, child_element, options));
                        }
                        return children.toOwnedSlice();
                        // var inx: usize = 0;
                        // while (inx < children.len) {
                        //     switch (element.children.items[inx]) {
                        //         .Element => children[inx] = try parseInternal(ptr_info.child, element.children.items[inx].Element, options),
                        //         .CharData => children[inx] = try allocator.dupe(u8, element.children.items[inx].CharData),
                        //         .Comment => children[inx] = try allocator.dupe(u8, element.children.items[inx].Comment), // This might be an error...
                        //     }
                        //     inx += 1;
                        // }
                    }
                    return try allocator.dupe(u8, element.children.items[0].CharData);
                },
                .Many => {
                    return error.ManyPointerSizeNotImplemented;
                },
                .C => {
                    return error.CPointerSizeNotImplemented;
                },
            }
        },
        else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
        // }
        // },
        // else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
    }
    unreachable;
}
pub fn fuzzyEqual(a: []const u8, b: []const u8, options: xml.PredicateOptions) !bool {
    const allocator = options.allocator orelse return error.AllocatorRequired;
    // std.debug.print("raw: a = '{s}', b = '{s}'\n", .{ a, b });
    const lower_a = try std.ascii.allocLowerString(allocator, a);
    defer allocator.free(lower_a);
    const lower_b = try std.ascii.allocLowerString(allocator, b);
    defer allocator.free(lower_b);
    // std.debug.print("lower: a = '{s}', b = '{s}'\n", .{ lower_a, lower_b });
    const normal_a = normalize(lower_a);
    const normal_b = normalize(lower_b);

    // std.debug.print("normal: a = '{s}', b = '{s}'\n", .{ normal_a, normal_b });
    return std.mem.eql(u8, normal_a, normal_b);
}

fn normalize(val: []u8) []u8 {
    var underscores: usize = 0;
    for (val, 0..) |ch, i| {
        if (ch == '_') {
            underscores = underscores + 1;
        } else {
            val[i - underscores] = ch;
        }
    }
    return val[0 .. val.len - underscores];
}

const testing = std.testing;
test "can parse a simple type" {
    const allocator = std.testing.allocator;
    // defer allocator.free(snake_case);
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>bar</fooBar>
        \\</Example>
    ;
    const Example = struct {
        foo_bar: []const u8,
    };
    // std.debug.print("{s}", .{data});
    const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqualStrings("bar", parsed_data.parsed_value.foo_bar);
}

test "can parse a boolean type" {
    const allocator = std.testing.allocator;
    // defer allocator.free(snake_case);
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>true</fooBar>
        \\</Example>
    ;
    const Example = struct {
        foo_bar: bool,
    };
    // std.debug.print("{s}", .{data});
    const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqual(true, parsed_data.parsed_value.foo_bar);
}
test "can parse an integer type" {
    const allocator = std.testing.allocator;
    // defer allocator.free(snake_case);
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>42</fooBar>
        \\</Example>
    ;
    const Example = struct {
        foo_bar: u8,
    };
    // std.debug.print("{s}", .{data});
    const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqual(@as(u8, 42), parsed_data.parsed_value.foo_bar);
}
test "can parse an optional boolean type" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>true</fooBar>
        \\</Example>
    ;
    const ExampleDoesNotMatter = struct {
        foo_bar: ?bool = null,
    };
    const parsed_data = try parse(ExampleDoesNotMatter, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqual(@as(?bool, true), parsed_data.parsed_value.foo_bar);
}

test "can coerce 8601 date to integer" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>2021-10-05T16:39:45.000Z</fooBar>
        \\</Example>
    ;
    const ExampleDoesNotMatter = struct {
        foo_bar: ?i64 = null,
    };
    const parsed_data = try parse(ExampleDoesNotMatter, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqual(@as(i64, 1633451985), parsed_data.parsed_value.foo_bar.?);
}
// This is the simplest test so far that breaks zig (circa 0.9.0)
// See "Using this else clause breaks zig, so we'll use a boolean instead"
test "can parse a boolean type (two fields)" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>true</fooBar>
        \\    <fooBaz>true</fooBaz>
        \\</Example>
    ;
    const ExampleDoesNotMatter = struct {
        foo_bar: bool,
        foo_baz: bool,
    };
    const parsed_data = try parse(ExampleDoesNotMatter, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqual(@as(bool, true), parsed_data.parsed_value.foo_bar);
}
var log_parse_traces = true;
test "can error without leaking memory" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <fooBar>true</fooBar>
        \\    <fooBaz>12.345</fooBaz>
        \\</Example>
    ;
    const ExampleDoesNotMatter = struct {
        foo_bar: bool,
        foo_baz: u64,
    };
    log_parse_traces = false;
    defer log_parse_traces = true;
    try std.testing.expectError(
        error.InvalidCharacter,
        parse(ExampleDoesNotMatter, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual }),
    );
}

test "can parse a nested type" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <foo>
        \\        <bar>baz</bar>
        \\    </foo>
        \\</Example>
    ;
    const Example = struct {
        foo: struct {
            bar: []const u8,
        },
    };
    const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqualStrings("baz", parsed_data.parsed_value.foo.bar);
}
test "can parse a nested type - two fields" {
    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<Example xmlns="http://example.example.com/doc/2016-11-15/">
        \\    <foo>
        \\        <bar>baz</bar>
        \\        <qux>baz</qux>
        \\    </foo>
        \\</Example>
    ;
    const Example = struct {
        foo: struct {
            bar: []const u8,
            qux: []const u8,
        },
    };
    const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate_ptr = fuzzyEqual });
    defer parsed_data.deinit();
    try testing.expectEqualStrings("baz", parsed_data.parsed_value.foo.bar);
    try testing.expectEqualStrings("baz", parsed_data.parsed_value.foo.qux);
}

const service_metadata: struct {
    version: []const u8 = "2016-11-15",
    sdk_id: []const u8 = "EC2",
    arn_namespace: []const u8 = "ec2",
    endpoint_prefix: []const u8 = "ec2",
    sigv4_name: []const u8 = "ec2",
    name: []const u8 = "AmazonEC2",
} = .{};

const describe_regions: struct {
    action_name: []const u8 = "DescribeRegions",
    Request: type = struct {
        // filters: ?[]Filter = null,
        region_names: ?[][]const u8 = null,
        dry_run: ?bool = null,
        all_regions: ?bool = null,

        pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
            const mappings = .{
                .filters = "Filter",
                .region_names = "RegionName",
                .dry_run = "dryRun",
                .all_regions = "AllRegions",
            };
            return @field(mappings, field_name);
        }

        pub fn metaInfo() struct { service_metadata: @TypeOf(service_metadata), action: @TypeOf(describe_regions) } {
            return .{ .service_metadata = service_metadata, .action = describe_regions };
        }
    },
    Response: type = struct {
        regions: ?[]struct {
            // Having two of these causes the zig compiler bug
            // Only one of them works fine. This leads me to believe that
            // it has something to do with the inline for
            endpoint: ?[]const u8 = null,
            region_name: ?[]const u8 = null,

            pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
                const mappings = .{
                    .endpoint = "regionEndpoint",
                    .region_name = "regionName",
                    .opt_in_status = "optInStatus",
                };
                return @field(mappings, field_name);
            }
        } = null,

        pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
            const mappings = .{
                .regions = "regionInfo",
            };
            return @field(mappings, field_name);
        }
    },
} = .{};

test "can parse something serious" {
    // std.testing.log_level = .debug;
    log.debug("", .{});

    const allocator = std.testing.allocator;
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<DescribeRegionsResponse xmlns="http://ec2.amazonaws.com/doc/2016-11-15/">
        \\    <requestId>8d6bfc99-978b-4146-ba23-2e5fe5b65406</requestId>
        \\    <regionInfo>
        \\        <item>
        \\            <regionName>eu-north-1</regionName>
        \\            <regionEndpoint>ec2.eu-north-1.amazonaws.com</regionEndpoint>
        \\        </item>
        \\        <item>
        \\            <regionName>ap-south-1</regionName>
        \\            <regionEndpoint>ec2.ap-south-1.amazonaws.com</regionEndpoint>
        \\        </item>
        \\    </regionInfo>
        \\</DescribeRegionsResponse>
    ;
    // const ServerResponse = struct { DescribeRegionsResponse: describe_regions.Response, };
    const parsed_data = try parse(describe_regions.Response, data, .{ .allocator = allocator, .elementToParse = findResult });
    defer parsed_data.deinit();
    try testing.expect(parsed_data.parsed_value.regions != null);
    try testing.expectEqualStrings("eu-north-1", parsed_data.parsed_value.regions.?[0].region_name.?);
    try testing.expectEqualStrings("ec2.eu-north-1.amazonaws.com", parsed_data.parsed_value.regions.?[0].endpoint.?);
}
const StsGetAccesskeyInfoResponse: type = struct {
    account: ?[]const u8 = null,

    pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
        const mappings = .{
            .account = "Account",
        };
        return @field(mappings, field_name);
    }
};
fn findResult(element: *xml.Element, options: ParseOptions) *xml.Element {
    _ = options;
    // We're looking for a very specific pattern here. We want only two direct
    // children. The first one must end with "Result", and the second should
    // be our ResponseMetadata node
    var children = element.elements();
    var found_metadata = false;
    var result_child: ?*xml.Element = null;
    var inx: usize = 0;
    while (children.next()) |child| : (inx += 1) {
        if (std.mem.eql(u8, child.tag, "ResponseMetadata")) {
            found_metadata = true;
            continue;
        }
        if (std.mem.endsWith(u8, child.tag, "Result")) {
            result_child = child;
            continue;
        }
        if (inx > 1) return element;
        return element; // It should only be those two
    }
    return result_child orelse element;
}
test "can parse a result within a response" {
    log.debug("", .{});

    const allocator = std.testing.allocator;
    const data =
        \\<GetAccessKeyInfoResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
        \\  <GetAccessKeyInfoResult>
        \\    <Account>123456789012</Account>
        \\  </GetAccessKeyInfoResult>
        \\  <ResponseMetadata>
        \\    <RequestId>ec85bf29-1ef0-459a-930e-6446dd14a286</RequestId>
        \\  </ResponseMetadata>
        \\</GetAccessKeyInfoResponse>
    ;
    const parsed_data = try parse(StsGetAccesskeyInfoResponse, data, .{ .allocator = allocator, .elementToParse = findResult });
    defer parsed_data.deinit();
    // Response expectations
    try std.testing.expect(parsed_data.parsed_value.account != null);
    try std.testing.expectEqualStrings("123456789012", parsed_data.parsed_value.account.?);
}

test "compiler assertion failure 2" {
    // std.testing.log_level = .debug;
    // log.debug("", .{});
    // Actually, we only care here that the code compiles
    const allocator = std.testing.allocator;
    const Response: type = struct {
        key_group_list: ?struct {
            quantity: i64, // Making this optional will make the code compile
            items: ?[]struct {
                key_group: []const u8,
            } = null,
            pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
                const mappings = .{
                    .quantity = "Quantity",
                    .items = "Items",
                };
                return @field(mappings, field_name);
            }
        } = null,

        pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
            const mappings = .{
                .key_group_list = "KeyGroupList",
            };
            return @field(mappings, field_name);
        }
    };
    const data =
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<AnythingAtAll xmlns="http://ec2.amazonaws.com/doc/2016-11-15/">
        \\    <KeyGroupList>
        \\        <Quantity>42</Quantity>
        \\    </KeyGroupList>
        \\</AnythingAtAll>
    ;
    const parsed_data = try parse(Response, data, .{ .allocator = allocator });
    defer parsed_data.deinit();
    try testing.expect(parsed_data.parsed_value.key_group_list.?.quantity == 42);
}