Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

35.7 KB
Raw Blame
using System.Globalization;
using System.Text;
using System.Text.Json;
using Filee.Core.Conversion;
using Filee.Core.Formats;
using Filee.Core.Presets;
using Filee.Core.Settings;
using Filee.Engines.Data;
using Filee.Engines.Office.Sheets;

namespace Filee.Engines.Tests;

public class ICalendarTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
    private static string Calendar(params string[] lines) =>
        string.Join("\r\n", ["BEGIN:VCALENDAR", "VERSION:2.0", .. lines, "END:VCALENDAR", ""]);

    private static string Event(string uid, params string[] lines) =>
        string.Join("\r\n", ["BEGIN:VEVENT", "UID:" + uid, .. lines, "END:VEVENT"]);

    private static List<List<string>> Rows(string text) => CsvFormat.Parse(text.TrimStart('\uFEFF'), ',');

    private async Task<string> Convert(string text, string extension, string target)
    {
        var path = Path.Combine(fx.NewFolder(), "source." + extension);
        await File.WriteAllTextAsync(path, text, TestContext.Current.CancellationToken);
        var job = await fx.ConvertAsync([path], new Preset { TargetFormat = target });
        Assert.Equal(JobState.Completed, job.State);
        return job.Outputs.Single();
    }

    private async Task<List<List<string>>> ReadCalendar(string text) =>
        Rows(await File.ReadAllTextAsync(await Convert(text, "ics", "csv"), TestContext.Current.CancellationToken));

    private static string Cell(List<List<string>> rows, int row, string name) => rows[row][rows[0].IndexOf(name)];

    private static string Csv(params string[][] rows) =>
        string.Join("\r\n", rows.Select(row => string.Join(",", row.Select(value =>
            value.IndexOfAny([',', '"', '\n', '\r']) < 0 ? value : "\"" + value.Replace("\"", "\"\"") + "\"")))) + "\r\n";

    [Fact]
    public async Task Google_export_preserves_columns_recurrence_attendees_folding_and_skips_alarm()
    {
        var zone = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Asia/Seoul", "BEGIN:STANDARD",
            "DTSTART:19700101T000000", "TZOFFSETFROM:+0900", "TZOFFSETTO:+0900", "END:STANDARD", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(zone, Event("007",
            "SUMMARY:123", "DTSTART:20261021T000000Z", "DTEND:20261021T010000Z", "LOCATION:true",
            "DESCRIPTION:긴 설명이 접힌 줄의 전반부 ", "\t후반부\\n둘째 줄",
            "RRULE:FREQ=WEEKLY;COUNT=3", "EXDATE;TZID=Asia/Seoul:20261028T090000,20261104T090000",
            "EXDATE;TZID=Asia/Seoul:20261111T090000",
            "ATTENDEE;CN=\"Kim, A\":mailto:[email protected]", "ATTENDEE:mailto:[email protected]",
            "BEGIN:VALARM", "DESCRIPTION:do not replace event description", "END:VALARM"),
            Event("seoul", "DTSTART;TZID=Asia/Seoul:20261021T090000")));
        Assert.Equal(ICalendar.Columns, rows[0]);
        Assert.Equal(3, rows.Count);
        Assert.Equal("2026-10-21T00:00:00Z", Cell(rows, 1, "Start"));
        Assert.Equal("2026-10-21T09:00:00+09:00", Cell(rows, 2, "Start"));
        Assert.Equal("123", Cell(rows, 1, "Title"));
        Assert.Equal("true", Cell(rows, 1, "Location"));
        Assert.Equal("007", Cell(rows, 1, "UID"));
        Assert.Equal("긴 설명이 접힌 줄의 전반부 후반부\n둘째 줄", Cell(rows, 1, "Description"));
        Assert.Equal("FREQ=WEEKLY;COUNT=3", Cell(rows, 1, "RRULE"));
        Assert.Equal("EXDATE;TZID=Asia/Seoul:20261028T090000,20261104T090000\nEXDATE;TZID=Asia/Seoul:20261111T090000", Cell(rows, 1, "EXDATE"));
        Assert.Equal("Kim, A <[email protected]>\n[email protected]", Cell(rows, 1, "Attendees"));
    }

    [Fact]
    public async Task Apple_all_day_exclusive_end_duration_and_unknown_properties()
    {
        var rows = await ReadCalendar(Calendar(
            Event("all", "DTSTART;VALUE=DATE:20261021", "DTEND;VALUE=DATE:20261022", "X-APPLE-STRUCTURED-LOCATION:ignored"),
            Event("duration", "DTSTART:20261021T090000Z", "DURATION:PT1H30M"),
            Event("weeks", "DTSTART;VALUE=DATE:20261021", "DURATION:P2W")));
        Assert.Equal("2026-10-22", Cell(rows, 1, "End"));
        Assert.Equal("true", Cell(rows, 1, "All day"));
        Assert.Equal("", Cell(rows, 1, "Time zone"));
        Assert.Equal("2026-10-21T10:30:00Z", Cell(rows, 2, "End"));
        Assert.Equal("2026-11-04", Cell(rows, 3, "End"));
    }

    [Fact]
    public async Task Duration_crossing_daylight_saving_time_keeps_calendar_days_and_elapsed_hours()
    {
        var customZone = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Custom/Spring", "BEGIN:DAYLIGHT",
            "DTSTART:20260308T020000", "TZOFFSETFROM:-0500", "TZOFFSETTO:-0400", "END:DAYLIGHT", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(customZone,
            Event("spring-clock", "DTSTART;TZID=America/New_York:20260308T013000", "DURATION:PT2H"),
            Event("spring-day", "DTSTART;TZID=America/New_York:20260308T013000", "DURATION:P1D"),
            Event("spring-24h", "DTSTART;TZID=America/New_York:20260308T013000", "DURATION:PT24H"),
            Event("spring-mixed", "DTSTART;TZID=America/New_York:20260307T013000", "DURATION:P1DT2H"),
            Event("fall-clock", "DTSTART;TZID=America/New_York:20261101T003000", "DURATION:PT2H"),
            Event("custom", "DTSTART;TZID=Custom/Spring:20260308T013000", "DURATION:PT2H")));
        Assert.Equal("2026-03-08T04:30:00-04:00", Cell(rows, 1, "End"));
        Assert.Equal("2026-03-09T01:30:00-04:00", Cell(rows, 2, "End"));
        Assert.Equal("2026-03-09T02:30:00-04:00", Cell(rows, 3, "End"));
        Assert.Equal("2026-03-08T04:30:00-04:00", Cell(rows, 4, "End"));
        Assert.Equal("2026-11-01T01:30:00-05:00", Cell(rows, 5, "End"));
        Assert.Equal("2026-03-08T04:30:00-04:00", Cell(rows, 6, "End"));
    }

    [Fact]
    public async Task Outlook_windows_zone_custom_zone_unknown_rules_and_recurrence_instance()
    {
        var fixedZone = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Customized Time Zone", "BEGIN:STANDARD",
            "DTSTART:19700101T000000", "TZOFFSETFROM:+0530", "TZOFFSETTO:+0530", "END:STANDARD", "END:VTIMEZONE");
        var unknown = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Unknown/Rule", "BEGIN:STANDARD",
            "DTSTART:19700101T000000", "TZOFFSETFROM:+0100", "TZOFFSETTO:+0200",
            "RRULE:FREQ=YEARLY;BYMONTH=1;BYDAY=1SU", "END:STANDARD", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(fixedZone, unknown,
            Event("windows", "DTSTART;TZID=Korea Standard Time:20261021T090000"),
            Event("custom", "DTSTART;TZID=Customized Time Zone:20261021T090000"),
            Event("unknown", "DTSTART;TZID=Unknown/Rule:20261021T090000"),
            Event("exception", "DTSTART:20261021T100000Z", "RECURRENCE-ID;TZID=Asia/Seoul:20261021T090000")));
        Assert.Equal("2026-10-21T09:00:00+09:00", Cell(rows, 1, "Start"));
        Assert.Equal("2026-10-21T09:00:00+05:30", Cell(rows, 2, "Start"));
        Assert.Equal("2026-10-21T09:00:00", Cell(rows, 3, "Start"));
        Assert.Equal("Unknown/Rule", Cell(rows, 3, "Time zone"));
        Assert.Equal("RECURRENCE-ID;TZID=Asia/Seoul:20261021T090000", Cell(rows, 4, "Recurrence ID"));
    }

    [Fact]
    public async Task Calendar_order_is_event_todo_event_across_two_calendars()
    {
        var text = Calendar(Event("A", "DTSTART:20261021T090000Z"), "BEGIN:VTODO", "UID:B", "END:VTODO")
            + Calendar(Event("C", "DTSTART:20261021T090000Z"));
        var rows = await ReadCalendar(text);
        Assert.Equal([("event", "A"), ("todo", "B"), ("event", "C")],
            rows.Skip(1).Select(row => (row[0], row[13])).ToArray());
    }

    [Fact]
    public async Task File_timezone_wins_and_transitions_are_scoped_to_each_calendar()
    {
        static string Zone(string id, string from, string to) =>
            string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:" + id, "BEGIN:STANDARD",
                "DTSTART:20261021T100000", "TZOFFSETFROM:" + from, "TZOFFSETTO:" + to,
                "END:STANDARD", "END:VTIMEZONE");
        var text = Calendar(Zone("America/New_York", "+0100", "+0100"),
            Event("file", "DTSTART;TZID=America/New_York:20261021T090000"))
            + Calendar(Zone("Custom/Change", "+0100", "+0200"),
                Event("before", "DTSTART;TZID=Custom/Change:20261021T090000"),
                Event("after", "DTSTART;TZID=Custom/Change:20261021T110000"))
            + Calendar(Zone("America/New_York", "+0300", "+0300"),
                Event("second", "DTSTART;TZID=America/New_York:20261021T090000"));
        var rows = await ReadCalendar(text);
        Assert.EndsWith("+01:00", Cell(rows, 1, "Start"));
        Assert.EndsWith("+01:00", Cell(rows, 2, "Start"));
        Assert.EndsWith("+02:00", Cell(rows, 3, "Start"));
        Assert.EndsWith("+03:00", Cell(rows, 4, "Start"));
    }

    [Fact]
    public async Task Custom_zone_with_second_offsets_keeps_instants_and_duration()
    {
        var zone = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Custom/Seconds", "BEGIN:STANDARD",
            "DTSTART:19000101T000000", "TZOFFSETFROM:+001932", "TZOFFSETTO:+001932", "END:STANDARD",
            "BEGIN:DAYLIGHT", "DTSTART:19000601T020000", "TZOFFSETFROM:+001932", "TZOFFSETTO:+012032",
            "END:DAYLIGHT", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(zone,
            Event("before", "DTSTART;TZID=Custom/Seconds:19000601T013000", "DURATION:PT2H"),
            Event("after", "DTSTART;TZID=Custom/Seconds:19000601T040000",
                "DTEND;TZID=Custom/Seconds:19000601T050000")));

        Assert.Equal("1900-06-01T01:10:28Z", Cell(rows, 1, "Start"));
        Assert.Equal("1900-06-01T03:10:28Z", Cell(rows, 1, "End"));
        Assert.Equal("1900-06-01T02:39:28Z", Cell(rows, 2, "Start"));
        Assert.Equal("1900-06-01T03:39:28Z", Cell(rows, 2, "End"));
    }

    [Theory]
    [InlineData("+001932", "1900-06-01T11:40:28Z")]
    [InlineData("-003015", "1900-06-01T12:30:15Z")]
    [InlineData("+1500", "1900-05-31T21:00:00Z")]
    [InlineData("+053000", "1900-06-01T12:00:00+05:30")]
    public async Task Custom_offset_is_exported_without_losing_its_instant(string offset, string expected)
    {
        var zone = string.Join("\r\n", "BEGIN:VTIMEZONE", "TZID:Custom/Fixed", "BEGIN:STANDARD",
            "DTSTART:19000101T000000", "TZOFFSETFROM:" + offset, "TZOFFSETTO:" + offset,
            "END:STANDARD", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(zone, Event("fixed", "DTSTART;TZID=Custom/Fixed:19000601T120000")));
        Assert.Equal(expected, Cell(rows, 1, "Start"));
    }

    [Fact]
    public async Task Rdate_transitions_before_between_after_and_tab_fold_with_escapes()
    {
        var zone = string.Join("\n", "BEGIN:VTIMEZONE", "TZID:Custom/Rdate", "BEGIN:STANDARD",
            "DTSTART:20261021T100000", "RDATE:20261121T100000",
            "TZOFFSETFROM:+0100", "TZOFFSETTO:+0200", "END:STANDARD",
            "BEGIN:DAYLIGHT", "DTSTART:20261221T100000", "RDATE:20270121T100000",
            "TZOFFSETFROM:+0200", "TZOFFSETTO:+0300", "END:DAYLIGHT", "END:VTIMEZONE");
        var rows = await ReadCalendar(Calendar(zone,
            Event("first", "DTSTART;TZID=Custom/Rdate:20261020T090000", @"SUMMARY:a\\b\;c\,d\ne\Nlast"),
            Event("middle", "DTSTART;TZID=Custom/Rdate:20261101T090000"),
            Event("last", "DTSTART;TZID=Custom/Rdate:20270122T090000")).Replace("\r\n", "\n"));
        Assert.EndsWith("+01:00", Cell(rows, 1, "Start"));
        Assert.EndsWith("+02:00", Cell(rows, 2, "Start"));
        Assert.EndsWith("+03:00", Cell(rows, 3, "Start"));
        Assert.Equal("a\\b;c,d\ne\nlast", Cell(rows, 1, "Title"));
    }

    [Fact]
    public async Task Todo_only_due_duration_without_dates_and_mixed_end_zones()
    {
        var rows = await ReadCalendar(Calendar(
            "BEGIN:VTODO", "UID:due", "DUE;VALUE=DATE:20261030", "END:VTODO",
            "BEGIN:VTODO", "UID:duration", "DTSTART:20261021T090000Z", "DURATION:PT1H", "END:VTODO",
            "BEGIN:VTODO", "UID:empty", "END:VTODO",
            Event("mixed", "DTSTART;TZID=Asia/Seoul:20261021T090000",
                "DTEND;TZID=America/New_York:20261021T090000")));
        Assert.Equal(5, rows.Count);
        Assert.Equal("", Cell(rows, 1, "Start"));
        Assert.Equal("2026-10-30", Cell(rows, 1, "End"));
        Assert.Equal("false", Cell(rows, 1, "All day"));
        Assert.Equal("2026-10-21T10:00:00Z", Cell(rows, 2, "End"));
        Assert.Equal("", Cell(rows, 3, "End"));
        Assert.Equal("Asia/Seoul", Cell(rows, 4, "Time zone"));
        Assert.EndsWith("-04:00", Cell(rows, 4, "End"));
        var output = await File.ReadAllTextAsync(await Convert(Csv(ICalendar.Columns,
            rows[1].ToArray()), "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.DoesNotContain("DTSTART", output);
        Assert.Contains("DUE;VALUE=DATE:20261030", output);
    }

    [Fact]
    public async Task Todo_only_calendar_converts_to_one_todo_row()
    {
        var rows = await ReadCalendar(Calendar(
            "BEGIN:VTODO", "UID:only", "DUE;VALUE=DATE:20261030", "END:VTODO"));
        Assert.Equal(2, rows.Count);
        Assert.Equal("todo", Cell(rows, 1, "Type"));
    }

    [Fact]
    public async Task Malformed_input_keeps_only_closed_components_and_raw_unparseable_dates()
    {
        var rows = await ReadCalendar(Calendar(
            "garbage", "NO-COLON",
            Event("closed", "DTSTART:tomorrow", "DTEND:tomorrow", "EXDATE:abc"),
            Event("bad-duration", "DTSTART:20261021T090000Z", "DURATION:abc"),
            Event("missing-start", "DTEND:20261021T090000Z"))
            + "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nUID:unclosed");
        Assert.Equal(4, rows.Count);
        Assert.Equal("tomorrow", Cell(rows, 1, "Start"));
        Assert.Equal("tomorrow", Cell(rows, 1, "End"));
        Assert.Equal("EXDATE:abc", Cell(rows, 1, "EXDATE"));
        Assert.Equal("", Cell(rows, 2, "End"));
        Assert.Equal("", Cell(rows, 3, "Start"));
        Assert.Equal("2026-10-21T09:00:00Z", Cell(rows, 3, "End"));
    }

    [Fact]
    public async Task Ambiguous_new_york_time_uses_standard_offset()
    {
        var rows = await ReadCalendar(Calendar(Event("dst", "DTSTART;TZID=America/New_York:20261101T013000")));
        Assert.Equal("2026-11-01T01:30:00-05:00", Cell(rows, 1, "Start"));
    }

    [Fact]
    public async Task Empty_calendar_and_invalid_table_fail_without_output()
    {
        var ics = Path.Combine(fx.NewFolder(), "empty.ics");
        await File.WriteAllTextAsync(ics, Calendar("BEGIN:VJOURNAL", "END:VJOURNAL"), TestContext.Current.CancellationToken);
        var csv = Path.Combine(fx.NewFolder(), "empty.csv");
        await File.WriteAllTextAsync(csv, "Title,Start\r\nA,\r\nB,10/21/2026\r\n", TestContext.Current.CancellationToken);
        foreach (var (path, target) in new[] { (ics, "csv"), (csv, "ics") })
        {
            var job = await fx.ConvertAsync([path], new Preset { TargetFormat = target });
            Assert.Equal(JobState.Failed, job.State);
            Assert.Equal("error.conversion_failed", job.Files.Single().ErrorKey);
            Assert.Contains("no iCalendar events", job.Files.Single().ErrorDetail);
            Assert.Empty(job.Outputs);
            Assert.Empty(Directory.GetFiles(Path.GetDirectoryName(path)!, "*." + target));
        }
        var missing = Path.Combine(fx.NewFolder(), "unknown.csv");
        await File.WriteAllTextAsync(missing, "Unknown,Other\r\nA,B\r\n", TestContext.Current.CancellationToken);
        Assert.Equal(JobState.Failed, (await fx.ConvertAsync([missing], new Preset { TargetFormat = "ics" })).State);
    }

    [Fact]
    public async Task Json_route_has_two_data_steps_and_uses_csv_type_inference()
    {
        var planner = fx.Catalog.CreatePlanner();
        var route = planner.Plan("ics", "json");
        Assert.NotNull(route);
        Assert.Equal(2, route.Steps.Count);
        Assert.All(route.Steps, step => Assert.Equal("data", step.Converter.Id));
        var path = await Convert(Calendar(Event("007", "SUMMARY:123", "LOCATION:true",
            "DTSTART;VALUE=DATE:20261021")), "ics", "json");
        using var document = JsonDocument.Parse(await File.ReadAllTextAsync(path, TestContext.Current.CancellationToken));
        var row = document.RootElement.EnumerateArray().Single();
        Assert.Equal(ICalendar.Columns, row.EnumerateObject().Select(p => p.Name).ToArray());
        Assert.True(row.GetProperty("All day").GetBoolean());
        Assert.True(row.GetProperty("Location").GetBoolean());
        Assert.Equal(123, row.GetProperty("Title").GetInt32());
        Assert.Equal("007", row.GetProperty("UID").GetString());
    }

    [Fact]
    public async Task Csv_writer_skips_invalid_events_end_and_unknown_columns_and_uses_leftmost_alias()
    {
        var text = await File.ReadAllTextAsync(await Convert(
            Csv(["Title", "Summary", "Start", "End", "Unknown"],
                ["A", "B", "2026-10-21", "soon", "secret"],
                ["skip", "x", "", "", "secret"],
                ["skip2", "y", "10/21/2026", "", "secret"]),
            "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Equal(1, text.Split("BEGIN:VEVENT").Length - 1);
        Assert.Contains("SUMMARY:A", text);
        Assert.DoesNotContain("SUMMARY:B", text);
        Assert.DoesNotContain("DTEND", text);
        Assert.DoesNotContain("secret", text);
    }

    [Theory]
    [InlineData("Summary", "Begin", "Finish")]
    [InlineData("Subject", "시작", "종료")]
    [InlineData("제목", "开始", "结束")]
    [InlineData("标题", "Begin", "Finish")]
    [InlineData("title", "START", "End")]
    public async Task Accepted_aliases_and_case_insensitive_headers(string title, string start, string end)
    {
        var output = await File.ReadAllTextAsync(await Convert(Csv([title, start, end],
            ["alias", "2026-10-21", "2026-10-22"]), "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Contains("SUMMARY:alias", output);
        Assert.Contains("DTSTART;VALUE=DATE:20261021", output);
        Assert.Contains("DTEND;VALUE=DATE:20261022", output);
    }

    [Theory]
    [InlineData("Location", "장소")]
    [InlineData("Location", "地点")]
    [InlineData("Description", "Notes")]
    [InlineData("Description", "설명")]
    [InlineData("Description", "描述")]
    public async Task Location_and_description_aliases(string field, string alias)
    {
        var output = await File.ReadAllTextAsync(await Convert(Csv(["Title", "Start", alias],
            ["A", "2026-10-21", "sample"]), "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Contains(field.ToUpperInvariant() + ":sample", output);
    }

    [Fact]
    public async Task Output_contract_uid_stamp_bom_folding_timezone_and_text_escaping()
    {
        var row = new[] { "event", "제목, 쉼표; 역슬래시\\ 줄\n둘", "2026-07-21T09:00:00+09:00",
            "2026-07-21T10:00:00+09:00", "false", "Asia/Seoul", "", new string('가', 55),
            "Kim, A <[email protected]>", "Kim; A <[email protected]>", "FREQ=DAILY;COUNT=2",
            "EXDATE;TZID=Asia/Seoul:20260722T090000", "RECURRENCE-ID;TZID=Asia/Seoul:20260720T090000", "" };
        var csv = Csv(ICalendar.Columns, row);
        var before = DateTime.UtcNow.AddSeconds(-1);
        var first = await Convert(csv, "csv", "ics");
        var bytes = await File.ReadAllBytesAsync(first, TestContext.Current.CancellationToken);
        var after = DateTime.UtcNow.AddSeconds(1);
        Assert.False(bytes is [0xEF, 0xBB, 0xBF, ..]);
        var text = Encoding.UTF8.GetString(bytes);
        Assert.StartsWith("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Filee//Filee//EN\r\n", text);
        Assert.Contains("BEGIN:VTIMEZONE\r\nTZID:Asia/Seoul\r\n", text);
        Assert.Contains("TZOFFSETFROM:+0900\r\nTZOFFSETTO:+0900", text);
        Assert.Contains("SUMMARY:제목\\, 쉼표\\; 역슬래시\\\\ 줄\\n둘", text);
        Assert.Contains("ORGANIZER;CN=\"Kim, A\":mailto:[email protected]", text);
        Assert.Contains("ATTENDEE;CN=\"Kim; A\":mailto:[email protected]", text);
        Assert.Contains("EXDATE;TZID=Asia/Seoul:20260722T090000", text);
        Assert.Contains("RECURRENCE-ID;TZID=Asia/Seoul:20260720T090000", text);
        Assert.DoesNotContain("\n", text.Replace("\r\n", ""));
        Assert.All(text.Split("\r\n"), line => Assert.True(Encoding.UTF8.GetByteCount(line) <= 75, line));
        var unfolded = text.Replace("\r\n ", "");
        var stamp = unfolded.Split("\r\n").Single(line => line.StartsWith("DTSTAMP:"))[8..];
        var parsed = DateTime.ParseExact(stamp, "yyyyMMdd'T'HHmmss'Z'", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
        Assert.InRange(parsed, before.AddSeconds(-1), after);
        var uid = unfolded.Split("\r\n").Single(line => line.StartsWith("UID:"));
        var second = await File.ReadAllTextAsync(await Convert(csv, "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Contains(uid, second.Replace("\r\n ", ""));
        var roundtrip = await ReadCalendar(text);
        Assert.Equal("Kim, A <[email protected]>", Cell(roundtrip, 1, "Organizer"));
        Assert.Equal("Kim; A <[email protected]>", Cell(roundtrip, 1, "Attendees"));
    }

    [Fact]
    public async Task Injected_rrule_and_exdate_cannot_create_events_or_alarms()
    {
        var row = Enumerable.Repeat("", ICalendar.Columns.Length).ToArray();
        row[1] = "Safe";
        row[2] = "2026-10-22T09:00:00Z";
        row[10] = "FREQ=DAILY\nBEGIN:VALARM";
        row[11] = "EXDATE:20261022T090000Z\r\nEND:VEVENT\nBEGIN:VEVENT\rSUMMARY:Injected"
            + "\nexdate;VALUE=DATE:20261023\rEXDATEX:20261024T090000Z";
        var second = (string[])row.Clone();
        second[1] = "Second";
        second[10] = "FREQ=WEEKLY\rX-INJECT:1";
        second[11] = "";
        var text = (await File.ReadAllTextAsync(await Convert(Csv(ICalendar.Columns, row, second),
            "csv", "ics"), TestContext.Current.CancellationToken)).Replace("\r\n ", "");
        var lines = text.Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
        Assert.Equal(2, lines.Count(line => line == "BEGIN:VEVENT"));
        Assert.DoesNotContain("VALARM", text);
        Assert.DoesNotContain("Injected", text);
        Assert.DoesNotContain("RRULE:", text);
        Assert.Contains("EXDATE:20261022T090000Z", lines);
        Assert.Contains("exdate;VALUE=DATE:20261023", lines);
        Assert.DoesNotContain("EXDATEX:20261024T090000Z", lines);
        var stack = new Stack<string>();
        foreach (var line in lines)
        {
            if (line.StartsWith("BEGIN:", StringComparison.Ordinal))
                stack.Push(line[6..]);
            if (line.StartsWith("END:", StringComparison.Ordinal))
                Assert.Equal(stack.Pop(), line[4..]);
        }
        Assert.Empty(stack);
        var names = new HashSet<string>(StringComparer.Ordinal)
        {
            "BEGIN", "END", "VERSION", "PRODID", "UID", "DTSTAMP", "SUMMARY",
            "DTSTART", "DTEND", "DUE", "LOCATION", "DESCRIPTION", "ORGANIZER",
            "ATTENDEE", "RRULE", "EXDATE", "RECURRENCE-ID", "TZID",
            "TZOFFSETFROM", "TZOFFSETTO", "TZNAME", "RDATE",
        };
        foreach (var line in lines)
        {
            Assert.Matches(@"^[A-Za-z-]+(?:;[^:\r\n]+)?:[^\r\n]*$", line);
            Assert.Contains(line.Split([';', ':'], 2)[0].ToUpperInvariant(), names);
        }
    }

    [Theory]
    [InlineData("bad\nBEGIN:VEVENT")]
    [InlineData("bad\rEND:VEVENT")]
    public async Task Uid_with_line_break_uses_generated_uid(string uid)
    {
        var text = (await File.ReadAllTextAsync(await Convert(Csv(["Title", "Start", "UID"],
            ["Safe", "2026-10-21", uid]), "csv", "ics"), TestContext.Current.CancellationToken))
            .Replace("\r\n ", "");
        Assert.Matches(@"(?m)^UID:[0-9a-f]{16}@filee\r?$", text);
        Assert.Contains("SUMMARY:Safe\r\nDTSTART;VALUE=DATE:20261021", text);
        Assert.Equal(1, text.Split("BEGIN:VEVENT").Length - 1);
    }

    [Theory]
    [InlineData("Asia/Seoul\nX-INJECT:1")]
    [InlineData("Asia/Seoul\rX-INJECT:1")]
    [InlineData("Asia/Seoul:X")]
    [InlineData("Asia/Seoul;X")]
    [InlineData("Asia/Seoul\"X")]
    public async Task Invalid_timezone_cell_is_discarded_for_dates_and_definitions(string timezone)
    {
        var text = await File.ReadAllTextAsync(await Convert(Csv(["Title", "Start", "Time zone"],
            ["Safe", "2026-10-21T09:00:00+09:00", timezone]), "csv", "ics"),
            TestContext.Current.CancellationToken);
        Assert.DoesNotContain("TZID", text);
        Assert.DoesNotContain("VTIMEZONE", text);
        Assert.Contains("SUMMARY:Safe\r\nDTSTART:20261021T000000Z", text);
        Assert.Equal(1, text.Split("BEGIN:VEVENT").Length - 1);
    }

    [Fact]
    public async Task Invalid_timezone_cannot_borrow_another_events_valid_zone()
    {
        var text = (await File.ReadAllTextAsync(await Convert(Csv(
            ["Title", "Start", "Time zone"],
            ["Valid", "2026-10-21T09:00:00+09:00", "Asia/Seoul"],
            ["Invalid", "2026-10-21T09:00:00+09:00", "Asia/Seoul;X"]),
            "csv", "ics"), TestContext.Current.CancellationToken)).Replace("\r\n ", "");
        Assert.Contains("BEGIN:VTIMEZONE\r\nTZID:Asia/Seoul", text);
        Assert.Contains("SUMMARY:Valid\r\nDTSTART;TZID=Asia/Seoul:20261021T090000", text);
        Assert.Contains("SUMMARY:Invalid\r\nDTSTART:20261021T000000Z", text);
    }

    [Fact]
    public async Task Recurrence_id_accepts_only_its_own_content_lines()
    {
        var text = (await File.ReadAllTextAsync(await Convert(Csv(["Title", "Start", "Recurrence ID"],
            ["Safe", "2026-10-21", "RECURRENCE-ID;TZID=Asia/Seoul:20261021T090000\nX-INJECT:1"
                + "\rrecurrence-id:20261022T090000Z\r\nRECURRENCE-IDX:20261023T090000Z"]),
            "csv", "ics"), TestContext.Current.CancellationToken)).Replace("\r\n ", "");
        Assert.Contains("RECURRENCE-ID;TZID=Asia/Seoul:20261021T090000\r\n", text);
        Assert.Contains("recurrence-id:20261022T090000Z\r\n", text);
        Assert.DoesNotContain("X-INJECT", text);
        Assert.DoesNotContain("RECURRENCE-IDX", text);
    }

    [Fact]
    public async Task People_remove_quotes_and_line_breaks_without_new_content_lines()
    {
        var text = (await File.ReadAllTextAsync(await Convert(Csv(
            ["Title", "Start", "Organizer", "Attendees"],
            ["Safe", "2026-10-21", "Lee\r\nX-INJECT:1, B <[email protected]>",
                "Kim \"A\", B <[email protected]>\r\nPark\rInjected, C <[email protected]>"]),
            "csv", "ics"), TestContext.Current.CancellationToken)).Replace("\r\n ", "");
        Assert.Contains("ORGANIZER;CN=\"LeeX-INJECT:1, B\":mailto:[email protected]\r\n", text);
        Assert.Contains("ATTENDEE;CN=\"Kim A, B\":mailto:[email protected]\r\n", text);
        Assert.Contains("ATTENDEE;CN=\"ParkInjected, C\":mailto:[email protected]\r\n", text);
        Assert.DoesNotContain("\r\nX-INJECT:", text);
        Assert.DoesNotContain("\r\nInjected,", text);
        Assert.Equal(2, text.Split("ATTENDEE;").Length - 1);
    }

    [Fact]
    public async Task Long_combining_sequence_folds_within_seventy_five_octets_and_roundtrips()
    {
        var title = "e" + new string('\u0301', 40);
        var text = await File.ReadAllTextAsync(await Convert(
            Csv(["Title", "Start"], [title, "2026-10-21"]), "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.All(text.Split("\r\n"), line => Assert.True(Encoding.UTF8.GetByteCount(line) <= 75, line));
        var rows = await ReadCalendar(text);
        Assert.Equal(title, Cell(rows, 1, "Title"));
    }

    [Fact]
    public async Task Calendar_defaults_type_ignores_all_day_and_preserves_due_only_todo()
    {
        var rows = new[]
        {
            new[] { "", "blank", "2026-10-21T09:00:00Z", "", "true", "", "", "", "", "", "", "", "", "one" },
            new[] { "meeting", "other", "2026-10-21", "", "", "", "", "", "", "", "", "", "", "two" },
            new[] { "todo", "due", "", "2026-10-21T09:00:00+09:00", "false", "Asia/Seoul", "", "", "", "", "", "", "", "three" },
        };
        var text = await File.ReadAllTextAsync(await Convert(Csv([ICalendar.Columns, .. rows]), "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Equal(2, text.Split("BEGIN:VEVENT").Length - 1);
        Assert.Contains("DTSTART:20261021T090000Z", text);
        Assert.Contains("DTSTART;VALUE=DATE:20261021", text);
        Assert.Contains("BEGIN:VTODO", text);
        var back = await ReadCalendar(text);
        Assert.Equal("", Cell(back, 3, "Start"));
        Assert.Equal("2026-10-21T09:00:00+09:00", Cell(back, 3, "End"));
        Assert.Equal("", Cell(back, 3, "Time zone"));
    }

    [Fact]
    public async Task Canonical_rows_roundtrip_all_fourteen_columns()
    {
        var rows = new[]
        {
            new[] { "event", "all", "2026-10-21", "2026-10-22", "true", "", "", "", "", "", "", "", "", "all" },
            new[] { "event", "seoul", "2026-10-21T09:00:00+09:00", "2026-10-21T10:00:00+09:00", "false", "Asia/Seoul", "", "", "", "", "", "", "", "seoul" },
            new[] { "event", "summer", "2026-07-21T09:00:00-04:00", "2026-07-21T10:00:00-04:00", "false", "America/New_York", "", "", "", "", "", "", "", "summer" },
            new[] { "event", "winter", "2026-12-21T09:00:00-05:00", "2026-12-21T10:00:00-05:00", "false", "America/New_York", "", "", "", "", "", "", "", "winter" },
            new[] { "event", "overlap", "2026-11-01T01:30:00-05:00", "", "false", "America/New_York", "", "", "", "", "", "", "", "overlap" },
            new[] { "event", "gap", "2026-03-08T02:30:00-05:00", "", "false", "America/New_York", "", "", "", "", "", "", "", "gap" },
            new[] { "event", "utc", "2026-10-21T00:00:00Z", "", "false", "", "", "", "", "", "", "", "", "utc" },
            new[] { "event", "float", "2026-10-21T09:00:00", "", "false", "", "", "", "", "", "", "", "", "float" },
            new[] { "todo", "task", "", "2026-10-21T09:00:00", "false", "", "", "", "", "", "", "", "", "todo" },
            new[] { "event", "a,b;c\\d\nsecond", "2026-10-21T09:00:00Z", "", "false", "", "", "x,y;z\\q\nagain",
                "name <[email protected]>", "one <[email protected]>\ntwo <[email protected]>", "FREQ=WEEKLY;COUNT=2",
                "EXDATE:20261028T090000Z\nEXDATE:20261104T090000Z", "RECURRENCE-ID:20261021T090000Z", "details" },
            new[] { "event", "uri", "2026-10-21T09:00:00Z", "", "false", "", "", "", "urn:organizer:abc", "", "", "", "", "uri" },
        };
        var original = Csv([ICalendar.Columns, .. rows]);
        var output = await Convert(original, "csv", "ics");
        var back = Rows(await File.ReadAllTextAsync(await Convert(await File.ReadAllTextAsync(output, TestContext.Current.CancellationToken),
            "ics", "csv"), TestContext.Current.CancellationToken));
        Assert.Equal(rows.Length + 1, back.Count);
        for (var i = 0; i < rows.Length; i++)
            Assert.Equal(rows[i], back[i + 1]);
    }

    [Fact]
    public async Task Noncanonical_rows_follow_loss_and_offset_rules()
    {
        var rows = new[]
        {
            new[] { "event", "generated", "2026-10-21T09:00:00Z", "", "false", "", "", "", "", "", "", "", "", "" },
            new[] { "event", "bad end", "2026-10-21T09:00:00Z", "tomorrow", "false", "", "", "", "", "", "", "", "", "bad" },
            new[] { "event", "floating end", "2026-10-21T09:00:00+09:00", "2026-10-21T10:00:00", "false", "Asia/Seoul", "", "", "", "", "", "", "", "floating" },
            new[] { "event", "overlap front", "2026-11-01T01:30:00-04:00", "", "false", "America/New_York", "", "", "", "", "", "", "", "front" },
            new[] { "event", "unknown", "2026-10-21T09:00:00+09:00", "", "false", "Unknown/Area", "", "", "", "", "", "", "", "unknown" },
            new[] { "event", "numeric", "2026-10-21T09:00:00+09:00", "", "false", "", "", "", "", "", "", "", "", "numeric" },
            new[] { "event", "invalid exdates", "2026-10-21T09:00:00Z", "", "false", "", "", "", "", "",
                "", "EXDATEX:20261028T090000\nEXDATE :20261029T090000", "", "exdates" },
            new[] { "event", "missing start", "", "2026-10-21T09:00:00Z", "false", "", "", "", "", "", "", "", "", "missing" },
        };
        var path = await Convert(Csv([ICalendar.Columns, .. rows]), "csv", "ics");
        var back = await ReadCalendar(await File.ReadAllTextAsync(path, TestContext.Current.CancellationToken));
        Assert.Equal(8, back.Count);
        Assert.EndsWith("@filee", Cell(back, 1, "UID"));
        Assert.Equal("", Cell(back, 2, "End"));
        Assert.Equal("2026-10-21T10:00:00+09:00", Cell(back, 3, "End"));
        Assert.Equal("2026-11-01T01:30:00-05:00", Cell(back, 4, "Start"));
        Assert.Equal("", Cell(back, 5, "Time zone"));
        Assert.Equal("2026-10-21T00:00:00Z", Cell(back, 5, "Start"));
        Assert.Equal("2026-10-21T00:00:00Z", Cell(back, 6, "Start"));
        Assert.Equal("", Cell(back, 7, "EXDATE"));
    }

    [Fact]
    public async Task Fixed_zone_uses_earliest_start_or_todo_end_and_reverts_historical_offsets()
    {
        var row1 = new[] { "todo", "old", "", "2013-01-01T09:00:00+04:00", "false", "Europe/Moscow", "", "", "", "", "", "", "", "old" };
        var row2 = new[] { "event", "new", "2026-01-01T09:00:00+03:00", "", "false", "Europe/Moscow", "", "", "", "", "", "", "", "new" };
        var solo = await File.ReadAllTextAsync(await Convert(Csv(ICalendar.Columns, row1),
            "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Contains("TZOFFSETFROM:+0400\r\nTZOFFSETTO:+0400", solo);
        var oldEvent = (string[])row1.Clone();
        oldEvent[0] = "event";
        oldEvent[2] = oldEvent[3];
        var output = await File.ReadAllTextAsync(await Convert(Csv(ICalendar.Columns, oldEvent, row2),
            "csv", "ics"), TestContext.Current.CancellationToken);
        Assert.Contains("TZOFFSETFROM:+0400\r\nTZOFFSETTO:+0400", output);
        var back = await ReadCalendar(output);
        Assert.EndsWith("+04:00", Cell(back, 2, "Start"));
    }

    [Fact]
    public void Timezone_builder_observes_transition_wall_times_and_validates_rules()
    {
        var utc = new DateTimeOffset(2026, 7, 1, 0, 0, 0, TimeSpan.Zero);
        var newYork = ICalendar.BuildVTimeZone(TimeZoneInfo.FindSystemTimeZoneById("America/New_York"), utc);
        Assert.Contains("BEGIN:DAYLIGHT\r\nDTSTART:20260308T020000\r\nTZOFFSETFROM:-0500\r\nTZOFFSETTO:-0400\r\nRRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU", newYork);
        Assert.Contains("BEGIN:STANDARD\r\nDTSTART:20261101T020000\r\nTZOFFSETFROM:-0400\r\nTZOFFSETTO:-0500\r\nRRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU", newYork);
        var berlin = ICalendar.BuildVTimeZone(TimeZoneInfo.FindSystemTimeZoneById("Europe/Berlin"), utc);
        Assert.Contains("BEGIN:DAYLIGHT\r\nDTSTART:20260329T020000\r\nTZOFFSETFROM:+0100\r\nTZOFFSETTO:+0200\r\nRRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU", berlin);
        Assert.Contains("BEGIN:STANDARD\r\nDTSTART:20261025T030000\r\nTZOFFSETFROM:+0200\r\nTZOFFSETTO:+0100\r\nRRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU", berlin);
        var rules = new[]
        {
            TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(
                new DateTime(2020, 1, 1), new DateTime(2030, 12, 31), TimeSpan.FromHours(1),
                TimeZoneInfo.TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, 2, 0, 0), 3, 21),
                TimeZoneInfo.TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, 3, 0, 0), 9, 21)),
        };
        var custom = TimeZoneInfo.CreateCustomTimeZone("Fixed/Date", TimeSpan.FromHours(1), "Fixed/Date", "Standard", "Daylight", rules);
        var fixedRule = ICalendar.BuildVTimeZone(custom, utc);
        Assert.Contains("BYMONTH=3;BYMONTHDAY=21", fixedRule);
        Assert.Contains("BYMONTH=9;BYMONTHDAY=21", fixedRule);
    }

    [Fact]
    public void Format_registration_and_new_data_donut_include_ics_and_ical()
    {
        Assert.Equal("ics", FormatRegistry.Detect("x.ics")?.Id);
        Assert.Equal("ics", FormatRegistry.Detect("x.ICAL")?.Id);
        var profile = BuiltInData.CreateProfiles().Single(p => p.Id == "data");
        Assert.Contains("ics", profile.Extensions);
        Assert.Contains("ical", profile.Extensions);
    }
}