From 32d050eee9dfbe77e0dfbd2b5a2e9ac19dd75fdb Mon Sep 17 00:00:00 2001 From: Oliver Drobnik Date: Sun, 24 Aug 2025 11:30:18 +0200 Subject: [PATCH] Added unit test for problematic email #43 --- .../ProblematicMessageTests.swift | 120 ++++++++++++++++++ .../Resources/problematic_message_6068.json | 67 ++++++++++ 2 files changed, 187 insertions(+) create mode 100644 Tests/SwiftIMAPTests/ProblematicMessageTests.swift create mode 100644 Tests/SwiftIMAPTests/Resources/problematic_message_6068.json diff --git a/Tests/SwiftIMAPTests/ProblematicMessageTests.swift b/Tests/SwiftIMAPTests/ProblematicMessageTests.swift new file mode 100644 index 0000000..b319257 --- /dev/null +++ b/Tests/SwiftIMAPTests/ProblematicMessageTests.swift @@ -0,0 +1,120 @@ +import Foundation +import Testing +@testable import SwiftMail + +// Add new tag for problematic message tests +extension Tag { + @Tag static var problematic: Self +} + +@Suite("Problematic Message Tests", .tags(.imap, .decoding, .problematic)) +struct ProblematicMessageTests { + + // MARK: - Test Resources + + func getResourceURL(for name: String, withExtension ext: String) -> URL? { + return Bundle.module.url(forResource: name, withExtension: ext, subdirectory: "Resources") + } + + func loadMessageFromJSON(name: String) throws -> Message { + guard let url = getResourceURL(for: name, withExtension: "json") else { + throw TestFailure("Failed to locate resource: \(name).json") + } + + do { + let data = try Data(contentsOf: url) + let decoder = JSONDecoder() + return try decoder.decode(Message.self, from: data) + } catch { + throw TestFailure("Failed to decode message from JSON: \(error)") + } + } + + // MARK: - Problematic Message 6068 Tests + + @Test("Message 6068 text body should be decodable", .tags(.decoding, .problematic)) + func message6068TextBodyShouldBeDecodable() throws { + // Load the problematic message from JSON + let message = try loadMessageFromJSON(name: "problematic_message_6068") + + // Verify the message has the expected UID + #expect(message.uid?.value == 6068) + #expect(message.subject?.contains("Apple") == true) + + // Check that the message has text parts with data + let textParts = message.parts.filter { $0.contentType.lowercased() == "text/plain" } + #expect(textParts.count > 0, "Message should have text/plain parts") + + let textPart = textParts.first! + #expect(textPart.data != nil, "Text part should have data") + #expect(textPart.data!.count > 0, "Text part data should not be empty") + #expect(textPart.encoding == "QUOTED-PRINTABLE", "Text part should be quoted-printable encoded") + + // Test the textBody computed property - this should fail currently + let textBody = message.textBody + #expect(textBody != nil, "textBody should not be nil") + if let textBody = textBody { + #expect(textBody.count > 0, "textBody should not be empty") + #expect(textBody.contains("Hallo Oliver Drobnik"), "textBody should contain expected content") + } + } + + @Test("Message 6068 HTML body should be decodable", .tags(.decoding, .problematic)) + func message6068HtmlBodyShouldBeDecodable() throws { + // Load the problematic message from JSON + let message = try loadMessageFromJSON(name: "problematic_message_6068") + + // Verify the message has the expected UID + #expect(message.uid?.value == 6068) + + // Check that the message has HTML parts with data + let htmlParts = message.parts.filter { $0.contentType.lowercased() == "text/html" } + #expect(htmlParts.count > 0, "Message should have text/html parts") + + let htmlPart = htmlParts.first! + #expect(htmlPart.data != nil, "HTML part should have data") + #expect(htmlPart.data!.count > 0, "HTML part data should not be empty") + #expect(htmlPart.encoding == "QUOTED-PRINTABLE", "HTML part should be quoted-printable encoded") + + // Test the htmlBody computed property - this should fail currently + let htmlBody = message.htmlBody + #expect(htmlBody != nil, "htmlBody should not be nil") + if let htmlBody = htmlBody { + #expect(htmlBody.count > 0, "htmlBody should not be empty") + #expect(htmlBody.contains(""), "htmlBody should contain HTML content") + #expect(htmlBody.contains("Hallo Oliver Drobnik"), "htmlBody should contain expected content") + } + } + + @Test("Message 6068 raw part data should be accessible", .tags(.decoding, .problematic)) + func message6068RawPartDataShouldBeAccessible() throws { + // Load the problematic message from JSON + let message = try loadMessageFromJSON(name: "problematic_message_6068") + + // Test text part raw data + let textParts = message.parts.filter { $0.contentType.lowercased() == "text/plain" } + let textPart = textParts.first! + + // The data should already be decoded from base64 by the JSON decoder + #expect(textPart.data != nil, "Text part should have data") + #expect(textPart.data!.count > 0, "Text part data should not be empty") + + // Test HTML part raw data + let htmlParts = message.parts.filter { $0.contentType.lowercased() == "text/html" } + let htmlPart = htmlParts.first! + + #expect(htmlPart.data != nil, "HTML part should have data") + #expect(htmlPart.data!.count > 0, "HTML part data should not be empty") + + // Try to decode as UTF-8 strings + let rawText = String(data: textPart.data!, encoding: .utf8) + let rawHtml = String(data: htmlPart.data!, encoding: .utf8) + + #expect(rawText != nil, "Raw text should be valid UTF-8") + #expect(rawHtml != nil, "Raw HTML should be valid UTF-8") + + // The raw content should be quoted-printable encoded + #expect(rawText!.contains("=20"), "Raw text should contain quoted-printable encoding") + #expect(rawHtml!.contains("=20"), "Raw HTML should contain quoted-printable encoding") + } +} diff --git a/Tests/SwiftIMAPTests/Resources/problematic_message_6068.json b/Tests/SwiftIMAPTests/Resources/problematic_message_6068.json new file mode 100644 index 0000000..9b4e0ce --- /dev/null +++ b/Tests/SwiftIMAPTests/Resources/problematic_message_6068.json @@ -0,0 +1,67 @@ +{ + "header" : { + "cc" : [ + + ], + "date" : 770012962, + "flags" : [ + "seen", + "$NotJunk", + "NotJunk" + ], + "from" : "\"Apple\" ", + "messageId" : "<1601458699.153043172.1748320162240@email.apple.com>", + "parts" : [ + { + "contentType" : "text\/plain", + "disposition" : "inline", + "encoding" : "QUOTED-PRINTABLE", + "section" : { + "numbers" : [ + 1 + ] + } + }, + { + "contentType" : "text\/html", + "disposition" : "inline", + "encoding" : "QUOTED-PRINTABLE", + "section" : { + "numbers" : [ + 2 + ] + } + } + ], + "sequenceNumber" : 272, + "subject" : "Dein_Apple Account_wurde_verwendet,_um_sich_ über_einen_Webbrowser_bei_iCloud_anzumelden.", + "to" : [ + "oliver@drobnik.com" + ], + "uid" : 6068 + }, + "parts" : [ + { + "contentType" : "text\/plain", + "data" : "SGFsbG8gT2xpdmVyIERyb2JuaWssDQoNCg0KDQogICA9MjANCiAgICAgICA9MjANCiAgICAgICAgICAgPTIwDQogICAgICAgICAgICAgICAgZGVpbiBBcHBsZT1BMEFjY291bnQgKG9saXZlckBkcm9ibmlrLmNvbSkgd3VyZGUgdmVyd2VuZGV0LCA9DQp1bSBzaWNoIGF1ZiBlaW5lbiBXZWJicm93c2VyIGJlaSBpQ2xvdWQgYW56dW1lbGRlbi4NCiAgICAgICAgICAgPTIwDQogICAgICAgPTIwDQogICA9MjANCg0KDQoNCiAgICBEYXR1bSB1bmQgWmVpdDogMjYuPUEwTWFpPUEwMjAyNSwgMjE6Mjg9QTBVaHI9QTBQRFQNCg0KDQoNCg0KICAgPTIwDQoNCg0KDQogICAgV2VubiBkaXIgZGllIG9iZW4gYXVmZ2VmPUZDaHJ0ZW4gSW5mb3JtYXRpb25lbiBiZWthbm50IHZvcmtvbW1lbiwga2FubnM9DQp0IGR1IGRpZXNlIE5hY2hyaWNodCBpZ25vcmllcmVuLg0KDQoNCg0KICAgPTIwDQogICAgICAgIEZhbGxzIGR1IGRpY2ggbmljaHQgdm9yIEt1cnplbSBiZWkgaUNsb3VkIGFuZ2VtZWxkZXQgaGFzdCB1bmQgZGVyIE09DQplaW51bmcgYmlzdCwgZGFzcyBqZW1hbmQgYW5kZXJlcyB2ZXJzdWNodCBoYXQsIGF1ZiBkZWluZW4gQWNjb3VudCB6dXp1Z3JlaWY9DQplbiwgc29sbHRlc3QgZHUgZGVpbiBQYXNzd29ydCBzbyBzY2huZWxsIHdpZSBtPUY2Z2xpY2ggdW50ZXIgaHR0cHM6Ly9hY2NvdW49DQp0LmFwcGxlLmNvbSA9RTRuZGVybi4NCiAgID0yMA0KDQoNCg0KTWl0IGZyZXVuZGxpY2hlbiBHcj1GQz1ERmVuDQpBcHBsZT1BMFN1cHBvcnQNCg0KDQpBcHBsZT1BMEFjY291bnQ6IGh0dHBzOi8vYWNjb3VudC5hcHBsZS5jb20vIyEmcGFnZT0zRHNpZ25pbg0KU3VwcG9ydDogaHR0cHM6Ly9zdXBwb3J0LmFwcGxlLmNvbS9kZS1kZQ0KRGF0ZW5zY2h1dHo6IGh0dHBzOi8vd3d3LmFwcGxlLmNvbS9sZWdhbC9wcml2YWN5L2RlLw0KQ29weXJpZ2h0IDIwMjUgQXBwbGUgRGlzdHJpYnV0aW9uIEludGVybmF0aW9uYWwgTHRkLiBIb2xseWhpbGwgSW5kdXN0cmlhbCBFPQ0Kc3RhdGUsIEhvbGx5aGlsbCwgQ29yaywgSXJlbGFuZC4NCkFsbGUgUmVjaHRlIHZvcmJlaGFsdGVuLg==", + "disposition" : "inline", + "encoding" : "QUOTED-PRINTABLE", + "section" : { + "numbers" : [ + 1 + ] + } + }, + { + "contentType" : "text\/html", + "data" : "<html>
 <head>=20
  <meta http-equiv=3D"content-type" content=3D"text/html; charset=3DUTF-8">=
=20
  <meta name=3D"viewport" content=3D"width=3Ddevice-width, initial-scale=3D=
1">=20
  <style type=3D"text/css">
    table.footer-table {
        width: 100%;
        font-size: inherit;
        line-height: 18px;
        text-align: center;
    }

    table.footer-table .footer-background {
        width: 685px;
        font-size: 11px;
        line-height: 22px;
        color: #888;
        text-align: center;
        background-repeat: no-repeat;
        background-position: center top;
        padding: 15px 0 7px;
        background-image: url(https://statici.icloud.com/emailimages/v4/com=
mon/footer_gradient_web.png);
    }
   =20
   .grey-footer-background {
        width: 685px;
        font-size: 11px;
        line-height: 22px;
        color: #888;
        text-align: center;
        background-repeat: no-repeat;
        background-position: center top;
        padding: 29px 0 7px;
        overflow: hidden;
        background: #f5f5f5 no-repeat;
    }

    table.footer-table .icloud-logo {
        display: inline-block;
    }

    table.footer-table .footer-cell {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        font-size: 12px;
        line-height: 15px;
        color: #666;
        text-align: center;
        padding: 0 18px 18px 18px;
    }

    table.footer-table .nobr {
        white-space: nowrap;
    }

    table.footer-table .footer-cell a {
        color: #0070c9;
        text-decoration: none;
    }

    footer-color {
        color: #666 !important;
    }

    table.footer-table .footer-cell a.apple-address {
        color: #666;
        white-space: nowrap;
        text-decoration: none;
    }

    table.footer-table1 {
        width: 100%;
        font-size: inherit;
        background-color: #f2f2f2;
        margin-top: auto;
    }

    table.footer-table1 .nobr {
        white-space: nowrap;
    }

    table.footer-table1 .footer-background1 {
        font-size: 11px;
        line-height: 22px;
        color: #888;
        background-image: url(https://statici.icloud.com/emailimages/v4/com=
mon/footer_gradient_web.png);
    }

    table.footer-table1 .footer-cell1 {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        font-size: 12px;
        line-height: 18px;
       =20
            padding: 20px 36px 1px 40px;
            margin-left:10px;
       =20
    }

        table.footer-table1 .footer-cell1-smallsize {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        font-size: 11px;
        line-height: 18px;
        color: #666 !important;
       =20
            padding: 20px 36px 1px 40px;
            margin-left:10px;
       =20
    }

    table.footer-table1 .footer-cell2 {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        font-size: 12px;
        line-height: 18px;
        color: #666;
       =20
            padding: 1px 36px 20px 40px;
            margin-left:10px;
       =20
    }

    table.footer-table1 .footer-cell1 a {
        color: #555;
        text-decoration: none;
    }

    table.footer-table1 .footer-cell2 a.apple-address {
        color: #666;
        white-space: nowrap;
        text-decoration: none;
    }

    table.footer-table .footer-link {
        color: #555;
        text-decoration: none;
    }
    table.footer-table .footer-text{
        color: #888;
        text-decoration: none;
    }
    table.footer-table .footer-text a{
        color: #888;
        text-decoration: none;
    }

</style>=20
  <style type=3D"text/css">

    body {
        padding: 0;
        margin: 0;
    }

    body * {
        margin: 0;
    }

    img {
        border: 0;
    }

    hr.horizontal-divider {
        height: 1px;
        background-color: #f6f6f6;
        border: 0;
    }

    a {
        color: #0070c9;
        text-decoration: none;
    }

    a.big-button {
        color: #0070c9;
        text-decoration: none;
        display: inline-block;
        text-align: center;
        height: 43px;
        line-height: 43px;
        font-size: 17px;
        padding: 0;
    }

    a.big-button > table {
        text-align: center;
        background-color: rgb(70,162,255);
        font-size: inherit;
        line-height: inherit;
        padding: 0;
        border: 0;
    }

    a.big-button > table td.btn-padding {
        width: 18px;
        font-family: inherit;
        font-size: inherit;
        line-height: inherit;
        background-size: 18px 43px !important;
        background-repeat: no-repeat;
        background-color: rgb(70,162,255);
    }

    a.big-button > table td.btn-left {
        background-image: url(https://statici.icloud.com/emailimages/v4/fam=
ilysharing/button_left.png);
    }

    a.big-button > table td.btn-right {
        background-image: url(https://statici.icloud.com/emailimages/v4/fam=
ilysharing/button_right.png);
    }

    a.big-button > table td.btn-middle {
        min-width: 60px;
        text-align: center;
        background: url('https://statici.icloud.com/emailimages/v4/familysh=
aring/button_middle.png') repeat-x;
        background-position:left bottom !important;
        background-color: rgb(70,162,255);
        zoom: 1;
        font-family: inherit;
        line-height: inherit;
        font-size: inherit;
    }

    a.big-button > table td.btn-middle > a {
        color: #ffffff;
        text-decoration: none;
    }

    body, td, p, ul, ol {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        font-size: 13px;
        -webkit-font-smoothing: antialiased;
        line-height: 18px;
        color: #333333;
    }

    table {
        border-spacing: 0;
        border-collapse: collapse;
        border: 0;
    }

    table td {
        padding: 0;
    }

    table td.align-left {
        text-align: left;
    }

    table td.align-center {
        text-align: center;
    }

    table td.align-right {
        text-align: right;
    }

    h1 {
        font-size: 19px;
        line-height: 22px;
        color: #333333;
        font-weight: bold;
    }

    h2 {
        font-size: 16px;
        line-height: 18px;
        color: #333333;
        font-weight: bold;
    }

    .hr {
        height:1px;
        background-color:#ccc;
    }

    .mail-wrapper {
        background-color: #ffffff;
    }

    table.list-items {
       =20
        table-layout: fixed;
        line-height: inherit;
        font-size: inherit;
    }

    table.list-items .list-item-prefix {
        padding-right: 4px;
        text-align: left;
        vertical-align: top;
    }

    table.list-items .list-item {
        text-align: left;
        vertical-align: top;
    }

    .show-on-mobile {
        display: none;
        mso-hide: all; /* Outlook */
        max-height: 0; /* Gmail */
        overflow: hidden; /* Gmail */
    }

    @media (max-width: 414px) {
        .show-on-mobile {
            display: table !important;
            mso-hide: none !important; /* Outlook */
            max-height: none !important; /* Gmail */
        }
        .hide-on-mobile {
            display: none !important;
            mso-hide: all !important;
            max-height: 0 !important;
            overflow: hidden;
        }
    }

</style>=20
  <style type=3D"text/css">
    .main-table-1 {
        width: 685px;
        padding: 0px 20px;
    }

    .main-table-2 {
        width: 685px;
       =20
            padding: 0px 36px 0px 40px;
       =20
    }

    .content-table-1 {
        margin: 0 auto;
        text-align: center;
    }

    .content-table-2 {
        margin: 0 auto;
       =20
            text-align: left;
       =20
    }

    .header-1 {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        -webkit-font-smoothing: antialiased;
        color: #333;
        font-smooth: always;
        font-size: 34px;
        line-height: 37px;
        text-align: center;
       =20
    }

    .text-1 {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        -webkit-font-smoothing: antialiased;
        color: #333;
        font-smooth: always;
        font-size: 17px;
        line-height: 26px;
        text-align: center;
       =20
    }

    .button-text {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        -webkit-font-smoothing: antialiased;
        color: #333;
        font-smooth: always;
        font-size: 17px;
        line-height: 26px;
        text-align: center;
       =20
    }

    .padding-1{
        padding-top: 16px;
    }

    .padding-2{
        padding-bottom: 14px;
    }

    .padding-3{
        padding-bottom: 16px;
    }

    .padding-4{
        padding-top: 24px;
    }

    .padding-5{
        padding-bottom: 26px;
    }

    .padding-6{
        padding-bottom: 30px;
    }

    .padding-7{
        padding-bottom: 12px;
    }

    .padding-8{
        padding-top: 38px;
    }
   =20
    .padding-9{
        padding-top: 32px;
    }


    @media screen and (max-width: 750px) {
        .content-table-1 {
            padding: 0px 20px;
            text-align: center;
        }

        .content-table-2 {
            padding: 0px 20px;
          =20
        }
    }

</style>=20
  <style type=3D"text/css">
    .mail-wrapper {
        text-align: center;
    }
    .account-content-sf {
        font-family: system-ui, -apple-system, BlinkMacSystemFont, Segoe UI=
, Helvetica Neue, Helvetica, Arial, sans-serif;
        color: #333;
        font-smooth: always;
        font-size: 17px;
        line-height: 1.3;
       =20
                text-align: left;
       =20
    }

    .account-logo-box {
       =20
            text-align: right;
            float:right;
            margin-right:10px;
       =20
    }
   =20
    .account-link-1 {
        color: #2b2b2b;=20
        text-decoration: none;
        font-weight: 600;
    }
    a:visited.account-link-1 { color: #08c !important; text-decoration: non=
e !important; }
    a:hover.account-link-1 { text-decoration: underline !important; }
    a:active.account-link-1 { text-decoration: underline !important; }

    .account-link-2 {
        color: #333;
        text-decoration: none;
    }
    a:visited.account-link-2 { color: #08c !important; text-decoration: non=
e !important; }
    a:hover.account-link-2 { text-decoration: underline !important; }
    a:active.account-link-2 { text-decoration: underline !important; }
    .account-link-3 {
        color: #333;
        text-decoration: none;
    }

    td.space {
        width: 15px;
    }

    td.icon {
        padding-top: 15px;
        width: 56px;
    }

    table.center-table {
        margin: auto;
    }

    p.icon-heading {
        color: #333;
        font-size: 15px;=20
        font-weight: 700;
        line-height: 20px;
        margin-bottom: 5px;
        margin-top: 0px;
        padding-top: 15px;
        text-align: left;
    }

    p.icon-subheading {
        color: #838383;
        font-size: 15px;=20
        line-height: 20px;
        margin-top: 5px;
        text-align: left;
    }

    td.align-center {
        text-align: center;
    }

    td.header-1 {
        color: #333;
        font-size: 34px;
        font-weight: 700;
        line-height: 1.1;
        padding: 20px 20px 15px 20px;
        text-align: center;
    }

    table.header-content {
        text-align: center;
        font-size: 45px;
        line-height: 48px;
        padding-top: 30px;
        font-family: inherit;
    }

    a.blue-button {
        background-color:#265bb0;
        border-radius:8px;
        color:#ffffff;
        display:inline-block;
        font-family: Helvetica Neue, Helvetica, sans-serif !important;
        font-size:17px;
        line-height:40px;
        text-align:center;
        text-decoration:none;
        width:150px;
        -webkit-text-size-adjust:none;
    }

</style>=20
 </head>=20
 <body style=3D"padding:0;margin:0;color:rgb(51, 51, 51);font-size:13px;fon=
t-family:system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica =
Neue, Helvetica, Arial, sans-serif;line-height:18px;-webkit-font-smoothing:=
antialiased;">=20
  <div class=3D"mail-wrapper" style=3D"background-color:rgb(255, 255, 255);=
margin:0;text-align:center;">=20
   <table style=3D"border:0;margin:0;border-spacing:0;table-layout:auto;wid=
th:100%;border-collapse:collapse;">=20
   </table>
   <table style=3D"border:0;margin:0 auto;border-spacing:0;border-collapse:=
collapse;" align=3D"center">=20
    <tbody style=3D"margin:0;">
     <tr style=3D"margin:0;">
      <td class=3D"main-table-2" align=3D"center" style=3D"padding:0px 36px=
 0px 40px;margin:0;color:rgb(51, 51, 51);width:685px;font-size:13px;font-fa=
mily:system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue=
, Helvetica, Arial, sans-serif;line-height:18px;-webkit-font-smoothing:anti=
aliased;">=20
       <table class=3D"content-table-2" style=3D"border:0;margin:0 auto;bor=
der-spacing:0;border-collapse:collapse;text-align:left;">=20
        <tbody style=3D"margin:0;">
         <tr style=3D"margin:0;">
          <td class=3D"account-logo-box padding-9 padding-6" style=3D"paddi=
ng:0;padding-top:32px;margin:0;color:rgb(51, 51, 51);font-size:13px;padding=
-bottom:30px;font-family:system-ui, -apple-system, BlinkMacSystemFont, Sego=
e UI, Helvetica Neue, Helvetica, Arial, sans-serif;line-height:18px;float:r=
ight;-webkit-font-smoothing:antialiased;text-align:right;margin-right:10px;=
"> <img src=3D"https://statici.icloud.com/emailimages/v4/common/apple_logo_=
web@2x.png" width=3D"22px" height=3D"26px" style=3D"border:0;margin:0;"> </=
td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Hallo Oliver Drobnik, </td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> dein Apple=A0Account (<a href=3D"ma=
ilto:oliver@drobnik.com" class=3D"account-link-1" style=3D"margin:0;color:r=
gb(43, 43, 43);font-weight:600;text-decoration:none;">oliver@drobnik.com</a=
>) wurde verwendet, um sich auf einen Webbrowser bei iCloud anzumelden. </t=
d>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Datum und Zeit: 26.=A0Mai=A02025, 2=
1:28=A0Uhr=A0PDT<br style=3D"margin:0;"> </td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Wenn dir die oben aufgef=FChrten In=
formationen bekannt vorkommen, kannst du diese Nachricht ignorieren. </td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Falls du dich nicht vor Kurzem bei =
iCloud angemeldet hast und der Meinung bist, dass jemand anderes versucht h=
at, auf deinen Account zuzugreifen, solltest du dein Passwort so schnell wi=
e m=F6glich unter <a class=3D"account-link-2" href=3D"https://account.apple=
.com" style=3D"margin:0;color:rgb(51, 51, 51);text-decoration:none;">https:=
//account.apple.com</a> =E4ndern. </td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-7" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:12px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Mit freundlichen Gr=FC=DFen </td>
         </tr>=20
         <tr style=3D"margin:0;">
          <td class=3D"account-content-sf padding-5" style=3D"padding:0;mar=
gin:0;color:rgb(51, 51, 51);font-size:17px;padding-bottom:26px;font-family:=
system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Hel=
vetica, Arial, sans-serif;line-height:1.3;font-smooth:always;-webkit-font-s=
moothing:antialiased;text-align:left;"> Apple=A0Support </td>
         </tr>=20
        </tbody>
       </table> </td>
     </tr>=20
     <tr style=3D"margin:0;">
      <td style=3D"padding:0;margin:0;color:rgb(51, 51, 51);width:100%;font=
-size:13px;font-family:system-ui, -apple-system, BlinkMacSystemFont, Segoe =
UI, Helvetica Neue, Helvetica, Arial, sans-serif;line-height:18px;-webkit-f=
ont-smoothing:antialiased;" align=3D"center">=20
       <table class=3D"footer-table" style=3D"border:0;margin:0;border-spac=
ing:0;width:100%;font-size:inherit;line-height:18px;border-collapse:collaps=
e;text-align:center;">=20
        <tbody style=3D"margin:0;">
         <tr style=3D"margin:0;">
          <td class=3D"footer-cell" style=3D"padding:0 18px 18px 18px;margi=
n:0;color:rgb(102, 102, 102);font-size:12px;font-family:system-ui, -apple-s=
ystem, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Helvetica, Arial, sans=
-serif;line-height:15px;-webkit-font-smoothing:antialiased;text-align:cente=
r;">=20
           <table class=3D"footer-table" style=3D"border:0;margin:0;border-=
spacing:0;width:100%;font-size:inherit;line-height:18px;border-collapse:col=
lapse;text-align:center;">=20
            <tbody style=3D"margin:0;">
             <tr style=3D"margin:0;">
              <td class=3D"footer-background" style=3D"padding:15px 0 7px;b=
ackground-repeat:no-repeat;margin:0;color:rgb(136, 136, 136);width:685px;fo=
nt-size:11px;line-height:22px;font-family:system-ui, -apple-system, BlinkMa=
cSystemFont, Segoe UI, Helvetica Neue, Helvetica, Arial, sans-serif;backgro=
und-position:center top;background-image:url(https://statici.icloud.com/ema=
ilimages/v4/common/footer_gradient_web.png);-webkit-font-smoothing:antialia=
sed;text-align:center;"></td>
             </tr>=20
             <tr style=3D"margin:0;">
              <td class=3D"footer-cell text-padding" style=3D"padding:0 18p=
x 18px 18px;margin:0;color:rgb(102, 102, 102);font-size:12px;font-family:sy=
stem-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica Neue, Helve=
tica, Arial, sans-serif;line-height:15px;-webkit-font-smoothing:antialiased=
;text-align:center;"> <a class=3D"nobr" href=3D"https://account.apple.com/#=
!&page=3Dsignin" style=3D"margin:0;color:rgb(0, 112, 201);white-space:nowra=
p;text-decoration:none;"> Apple=A0Account </a> | <a class=3D"nobr" href=3D"=
https://support.apple.com/de-de" style=3D"margin:0;color:rgb(0, 112, 201);w=
hite-space:nowrap;text-decoration:none;"> Support </a> | <a class=3D"nobr" =
href=3D"https://www.apple.com/legal/privacy/de/" style=3D"margin:0;color:rg=
b(0, 112, 201);white-space:nowrap;text-decoration:none;"> Datenschutz </a> =
<br style=3D"margin:0;"> <span class=3D"nobr" style=3D"margin:0;white-space=
:nowrap;">Copyright =A9 2025</span> Apple Distribution International Ltd. <=
a class=3D"apple-address" href=3D"#address" style=3D"margin:0;color:rgb(102=
, 102, 102);white-space:nowrap;text-decoration:none;">Hollyhill Industrial =
Estate, Hollyhill, Cork, Ireland.</a> <span class=3D"nobr" style=3D"margin:=
0;white-space:nowrap;">Alle Rechte vorbehalten.</span> </td>
             </tr>=20
            </tbody>
           </table> </td>
         </tr>=20
        </tbody>
       </table> </td>
     </tr>=20
    </tbody>
   </table> =20
  </div> =20
 </body>
</html>", + "disposition" : "inline", + "encoding" : "QUOTED-PRINTABLE", + "section" : { + "numbers" : [ + 2 + ] + } + } + ] +} \ No newline at end of file