// Create a resolver using Cloudflare DNS
        let resolver = Resolver::new_cloudflare_tls().unwrap();

        // Parse message
        let authenticated_message = AuthenticatedMessage::parse(RFC5322_MESSAGE.as_bytes()).unwrap();

        // Validate signature
        let result = resolver.verify_dkim(&authenticated_message).await;

        // Make sure all signatures passed verification
        assert!(result.iter().all(|s| s.result() == &DKIMResult::Pass));

        // Sign an e-mail message using RSA-SHA256
        let pk_rsa = PrivateKey::from_rsa_pkcs1_pem(RSA_PRIVATE_KEY).unwrap();
        let signature_rsa = Signature::new()
            .headers(["From", "To", "Subject"])
            .domain("example.com")
            .selector("default")
            .sign(RFC5322_MESSAGE.as_bytes(), &pk_rsa)
            .unwrap();

        // Sign an e-mail message using ED25519-SHA256
        let pk_ed = PrivateKey::from_ed25519(
            &base64_decode(ED25519_PUBLIC_KEY.as_bytes()).unwrap(),
            &base64_decode(ED25519_PRIVATE_KEY.as_bytes()).unwrap(),
        )
        .unwrap();
        let signature_ed = Signature::new()
            .headers(["From", "To", "Subject"])
            .domain("example.com")
            .selector("default-ed")
            .sign(RFC5322_MESSAGE.as_bytes(), &pk_ed)
            .unwrap();

        // Print the message including both signatures to stdout
        println!(
            "{}{}{}",
            signature_rsa.to_header(),
            signature_ed.to_header(),
            RFC5322_MESSAGE
        );

        // Create a resolver using Cloudflare DNS
        let resolver = Resolver::new_cloudflare_tls().unwrap();

        // Parse message
        let authenticated_message = AuthenticatedMessage::parse(RFC5322_MESSAGE.as_bytes()).unwrap();

        // Validate ARC chain
        let result = resolver.verify_arc(&authenticated_message).await;

        // Make sure ARC passed verification
        assert_eq!(result.result(), &DKIMResult::Pass);

        // Create a resolver using Cloudflare DNS
        let resolver = Resolver::new_cloudflare_tls().unwrap();

        // Parse message to be sealed
        let authenticated_message = AuthenticatedMessage::parse(RFC5322_MESSAGE.as_bytes()).unwrap();

        // Verify ARC and DKIM signatures
        let arc_result = resolver.verify_arc(&authenticated_message).await;
        let dkim_result = resolver.verify_dkim(&authenticated_message).await;

        // Build Authenticated-Results header
        let auth_results = AuthenticationResults::new("mx.mydomain.org")
            .with_dkim_result(&dkim_result, "[email protected]")
            .with_arc_result(&arc_result, "127.0.0.1".parse().unwrap());

        // Seal message
        if arc_result.can_be_sealed() {
            // Seal the e-mail message using RSA-SHA256
            let pk_rsa = PrivateKey::from_rsa_pkcs1_pem(RSA_PRIVATE_KEY).unwrap();
            let arc_set = ARC::new(&auth_results)
                .domain("example.org")
                .selector("default")
                .headers(["From", "To", "Subject", "DKIM-Signature"])
                .seal(&authenticated_message, &arc_result, &pk_rsa)
                .unwrap();

            // Print the sealed message to stdout
            println!("{}{}", arc_set.to_header(), RFC5322_MESSAGE)
        } else {
            eprintln!("The message could not be sealed, probably an ARC chain with cv=fail was found.")
        }

        // Create a resolver using Cloudflare DNS
        let resolver = Resolver::new_cloudflare_tls().unwrap();

        // Verify HELO identity
        let result = resolver
            .verify_spf_helo("127.0.0.1".parse().unwrap(), "gmail.com")
            .await;
        assert_eq!(result.result(), SPFResult::Fail);

        // Verify MAIL-FROM identity
        let result = resolver
            .verify_spf_sender("::1".parse().unwrap(), "gmail.com", "[email protected]")
            .await;
        assert_eq!(result.result(), SPFResult::Fail);

        // Create a resolver using Cloudflare DNS
        let resolver = Resolver::new_cloudflare_tls().unwrap();

        // Verify DKIM signatures
        let authenticated_message = AuthenticatedMessage::parse(RFC5322_MESSAGE.as_bytes()).unwrap();
        let dkim_result = resolver.verify_dkim(&authenticated_message).await;

        // Verify SPF MAIL-FROM identity
        let spf_result = resolver
            .verify_spf_sender("::1".parse().unwrap(), "example.org", "[email protected]")
            .await;

        // Verify DMARC
        let dmarc_result = resolver
            .verify_dmarc(
                &authenticated_message,
                &dkim_result,
                "example.org",
                &spf_result,
            )
            .await;
        assert_eq!(dmarc_result.dkim_result(), &DMARCResult::Pass);
        assert_eq!(dmarc_result.spf_result(), &DMARCResult::Pass);

    use sieve::{runtime::RuntimeError, Action, Compiler, Event, Input, Runtime};
    
        let text_script = br#"
        require ["fileinto", "body", "imap4flags"];
        
        if body :contains "tps" {
            setflag "$tps_reports";
        }
    
        if header :matches "List-ID" "*<*@*" {
            fileinto "INBOX.lists.${2}"; stop;
        }
        "#;
    
        // Compile
        let compiler = Compiler::new();
        let script = compiler.compile(text_script).unwrap();
    
        // Build runtime
        let runtime = Runtime::new();
    
        // Create filter instance
        let mut instance = runtime.filter(
            br#"From: Sales Mailing List <[email protected]>
    To: John Doe <[email protected]>
    List-ID: <[email protected]>
    Subject: TPS Reports
    
    We're putting new coversheets on all the TPS reports before they go out now.
    So if you could go ahead and try to remember to do that from now on, that'd be great. All right! 
    "#,
        );
        let mut input = Input::script("my-script", script);
    
        // Start event loop
        while let Some(result) = instance.run(input) {
            match result {
                Ok(event) => match event {
                    Event::IncludeScript { name, optional } => {
                        // NOTE: Just for demonstration purposes, script name needs to be validated first.
                        if let Ok(bytes) = std::fs::read(name.as_str()) {
                            let script = compiler.compile(&bytes).unwrap();
                            input = Input::script(name, script);
                        } else if optional {
                            input = Input::False;
                        } else {
                            panic!("Script {} not found.", name);
                        }
                    }
                    Event::MailboxExists { .. } => {
                        // Return true if the mailbox exists
                        input = false.into();
                    }
                    Event::ListContains { .. } => {
                        // Return true if the list(s) contains an entry
                        input = false.into();
                    }
                    Event::DuplicateId { .. } => {
                        // Return true if the ID is duplicate
                        input = false.into();
                    }
                    Event::Execute { command, arguments } => {
                        println!(
                            "Script executed command {:?} with parameters {:?}",
                            command, arguments
                        );
                        input = false.into(); // Report whether the script succeeded
                    }
                    #[cfg(test)]
                    _ => unreachable!(),
                },
                Err(error) => {
                    match error {
                        RuntimeError::IllegalAction => {
                            eprintln!("Script tried allocating more variables than allowed.");
                        }
                        RuntimeError::TooManyIncludes => {
                            eprintln!("Too many included scripts.");
                        }
                        RuntimeError::InvalidInstruction(instruction) => {
                            eprintln!(
                                "Invalid instruction {:?} found at {}:{}.",
                                instruction.name(),
                                instruction.line_num(),
                                instruction.line_pos()
                            );
                        }
                        RuntimeError::ScriptErrorMessage(message) => {
                            eprintln!("Script called the 'error' function with {:?}", message);
                        }
                        RuntimeError::CapabilityNotAllowed(capability) => {
                            eprintln!(
                                "Capability {:?} has been disabled by the administrator.",
                                capability
                            );
                        }
                        RuntimeError::CapabilityNotSupported(capability) => {
                            eprintln!("Capability {:?} not supported.", capability);
                        }
                        RuntimeError::OutOfMemory => {
                            eprintln!("Script exceeded the configured memory limit.");
                        }
                        RuntimeError::CPULimitReached => {
                            eprintln!("Script exceeded the configured CPU limit.");
                        }
                    }
                    break;
                }
            }
        }
    
        // Process actions
        for action in instance.get_actions() {
            match action {
                Action::Keep { flags, message_id } => {
                    println!(
                        "Keep message '{}' with flags {:?}.",
                        std::str::from_utf8(instance.get_message(*message_id).unwrap()).unwrap(),
                        flags
                    );
                }
                Action::Discard => {
                    println!("Discard message.")
                }
                Action::Reject { reason } => {
                    println!("Reject message with reason {:?}.", reason);
                }
                Action::Ereject { reason } => {
                    println!("Ereject message with reason {:?}.", reason);
                }
                Action::FileInto {
                    folder,
                    flags,
                    message_id,
                    ..
                } => {
                    println!(
                        "File message '{}' in folder {:?} with flags {:?}.",
                        std::str::from_utf8(instance.get_message(*message_id).unwrap()).unwrap(),
                        folder,
                        flags
                    );
                }
                Action::SendMessage {
                    recipient,
                    message_id,
                    ..
                } => {
                    println!(
                        "Send message '{}' to {:?}.",
                        std::str::from_utf8(instance.get_message(*message_id).unwrap()).unwrap(),
                        recipient
                    );
                }
                Action::Notify {
                    message, method, ..
                } => {
                    println!("Notify URI {:?} with message {:?}", method, message);
                }
            }
        }

        // Build a simple multipart message
        let message = MessageBuilder::new()
            .from(("John Doe", "[email protected]"))
            .to(vec![
                ("Jane Doe", "[email protected]"),
                ("James Smith", "[email protected]"),
            ])
            .subject("Hi!")
            .html_body("<h1>Hello, world!</h1>")
            .text_body("Hello world!");
    
        // Connect to an SMTP relay server over TLS and
        // authenticate using the provided credentials.
        Transport::new("smtp.gmail.com")
            .credentials("john", "p4ssw0rd")
            .connect_tls()
            .await
            .unwrap()
            .send(message)
            .await
            .unwrap();

    // Build a simple text message with a single attachment
        let message = MessageBuilder::new()
            .from(("John Doe", "[email protected]"))
            .to("[email protected]")
            .subject("Howdy!")
            .text_body("These pretzels are making me thirsty.")
            .binary_attachment("image/png", "pretzels.png", [1, 2, 3, 4].as_ref());
    
        // Set up DKIM signer
        let dkim = DKIM::from_pkcs1_pem_file("./cert.pem")
            .unwrap()
            .domain("example.com")
            .selector("2022")
            .headers(["From", "To", "Subject"]) // Headers to sign
            .expiration(60 * 60 * 7); // Number of seconds before this signature expires (optional)
    
        // Connect to an SMTP relay server over TLS.
        // Signs each message with the configured DKIM signer.
        Transport::new("smtp.example.com")
            .dkim(dkim)
            .connect_tls()
            .await
            .unwrap()
            .send(message)
            .await
            .unwrap();

        // Build a simple text message with a single attachment
        let mut message = MessageBuilder::new();
        message.from(("John Doe", "[email protected]"));
        message.to("[email protected]");
        message.subject("Hello, world!");
        message.text_body("Message contents go here.");
        message.binary_attachment("image/png", "image.png", &[1, 2, 3, 4]);

        // Write message to memory
        let mut output = Vec::new();
        message.write_to(&mut output).unwrap();

        // Build a multipart message with text and HTML bodies,
        // inline parts and attachments.
        let mut message = MessageBuilder::new();
        message.from(("John Doe", "[email protected]"));

        // To recipients
        message.to(vec![
            ("Antoine de Saint-Exupéry", "[email protected]"),
            ("안녕하세요 세계", "[email protected]"),
            ("Xin chào", "[email protected]"),
        ]);

        // BCC recipients using grouped addresses
        message.bcc(vec![
            (
                "My Group",
                vec![
                    ("ASCII name", "[email protected]"),
                    ("ハロー・ワールド", "[email protected]"),
                    ("áéíóú", "[email protected]"),
                    ("Γειά σου Κόσμε", "[email protected]"),
                ],
            ),
            (
                "Another Group",
                vec![
                    ("שלום עולם", "[email protected]"),
                    ("ñandú come ñoquis", "[email protected]"),
                    ("Recipient", "[email protected]"),
                ],
            ),
        ]);

        // Set RFC and custom headers
        message.subject("Testing multipart messages");
        message.in_reply_to(vec!["message-id-1", "message-id-2"]);
        message.header("List-Archive", URL::new("http://example.com/archive"));

        // Set HTML and plain text bodies
        message.text_body("This is the text body!\n");
        message.html_body("<p>HTML body with <img src=\"cid:my-image\"/>!</p>");

        // Include an embedded image as an inline part
        message.binary_inline("image/png", "cid:my-image", &[0, 1, 2, 3, 4, 5]);

        // Add a text and a binary attachment
        message.text_attachment("text/plain", "my fíle.txt", "Attachment contents go here.");
        message.binary_attachment(
            "text/plain",
            "ハロー・ワールド",
            b"Binary contents go here.",
        );

        // Write the message to a file
        message
            .write_to(File::create("message.eml").unwrap())
            .unwrap();

    // Build a nested multipart message
        let mut message = MessageBuilder::new();

        message.from(Address::new_address("John Doe".into(), "[email protected]"));
        message.to(Address::new_address("Jane Doe".into(), "[email protected]"));
        message.subject("Nested multipart message");

        // Define the nested MIME body structure
        message.body(MimePart::new_multipart(
            "multipart/mixed",
            vec![
                MimePart::new_text("Part A contents go here...").inline(),
                MimePart::new_multipart(
                    "multipart/mixed",
                    vec![
                        MimePart::new_multipart(
                            "multipart/alternative",
                            vec![
                                MimePart::new_multipart(
                                    "multipart/mixed",
                                    vec![
                                        MimePart::new_text("Part B contents go here...").inline(),
                                        MimePart::new_binary(
                                            "image/jpeg",
                                            "Part C contents go here...".as_bytes(),
                                        )
                                        .inline(),
                                        MimePart::new_text("Part D contents go here...").inline(),
                                    ],
                                ),
                                MimePart::new_multipart(
                                    "multipart/related",
                                    vec![
                                        MimePart::new_html("Part E contents go here...").inline(),
                                        MimePart::new_binary(
                                            "image/jpeg",
                                            "Part F contents go here...".as_bytes(),
                                        ),
                                    ],
                                ),
                            ],
                        ),
                        MimePart::new_binary("image/jpeg", "Part G contents go here...".as_bytes())
                            .attachment("image_G.jpg"),
                        MimePart::new_binary(
                            "application/x-excel",
                            "Part H contents go here...".as_bytes(),
                        ),
                        MimePart::new_binary(
                            "x-message/rfc822",
                            "Part J contents go here...".as_bytes(),
                        ),
                    ],
                ),
                MimePart::new_text("Part K contents go here...").inline(),
            ],
        ));

        // Write the message to a file
        message
            .write_to(File::create("nested-message.eml").unwrap())
            .unwrap();

    let input = concat!(
            "From: Art Vandelay <[email protected]> (Vandelay Industries)\n",
            "To: \"Colleagues\": \"James Smythe\" <[email protected]>; Friends:\n",
            "    [email protected], =?UTF-8?Q?John_Sm=C3=AEth?= <[email protected]>;\n",
            "Date: Sat, 20 Nov 2021 14:22:01 -0800\n",
            "Subject: Why not both importing AND exporting? =?utf-8?b?4pi6?=\n",
            "Content-Type: multipart/mixed; boundary=\"festivus\";\n\n",
            "--festivus\n",
            "Content-Type: text/html; charset=\"us-ascii\"\n",
            "Content-Transfer-Encoding: base64\n\n",
            "PGh0bWw+PHA+SSB3YXMgdGhpbmtpbmcgYWJvdXQgcXVpdHRpbmcgdGhlICZsZHF1bztle\n",
            "HBvcnRpbmcmcmRxdW87IHRvIGZvY3VzIGp1c3Qgb24gdGhlICZsZHF1bztpbXBvcnRpbm\n",
            "cmcmRxdW87LDwvcD48cD5idXQgdGhlbiBJIHRob3VnaHQsIHdoeSBub3QgZG8gYm90aD8\n",
            "gJiN4MjYzQTs8L3A+PC9odG1sPg==\n",
            "--festivus\n",
            "Content-Type: message/rfc822\n\n",
            "From: \"Cosmo Kramer\" <[email protected]>\n",
            "Subject: Exporting my book about coffee tables\n",
            "Content-Type: multipart/mixed; boundary=\"giddyup\";\n\n",
            "--giddyup\n",
            "Content-Type: text/plain; charset=\"utf-16\"\n",
            "Content-Transfer-Encoding: quoted-printable\n\n",
            "=FF=FE=0C!5=D8\"=DD5=D8)=DD5=D8-=DD =005=D8*=DD5=D8\"=DD =005=D8\"=\n",
            "=DD5=D85=DD5=D8-=DD5=D8,=DD5=D8/=DD5=D81=DD =005=D8*=DD5=D86=DD =\n",
            "=005=D8=1F=DD5=D8,=DD5=D8,=DD5=D8(=DD =005=D8-=DD5=D8)=DD5=D8\"=\n",
            "=DD5=D8=1E=DD5=D80=DD5=D8\"=DD!=00\n",
            "--giddyup\n",
            "Content-Type: image/gif; name*1=\"about \"; name*0=\"Book \";\n",
            "              name*2*=utf-8''%e2%98%95 tables.gif\n",
            "Content-Transfer-Encoding: Base64\n",
            "Content-Disposition: attachment\n\n",
            "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7\n",
            "--giddyup--\n",
            "--festivus--\n",
        )
        .as_bytes();
    
        let message = Message::parse(input);
    
        // Parses addresses (including comments), lists and groups
        assert_eq!(
            message.get_from(),
            &Address::Address(Addr {
                name: Some("Art Vandelay (Vandelay Industries)".into()),
                address: Some("[email protected]".into())
            })
        );
        assert_eq!(
            message.get_to(),
            &Address::GroupList(vec![
                Group {
                    name: Some("Colleagues".into()),
                    addresses: vec![Addr {
                        name: Some("James Smythe".into()),
                        address: Some("[email protected]".into())
                    }]
                },
                Group {
                    name: Some("Friends".into()),
                    addresses: vec![
                        Addr {
                            name: None,
                            address: Some("[email protected]".into())
                        },
                        Addr {
                            name: Some("John Smîth".into()),
                            address: Some("[email protected]".into())
                        }
                    ]
                }
            ])
        );
    
        assert_eq!(
            message.get_date().unwrap().to_iso8601(),
            "2021-11-20T14:22:01-08:00"
        );
    
        // RFC2047 support for encoded text in message readers
        assert_eq!(
            message.get_subject().unwrap(),
            "Why not both importing AND exporting? ☺"
        );
    
        // HTML and text body parts are returned conforming to RFC8621, Section 4.1.4 
        assert_eq!(
            message.get_html_body(0).unwrap().to_string(),
            concat!(
                "<html><p>I was thinking about quitting the &ldquo;exporting&rdquo; to ",
                "focus just on the &ldquo;importing&rdquo;,</p><p>but then I thought,",
                " why not do both? &#x263A;</p></html>"
            )
        );
    
        // HTML parts are converted to plain text (and viceversa) when missing
        assert_eq!(
            message.get_text_body(0).unwrap().to_string(),
            concat!(
                "I was thinking about quitting the “exporting” to focus just on the",
                " “importing”,\nbut then I thought, why not do both? ☺\n"
            )
        );
    
        // Supports nested messages as well as multipart/digest
        let nested_message = match message.get_attachment(0).unwrap() {
            MessagePart::Message(v) => v,
            _ => unreachable!(),
        };
    
        assert_eq!(
            nested_message.get_subject().unwrap(),
            "Exporting my book about coffee tables"
        );
    
        // Handles UTF-* as well as many legacy encodings
        assert_eq!(
            nested_message.get_text_body(0).unwrap().to_string(),
            "ℌ𝔢𝔩𝔭 𝔪𝔢 𝔢𝔵𝔭𝔬𝔯𝔱 𝔪𝔶 𝔟𝔬𝔬𝔨 𝔭𝔩𝔢𝔞𝔰𝔢!"
        );
        assert_eq!(
            nested_message.get_html_body(0).unwrap().to_string(),
            "<html><body>ℌ𝔢𝔩𝔭 𝔪𝔢 𝔢𝔵𝔭𝔬𝔯𝔱 𝔪𝔶 𝔟𝔬𝔬𝔨 𝔭𝔩𝔢𝔞𝔰𝔢!</body></html>"
        );
    
        let nested_attachment = match nested_message.get_attachment(0).unwrap() {
            MessagePart::Binary(v) => v,
            _ => unreachable!(),
        };
    
        assert_eq!(nested_attachment.len(), 42);
    
        // Full RFC2231 support for continuations and character sets
        assert_eq!(
            nested_attachment
                .get_header()
                .unwrap()
                .get_content_type()
                .unwrap()
                .get_attribute("name")
                .unwrap(),
            "Book about ☕ tables.gif"
        );
    
        // Integrates with Serde
        println!("{}", serde_json::to_string_pretty(&message).unwrap());
        println!("{}", serde_yaml::to_string(&message).unwrap());