From 8905a38a3eb26bfd21253a9388ef0988c0535630 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Wed, 10 Apr 2024 17:24:37 +0500 Subject: [PATCH 01/12] hrmlogin one test added --- .../test_project/features/api/test_feature.py | 43 +++++++++++++++++-- 1 file changed, 40 insertions(+), 3 deletions(-) diff --git a/frontend/test_project/features/api/test_feature.py b/frontend/test_project/features/api/test_feature.py index 75678810..22e051a8 100644 --- a/frontend/test_project/features/api/test_feature.py +++ b/frontend/test_project/features/api/test_feature.py @@ -1,17 +1,23 @@ from os import environ -import pytest from main.backend.common.step_definitions.steps_common import * from assertpy import assert_that from openai import OpenAI +import pytest +from selenium import webdriver +from selenium.webdriver.common.by import By +from time import sleep + +from main.frontend.common.step_definitions import open_base_url, maximize, page_title + logger = structlog.get_logger(__name__) client = OpenAI(api_key=environ.get("OPEN_KEY")) - API_POST_CALL = "post_call" DELETE_ENDPOINT = "/posts/1" POST_ENDPOINT = "/posts" +chrome_driver = webdriver.Chrome() @pytest.mark.nondestructive @@ -26,7 +32,7 @@ def test_send_post_request(request, api_response_container): test_case_name=request.node.name, ) set_request_endpoint(request, request_name=API_POST_CALL, base_url='{%API_BASE_URL%}', endpoint=POST_ENDPOINT) - set_request_headers(request, request_name=API_POST_CALL,headers="./test_data/api/payloads/sample/headers.json") + set_request_headers(request, request_name=API_POST_CALL, headers="./test_data/api/payloads/sample/headers.json") add_json_payload(request, request_name=API_POST_CALL, json_payload="./test_data/api/payloads/post_payload_1.json") make_api_request(request, api_response_container, request_name=API_POST_CALL, request_type='POST') @@ -39,6 +45,37 @@ def test_send_post_request(request, api_response_container): ) +@pytest.mark.nondestructive +@pytest.mark.automated +@pytest.mark.hrmlogin +@pytest.mark.test_name("Login into OrangeHRM system and logout") +def test_login(): + logger.info( + "Scenario is started" + ) + chrome_driver.get('https://lambdatest.github.io/sample-todo-app/') + chrome_driver.maximize_window() + + title = chrome_driver.title + assert 'Sample page - lambdatest.com' in title + + first_checkbox = chrome_driver.find_element(By.XPATH, "//input[@name='li1']") + first_checkbox.click() + second_checkbox = chrome_driver.find_element(By.XPATH, "//input[@name='li2']") + second_checkbox.click() + field = chrome_driver.find_element(By.XPATH, "//input[@id='sampletodotext']") + field.send_keys("testing") + button = chrome_driver.find_element(By.XPATH, "//input[@id='addbutton']") + button.click() + result = chrome_driver.find_element(By.XPATH, "//li[6]/span[@class='done-false']").text + assert 'testing' in result + sleep(5) + chrome_driver.close() + logger.info( + "Scenario is completed successfully" + ) + + # A sample test to verify the open API call @pytest.mark.nondestructive @pytest.mark.automated From 497418557c5fc449a3c7528ac9a86e51015b052b Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Thu, 11 Apr 2024 11:17:41 +0500 Subject: [PATCH 02/12] email step --- frontend/test_project/features/api/api_tests.feature | 2 +- frontend/test_project/features/web/email_tests.feature | 6 ++++++ frontend/test_project/features/web/web_tests.feature | 7 +------ .../step_definitions/test_steps/test_site_steps.py | 2 ++ main/utils/cred.json | 6 +++--- 5 files changed, 13 insertions(+), 10 deletions(-) create mode 100644 frontend/test_project/features/web/email_tests.feature diff --git a/frontend/test_project/features/api/api_tests.feature b/frontend/test_project/features/api/api_tests.feature index 9d0f8c06..8a0b5ef4 100644 --- a/frontend/test_project/features/api/api_tests.feature +++ b/frontend/test_project/features/api/api_tests.feature @@ -21,7 +21,7 @@ Feature: Test HTTP methods for a REST API Given I set the GET endpoint to '/posts' for fetching posts When I send a GET HTTP request # Failing the test on purpose to see the failure in the report - Then I expect the HTTP response code of 'GET' to be '2000' + Then I expect the HTTP response code of 'GET' to be '200' And I expect the response body of 'GET' to be non-empty @api_smoke diff --git a/frontend/test_project/features/web/email_tests.feature b/frontend/test_project/features/web/email_tests.feature new file mode 100644 index 00000000..59167e71 --- /dev/null +++ b/frontend/test_project/features/web/email_tests.feature @@ -0,0 +1,6 @@ +@nondestructive @email_tests +Feature: Email Test + + @email @automated + Scenario: Email verification + When I get email for 'moduspytestboilerplate@gmail.com' \ No newline at end of file diff --git a/frontend/test_project/features/web/web_tests.feature b/frontend/test_project/features/web/web_tests.feature index de961438..57854169 100644 --- a/frontend/test_project/features/web/web_tests.feature +++ b/frontend/test_project/features/web/web_tests.feature @@ -173,9 +173,4 @@ Feature: OrangeHRM Login and Modus QA blog And I click item 'Contractor. Understanding' for element 'Modus_Site > Careers > form_dropdown' And I click item 'Yes' for element 'Modus_Site > Careers > position_dropdown' And I click item 'data protection apps upon hire' for element 'Modus_Site > Careers > form_dropdown' - And I click item 'Yes' for element 'Modus_Site > Careers > protection_dropdown' - - - @email @automated - Scenario: Email verification - When I get email for 'moduspytestboilerplate@gmail.com' \ No newline at end of file + And I click item 'Yes' for element 'Modus_Site > Careers > protection_dropdown' \ No newline at end of file diff --git a/frontend/test_project/step_definitions/test_steps/test_site_steps.py b/frontend/test_project/step_definitions/test_steps/test_site_steps.py index 20d2baca..49061c4e 100644 --- a/frontend/test_project/step_definitions/test_steps/test_site_steps.py +++ b/frontend/test_project/step_definitions/test_steps/test_site_steps.py @@ -6,6 +6,8 @@ scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/web/web_tests.feature")) scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/visual/visual_tests.feature")) +scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/web/email_tests.feature")) + diff --git a/main/utils/cred.json b/main/utils/cred.json index 590a29e2..2edab942 100644 --- a/main/utils/cred.json +++ b/main/utils/cred.json @@ -1,12 +1,12 @@ { "installed": { - "client_id": "44392rcontent.com", + "client_id": "443927617801-152i1i2juvvaqq7q3gniugrtoq4r89s9.apps.googleusercontent.com", "project_id": "modus-pytest", "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://oauth2.googleapis.com/token", - "refresh_token": "1//0ewd1ANSvascVyJs2UBeQOY", + "refresh_token": "1//0ewd1V6v2W-BdCgYIARAAGA4SNwF-L9Ir0okYJ30QMNCV_ArrnK0aor-KhqbnrV4tu5qNmbk-pzFRAna9XANSvascVyJs2UBeQOY", "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_secret": "MGS3sWe", + "client_secret": "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", "redirect_uris": ["urn:ietf:wg:oauth:2.0:oob", "http://localhost", "http://localhost:8080", "http://127.0.0.1"] } } \ No newline at end of file From 71d013389962f1bcd8538d87387d39b59cb62b8d Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Thu, 11 Apr 2024 13:39:49 +0500 Subject: [PATCH 03/12] email step --- main/utils/cred.json | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/main/utils/cred.json b/main/utils/cred.json index 2edab942..9acf3e83 100644 --- a/main/utils/cred.json +++ b/main/utils/cred.json @@ -1,12 +1,14 @@ { - "installed": { - "client_id": "443927617801-152i1i2juvvaqq7q3gniugrtoq4r89s9.apps.googleusercontent.com", - "project_id": "modus-pytest", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "refresh_token": "1//0ewd1V6v2W-BdCgYIARAAGA4SNwF-L9Ir0okYJ30QMNCV_ArrnK0aor-KhqbnrV4tu5qNmbk-pzFRAna9XANSvascVyJs2UBeQOY", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_secret": "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", - "redirect_uris": ["urn:ietf:wg:oauth:2.0:oob", "http://localhost", "http://localhost:8080", "http://127.0.0.1"] - } + "installed": { + "client_id": "443927617801-omgpeeqfic2pjhcb8nmopmmeokfc53qt.apps.googleusercontent.com", + "project_id": "modus-pytest", + "auth_uri": "https://accounts.google.com/o/oauth2/auth", + "token_uri": "https://oauth2.googleapis.com/token", + "refresh_token": "1//0ewd1V6v2W-BdCgYIARAAGA4SNwF-L9Ir0okYJ30QMNCV_ArrnK0aor-KhqbnrV4tu5qNmbk-pzFRAna9XANSvascVyJs2UBeQOY", + "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", + "client_secret": "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", + "redirect_uris": [ + "http://localhost" + ] + } } \ No newline at end of file From 814767d49212e7b1946a43f306a11749c9c45d76 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 08:41:46 +0500 Subject: [PATCH 04/12] updated email files --- main/utils/cred.json | 24 +++++++-------- main/utils/email_reader.py | 9 +++--- main/utils/token.pickle | Bin 905 -> 984 bytes test_data/files/email_data.json | 50 +++++++++++++++++++++++++++++++ test_data/files/email_reader.txt | 42 ++++++++++++++++++++++++++ 5 files changed, 109 insertions(+), 16 deletions(-) diff --git a/main/utils/cred.json b/main/utils/cred.json index 9acf3e83..0a9d4929 100644 --- a/main/utils/cred.json +++ b/main/utils/cred.json @@ -1,14 +1,14 @@ { - "installed": { - "client_id": "443927617801-omgpeeqfic2pjhcb8nmopmmeokfc53qt.apps.googleusercontent.com", - "project_id": "modus-pytest", - "auth_uri": "https://accounts.google.com/o/oauth2/auth", - "token_uri": "https://oauth2.googleapis.com/token", - "refresh_token": "1//0ewd1V6v2W-BdCgYIARAAGA4SNwF-L9Ir0okYJ30QMNCV_ArrnK0aor-KhqbnrV4tu5qNmbk-pzFRAna9XANSvascVyJs2UBeQOY", - "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", - "client_secret": "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", - "redirect_uris": [ - "http://localhost" - ] - } + "installed": { + "client_id": "443927617801-42v66kpc5hup1umr1ea3s4a3h3s8itvu.apps.googleusercontent.com", + "project_id": "modus-pytest", + "auth_uri": "https://accounts.google.com/o/oauth2/auth", + "token_uri": "https://oauth2.googleapis.com/token", + "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", + "client_secret": "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", + "redirect_uris": [ + "http://localhost" + ], + "refresh_token": "1//03-ae1grOJ-2PCgYIARAAGAMSNwF-L9Irgoa_vZsrtTxD47PDd501_-4KySUmE6kHL7ZlAsmCGlbQFpUULBmwNcoCwG0uPoJTf7s" + } } \ No newline at end of file diff --git a/main/utils/email_reader.py b/main/utils/email_reader.py index 023f50a4..ffbdad34 100644 --- a/main/utils/email_reader.py +++ b/main/utils/email_reader.py @@ -29,10 +29,11 @@ def get_email(): if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: - creds.refresh(Request()) - else: - flow = InstalledAppFlow.from_client_secrets_file(test_data_dir_utils+'/cred.json', SCOPES) - creds = flow.run_local_server(port=0) + # creds.refresh(Request()) + creds = None + flow = InstalledAppFlow.from_client_secrets_file(test_data_dir_utils+'/cred.json', scopes=SCOPES) + creds = flow.run_local_server(port=0, timeout_seconds=10) + session = flow.authorized_session() with open(test_data_dir_utils+'/token.pickle', 'wb') as token: pickle.dump(creds, token) diff --git a/main/utils/token.pickle b/main/utils/token.pickle index 1bcbc657dc6c876f7574101135e7e831bbe35011..89add9fec3b6ddd97416a1e0604d38982e0f324e 100644 GIT binary patch delta 517 zcmWO0xssY-007{1*BO({}mM!0qSe zck98y5z9mUY$hR?dOeM=A4XuNx>E7TWH8SB!~&%WvwTqx2}&Kh{T>PsLO$w7G$Qxn zgfc@0Mw}4Zb3QeU2^&?4lW>*LE7U|aj5dteoa-TZ=ZIPly zl%bx5L&CzhIHZHTESeX0#Hig#S>kc?$ zu3UH)PvH%`gbV!+@co{CnNB`UzJ2&Qu|FQ|+@gmB%$L zUpjf1QJ43c3yVP7LI-z29eKS~Giy0UD}VTW^PQTpBEzw~#4(&e(KH9dS#u~F&;>1s wBtj<*ov>V%iag=c!5#~@p1b2^osL_R9MrHbH)d@(QX^R>d-ySaJ#NGMe{&>@^Z)<= diff --git a/test_data/files/email_data.json b/test_data/files/email_data.json index e69de29b..19387c40 100644 --- a/test_data/files/email_data.json +++ b/test_data/files/email_data.json @@ -0,0 +1,50 @@ +[ + { + "Subject": "Action Required - Your OAuth Verification Request", + "From": "API OAuth Dev Verification ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Thu, 11 Apr 2024 01:30:39 -0700", + "Message": "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", + "Url": "<p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P>" + }, + { + "Subject": "Action Required - Your OAuth Verification Request", + "From": "API OAuth Dev Verification ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Thu, 11 Apr 2024 01:19:18 -0700", + "Message": "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", + "Url": "<p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P>" + }, + { + "Subject": "Security alert", + "From": "Google ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Thu, 07 Mar 2024 09:40:59 GMT", + "Message": "W2ltYWdlOiBHb29nbGVdDQpOZXcgcGFzc2tleSBhZGRlZCB0byB5b3VyIGFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KSWYgeW91IGRpZG7igJl0IGFkZCBhIHBhc3NrZXksIHNvbWVvbmUgbWlnaHQgYmUgdXNpbmcgeW91ciBhY2NvdW50LiBDaGVjayBhbmQNCnNlY3VyZSB5b3VyIGFjY291bnQgbm93Lg0KQ2hlY2sgYWN0aXZpdHkNCjxodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20vQWNjb3VudENob29zZXI/RW1haWw9bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb20mY29udGludWU9aHR0cHM6Ly9teWFjY291bnQuZ29vZ2xlLmNvbS9hbGVydC9udC8xNzA5ODA0NDU5NjIxP3JmbiUzRDM2NCUyNnJmbmMlM0QxJTI2ZWlkJTNEMjk3NjEwNjI0OTY2Nzc3OTY5OSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K", + "Url": "PCFET0NUWVBFIGh0bWw+PGh0bWwgbGFuZz0iZW4iPjxoZWFkPjxtZXRhIG5hbWU9ImZvcm1hdC1kZXRlY3Rpb24iIGNvbnRlbnQ9ImVtYWlsPW5vIi8+PG1ldGEgbmFtZT0iZm9ybWF0LWRldGVjdGlvbiIgY29udGVudD0iZGF0ZT1ubyIvPjxzdHlsZSBub25jZT0iWno3NTE2MS1WajJwZlZxX0VjRDFvUSI+LmF3bCBhIHtjb2xvcjogI0ZGRkZGRjsgdGV4dC1kZWNvcmF0aW9uOiBub25lO30gLmFibWwgYSB7Y29sb3I6ICMwMDAwMDA7IGZvbnQtZmFtaWx5OiBSb2JvdG8tTWVkaXVtLEhlbHZldGljYSxBcmlhbCxzYW5zLXNlcmlmOyBmb250LXdlaWdodDogYm9sZDsgdGV4dC1kZWNvcmF0aW9uOiBub25lO30gLmFkZ2wgYSB7Y29sb3I6IHJnYmEoMCwgMCwgMCwgMC44Nyk7IHRleHQtZGVjb3JhdGlvbjogbm9uZTt9IC5hZmFsIGEge2NvbG9yOiAjYjBiMGIwOyB0ZXh0LWRlY29yYXRpb246IG5vbmU7fSBAbWVkaWEgc2NyZWVuIGFuZCAobWluLXdpZHRoOiA2MDBweCkgey52MnNwIHtwYWRkaW5nOiA2cHggMzBweCAwcHg7fSAudjJyc3Age3BhZGRpbmc6IDBweCAxMHB4O319IEBtZWRpYSBzY3JlZW4gYW5kIChtaW4td2lkdGg6IDYwMHB4KSB7Lm1kdjJydyB7cGFkZGluZzogNDBweCA0MHB4O319IDwvc3R5bGU+PGxpbmsgaHJlZj0iLy9mb250cy5nb29nbGVhcGlzLmNvbS9jc3M/ZmFtaWx5PUdvb2dsZStTYW5zIiByZWw9InN0eWxlc2hlZXQiIHR5cGU9InRleHQvY3NzIiBub25jZT0iWno3NTE2MS1WajJwZlZxX0VjRDFvUSIvPjwvaGVhZD48Ym9keSBzdHlsZT0ibWFyZ2luOiAwOyBwYWRkaW5nOiAwOyIgYmdjb2xvcj0iI0ZGRkZGRiI+PHRhYmxlIHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUiIHN0eWxlPSJtaW4td2lkdGg6IDM0OHB4OyIgYm9yZGVyPSIwIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjAiIGxhbmc9ImVuIj48dHIgaGVpZ2h0PSIzMiIgc3R5bGU9ImhlaWdodDogMzJweDsiPjx0ZD48L3RkPjwvdHI+PHRyIGFsaWduPSJjZW50ZXIiPjx0ZD48ZGl2IGl0ZW1zY29wZSBpdGVtdHlwZT0iLy9zY2hlbWEub3JnL0VtYWlsTWVzc2FnZSI+PGRpdiBpdGVtcHJvcD0iYWN0aW9uIiBpdGVtc2NvcGUgaXRlbXR5cGU9Ii8vc2NoZW1hLm9yZy9WaWV3QWN0aW9uIj48bGluayBpdGVtcHJvcD0idXJsIiBocmVmPSJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20vQWNjb3VudENob29zZXI/RW1haWw9bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb20mYW1wO2NvbnRpbnVlPWh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vYWxlcnQvbnQvMTcwOTgwNDQ1OTYyMT9yZm4lM0QzNjQlMjZyZm5jJTNEMSUyNmVpZCUzRDI5NzYxMDYyNDk2Njc3Nzk2OTklMjZldCUzRDAiLz48bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iUmV2aWV3IEFjdGl2aXR5Ii8+PC9kaXY+PC9kaXY+PHRhYmxlIGJvcmRlcj0iMCIgY2VsbHNwYWNpbmc9IjAiIGNlbGxwYWRkaW5nPSIwIiBzdHlsZT0icGFkZGluZy1ib3R0b206IDIwcHg7IG1heC13aWR0aDogNTE2cHg7IG1pbi13aWR0aDogMjIwcHg7Ij48dHI+PHRkIHdpZHRoPSI4IiBzdHlsZT0id2lkdGg6IDhweDsiPjwvdGQ+PHRkPjxkaXYgc3R5bGU9ImJvcmRlci1zdHlsZTogc29saWQ7IGJvcmRlci13aWR0aDogdGhpbjsgYm9yZGVyLWNvbG9yOiNkYWRjZTA7IGJvcmRlci1yYWRpdXM6IDhweDsgcGFkZGluZzogNDBweCAyMHB4OyIgYWxpZ249ImNlbnRlciIgY2xhc3M9Im1kdjJydyI+PGltZyBzcmM9Imh0dHBzOi8vd3d3LmdzdGF0aWMuY29tL2ltYWdlcy9icmFuZGluZy9nb29nbGVsb2dvLzJ4L2dvb2dsZWxvZ29fY29sb3JfNzR4MjRkcC5wbmciIHdpZHRoPSI3NCIgaGVpZ2h0PSIyNCIgYXJpYS1oaWRkZW49InRydWUiIHN0eWxlPSJtYXJnaW4tYm90dG9tOiAxNnB4OyIgYWx0PSJHb29nbGUiPjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiAmIzM5O0dvb2dsZSBTYW5zJiMzOTssUm9ib3RvLFJvYm90b0RyYWZ0LEhlbHZldGljYSxBcmlhbCxzYW5zLXNlcmlmO2JvcmRlci1ib3R0b206IHRoaW4gc29saWQgI2RhZGNlMDsgY29sb3I6IHJnYmEoMCwwLDAsMC44Nyk7IGxpbmUtaGVpZ2h0OiAzMnB4OyBwYWRkaW5nLWJvdHRvbTogMjRweDt0ZXh0LWFsaWduOiBjZW50ZXI7IHdvcmQtYnJlYWs6IGJyZWFrLXdvcmQ7Ij48ZGl2IHN0eWxlPSJmb250LXNpemU6IDI0cHg7Ij5OZXcgcGFzc2tleSBhZGRlZCB0byB5b3VyIGFjY291bnQgPC9kaXY+PHRhYmxlIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPjx0ciBzdHlsZT0ibGluZS1oZWlnaHQ6IG5vcm1hbDsiPjx0ZCBhbGlnbj0icmlnaHQiIHN0eWxlPSJwYWRkaW5nLXJpZ2h0OjhweDsiPjxpbWcgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiBzdHlsZT0id2lkdGg6IDIwcHg7IGhlaWdodDogMjBweDsgdmVydGljYWwtYWxpZ246IHN1YjsgYm9yZGVyLXJhZGl1czogNTAlOzsiIHNyYz0iaHR0cHM6Ly9saDMuZ29vZ2xldXNlcmNvbnRlbnQuY29tL2EvQUNnOG9jTERiUEQtWno5NUJVeC11bjBUblprYWVhdDZJckhtdXJJamN5eHBVeDRKPXM5Ni1jIiBhbHQ9IiI+PC90ZD48dGQ+PGEgc3R5bGU9ImZvbnQtZmFtaWx5OiAmIzM5O0dvb2dsZSBTYW5zJiMzOTssUm9ib3RvLFJvYm90b0RyYWZ0LEhlbHZldGljYSxBcmlhbCxzYW5zLXNlcmlmO2NvbG9yOiByZ2JhKDAsMCwwLDAuODcpOyBmb250LXNpemU6IDE0cHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyI+bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb208L2E+PC90ZD48L3RyPjwvdGFibGU+IDwvZGl2PjxkaXYgc3R5bGU9ImZvbnQtZmFtaWx5OiBSb2JvdG8tUmVndWxhcixIZWx2ZXRpY2EsQXJpYWwsc2Fucy1zZXJpZjsgZm9udC1zaXplOiAxNHB4OyBjb2xvcjogcmdiYSgwLDAsMCwwLjg3KTsgbGluZS1oZWlnaHQ6IDIwcHg7cGFkZGluZy10b3A6IDIwcHg7IHRleHQtYWxpZ246IGxlZnQ7Ij5JZiB5b3UgZGlkbuKAmXQgYWRkIGEgcGFzc2tleSwgc29tZW9uZSBtaWdodCBiZSB1c2luZyB5b3VyIGFjY291bnQuIENoZWNrIGFuZCBzZWN1cmUgeW91ciBhY2NvdW50IG5vdy48ZGl2IHN0eWxlPSJwYWRkaW5nLXRvcDogMzJweDsgdGV4dC1hbGlnbjogY2VudGVyOyI+PGEgaHJlZj0iaHR0cHM6Ly9hY2NvdW50cy5nb29nbGUuY29tL0FjY291bnRDaG9vc2VyP0VtYWlsPW1vZHVzcHl0ZXN0Ym9pbGVycGxhdGVAZ21haWwuY29tJmFtcDtjb250aW51ZT1odHRwczovL215YWNjb3VudC5nb29nbGUuY29tL2FsZXJ0L250LzE3MDk4MDQ0NTk2MjE/cmZuJTNEMzY0JTI2cmZuYyUzRDElMjZlaWQlM0QyOTc2MTA2MjQ5NjY3Nzc5Njk5JTI2ZXQlM0QwIiB0YXJnZXQ9Il9ibGFuayIgbGluay1pZD0ibWFpbi1idXR0b24tbGluayIgc3R5bGU9ImZvbnQtZmFtaWx5OiAmIzM5O0dvb2dsZSBTYW5zJiMzOTssUm9ib3RvLFJvYm90b0RyYWZ0LEhlbHZldGljYSxBcmlhbCxzYW5zLXNlcmlmOyBsaW5lLWhlaWdodDogMTZweDsgY29sb3I6ICNmZmZmZmY7IGZvbnQtd2VpZ2h0OiA0MDA7IHRleHQtZGVjb3JhdGlvbjogbm9uZTtmb250LXNpemU6IDE0cHg7ZGlzcGxheTppbmxpbmUtYmxvY2s7cGFkZGluZzogMTBweCAyNHB4O2JhY2tncm91bmQtY29sb3I6ICM0MTg0RjM7IGJvcmRlci1yYWRpdXM6IDVweDsgbWluLXdpZHRoOiA5MHB4OyI+Q2hlY2sgYWN0aXZpdHk8L2E+PC9kaXY+PC9kaXY+PGRpdiBzdHlsZT0icGFkZGluZy10b3A6IDIwcHg7IGZvbnQtc2l6ZTogMTJweDsgbGluZS1oZWlnaHQ6IDE2cHg7IGNvbG9yOiAjNWY2MzY4OyBsZXR0ZXItc3BhY2luZzogMC4zcHg7IHRleHQtYWxpZ246IGNlbnRlciI+WW91IGNhbiBhbHNvIHNlZSBzZWN1cml0eSBhY3Rpdml0eSBhdDxicj48YSBzdHlsZT0iY29sb3I6IHJnYmEoMCwgMCwgMCwgMC44Nyk7dGV4dC1kZWNvcmF0aW9uOiBpbmhlcml0OyI+aHR0cHM6Ly9teWFjY291bnQuZ29vZ2xlLmNvbS9ub3RpZmljYXRpb25zPC9hPjwvZGl2PjwvZGl2PjxkaXYgc3R5bGU9InRleHQtYWxpZ246IGxlZnQ7Ij48ZGl2IHN0eWxlPSJmb250LWZhbWlseTogUm9ib3RvLVJlZ3VsYXIsSGVsdmV0aWNhLEFyaWFsLHNhbnMtc2VyaWY7Y29sb3I6IHJnYmEoMCwwLDAsMC41NCk7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDE4cHg7IHBhZGRpbmctdG9wOiAxMnB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7Ij48ZGl2PllvdSByZWNlaXZlZCB0aGlzIGVtYWlsIHRvIGxldCB5b3Uga25vdyBhYm91dCBpbXBvcnRhbnQgY2hhbmdlcyB0byB5b3VyIEdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy48L2Rpdj48ZGl2IHN0eWxlPSJkaXJlY3Rpb246IGx0cjsiPiZjb3B5OyAyMDI0IEdvb2dsZSBMTEMsIDxhIGNsYXNzPSJhZmFsIiBzdHlsZT0iZm9udC1mYW1pbHk6IFJvYm90by1SZWd1bGFyLEhlbHZldGljYSxBcmlhbCxzYW5zLXNlcmlmO2NvbG9yOiByZ2JhKDAsMCwwLDAuNTQpOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAxOHB4OyBwYWRkaW5nLXRvcDogMTJweDsgdGV4dC1hbGlnbjogY2VudGVyOyI+MTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQTwvYT48L2Rpdj48L2Rpdj48L2Rpdj48L3RkPjx0ZCB3aWR0aD0iOCIgc3R5bGU9IndpZHRoOiA4cHg7Ij48L3RkPjwvdHI+PC90YWJsZT48L3RkPjwvdHI+PHRyIGhlaWdodD0iMzIiIHN0eWxlPSJoZWlnaHQ6IDMycHg7Ij48dGQ+PC90ZD48L3RyPjwvdGFibGU+PC9ib2R5PjwvaHRtbD4=" + }, + { + "Subject": "Security alert", + "From": "Google ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Thu, 07 Mar 2024 07:26:07 GMT", + "Message": "W2ltYWdlOiBHb29nbGVdDQptb2R1cy1hcHAgd2FzIGdyYW50ZWQgYWNjZXNzIHRvIHlvdXIgR29vZ2xlIEFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KDQpJZiB5b3UgZGlkIG5vdCBncmFudCBhY2Nlc3MsIHlvdSBzaG91bGQgY2hlY2sgdGhpcyBhY3Rpdml0eSBhbmQgc2VjdXJlIHlvdXINCmFjY291bnQuDQpDaGVjayBhY3Rpdml0eQ0KPGh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9BY2NvdW50Q2hvb3Nlcj9FbWFpbD1tb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbSZjb250aW51ZT1odHRwczovL215YWNjb3VudC5nb29nbGUuY29tL2FsZXJ0L250LzE3MDk3OTYzNjcwMDA/cmZuJTNEMTI3JTI2cmZuYyUzRDElMjZlaWQlM0QtMjM3Mzc5MzMxNzk3MTIzODg4MSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K", + "Url": "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" + }, + { + "Subject": "test", + "From": "Modus Pytest Boilerplate ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Thu, 7 Mar 2024 12:07:37 +0500", + "Message": "dGVzdA0K", + "Url": "PGRpdiBkaXI9Imx0ciI+dGVzdDwvZGl2Pg0K" + }, + { + "Subject": "Modus Pytest, finish setting up your new Google Account", + "From": "Google Community Team ", + "To": "moduspytestboilerplate@gmail.com", + "Date": "Wed, 06 Mar 2024 22:58:19 -0800", + "Message": "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", + "Url": "<!doctype html>
<html ⚡4email data-css-strict lang=en>
<head>
<meta charset=utf-8>
<script async src=https://cdn.ampproject.org/v0.js></script>
<script custom-element=amp-bind src=https://cdn.ampproject.org/v0/amp-bind-0.1.js async></script>
<script async custom-element=amp-form src=https://cdn.ampproject.org/v0/amp-form-0.1.js></script>
<style amp4email-boilerplate>body{visibility:hidden}</style>
<style amp-custom>
body{text-decoration:none;}
td.table-cell.subheadline.space6.module_para {
padding: 0 50px;
}
.pdngrtl{padding:7px 24px 7px 24px}
.localepading{padding:8px 26px 7px 26px; font-size:16px;}
.space6{padding:0 80px 0 80px;}
.space2{padding:0 70px 0 70px;}
.widthmin{min-width:115px;}
.addingspace{width:6px; display: inline-block;}
@media only screen and (max-width: 767px){
.btn_mod2_mobile1{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod2_mobile2{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod3_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod4_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.pdngrtl{padding:7px 11px 7px 11px}
.space1{height:19px ;}
.space2{padding:3px 35px 0 35px ;}
.space3{padding-top: 22px ;}
.space4{padding: 6px 0 0 0 ;}
.space5{padding-top: 17px ;}
.space6{padding:0 35px 0 35px ;}
.space7{padding-right: 0px ;}
}
@media screen and (min-resolution: 288dpi) {
.device_txt{font-size:26px;}
}
/* Potrait for iPhone */
@media only screen and (device-width: 375px) and (orientation:portrait){
.fmd_mobile {padding-top:5px ;color:red ;}
}
body{text-decoration:none;}
</style>
<!--[if gte mso 9]>
<xml>
<o:OfficeDocumentSettings>
<o:AllowPNG/>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
<![endif]-->
<!--[if mso]>
<style>a{color:4285f4; text-decoration:none;}</style>
<![endif]-->
</head>
<body class=body_wrapper style="padding: 0 6px;">
<div style="font-size: 0px; line-height:0px; color: #ffffff; display: none;">                                                                                                                                                                                                                                                                                                                                                                                                                                                                           </div>
<table role=presentation class=body_size border=0 cellspacing=0 cellpadding=0 align=center width=100% bgcolor=#ffffff style="background: #ffffff; width:100%;max-width: 520px;">
<tr><td align=center style="padding-top: 20px;"> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-header.png style="width: 82px; height:26px; text-align: center; border: none;">
</td></tr>
<tr><td class=space1 height=15></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=516 height=109 src=https://www.gstatic.com/gumdrop/files/banner.png style="width: 100%; text-align: center; border: none;" layout=responsive>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<!--[if mso]>
<td align="center" class="greeting_name space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; padding:0 80px 20px 80px; text-align:center;word-break:normal;direction:ltr;' dir="ltr">
Hi Modus Pytest,
</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="greeting_name space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>
Hi Modus Pytest,
</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space2" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Welcome to Google. Your new account comes with access to Google products, apps, and services.</td>
</tr>
<tr>
<td class="subheadline space6" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Here are a few tips to get you started.</td>
</tr>
<tr><td height=45></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style=padding-bottom:50px;>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr class=table-row>
<td class=table-cell style=height:50px></td>
</tr>
<tr class=table-row>
<td class=table-cell align=center>
<amp-img role=presentation width=48 height=48 src=https://www.gstatic.com/images/branding/product/2x/email_64dp.png style=width:48px;height:48px;text-align:center;border:none;font-size:9px class=CToWUd></amp-img>
</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px></td>
</tr>
<tr class=table-row>
<td class=table-cell style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 30px 0 30px; text-align:center; word-break:normal; direction:ltr;" dir=ltr>Get the most out of your Google Account</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px;line-height:4px;font-size:4px></td>
</tr>
<tr class=table-row>
<td class="table-cell subheadline space6 module_para" style="color:#5f6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal; direction:ltr;" dir=ltr>We&#39;ll send you personalized tips, news and recommendations from Google.</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:30px;></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 4px; height:4px;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<form class="sample-form hide-inputs" method=post action-xhr=https://www.google.com/dynamicmail/optin?tok=AMkCvlsFcJCAyjqfUBxSVGWAeBaDxQHayXK1a_iSygC0P5WIJzQpCgwOq_QGO4--tFaOgh2xFQ==&amp;ctrk=https://notifications.google.com/g/p/ANiao5q00zyMvvt-jpKiJuw2CiYJi4Zthu6gBCDeof77qPoiCT8zlM3PPyyOyRNfW-SdckVvjI80pItjYNDwllNhjx_HUgBJpo4LLItagUMohE1NqTkHrbn0SSI9IbhZ-_Z32JH9hateW-9WM7yDZMEE4XUZ9io7V5E5cTwFd0ZMyEVbrA0EQgEJz_92MjMdpA8yQp_w0s7QeryNRValYk4hDaOXA_O8adsO9Z6u7r1briiE>
<button [hidden]=cta_submit role="" tabindex="" on="tap:AMP.setState({sign_up: true, cta_submit: true})" type=submit value="" style="background-color:#1a73e8; border:1px solid #1a73e8; border-radius:4px; color:#FFFFFF; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:180px; font-weight:500; text-align:center; word-break:normal; direction:ltr;" class=localepading>Yes, keep me updated</button>
<div submitting>
<a style="background-color:#5F6368; border:1px solid #5F6368; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>One moment...</a>
</div>
<div submit-success>
<a style="background-color:#188038; border:1px solid #188038; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>You&#39;ve signed up</a>
<div class=table-row>
<div class=table-cell style=height:20px></div>
</div>
<table width=80% role=presentation align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto; width: 80%;">
<tr class=table-row>
<td align=center class=table-cell style="background-color: #ffffff; color: #5F6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size: 14px; line-height: 21px; text-align:center; margin: 0 auto; padding:0px;">You can unsubscribe at any time in the messages you receive. You can also <a href=https://notifications.google.com/g/p/ANiao5qjymW_t0uPjVYrfJYbgdo9waKj9lw3lnGdYyZInr8de_Lbr1yE5-ZbxhCGD_sfBGRNjMWFNQNqPltxa3ymYfMUw697szlzaHHLqyb_-RffxxmvXmBphBpgrfjKcOvo9nmgFhqWehnEc5wf8owpdvFlGxmpyKSAr-ORgcymVQWIVTorL5_w45Eyly2nT-mnfy-8ILD1ok6--PbSp_Kehm0iUDwWduXRajhouKlgIpN2WPGvmHxvwhm_TeBQjNfanPY1d5yM9Zk9ysa7fHSxIqNr4RM-_mJHEblWYw5JeG07Z__4Rl6qr7PSFZf5FD3CxeUBGSqOyEBE28fpvNuTmTI6e29NYCj4G2Gc14LCI4lcVnrmRoWpdsw4Mx_w89zRFQUOolVZF8SeAde9ifXDcDk-V37gi7FNp2QK2pqi7mgaERONST_QVWUPz7FRwwSPNUfUBlqz7vnsYrB1w0r5vogVgOrG_Qz-oR8wejXLYNKL2tOahU2v5E_EbvRi53_evxgB6oKnPWQODn6LFXi1yB0peGxcGLSuoT62HzV1l5DHvwZUh21HO0niraoX78aIBmWrLL1LKYmRnHnEeMVOCXWVmMaO6bsX8mMR9rc1yhbvJae4RpMjmJSkOfSIkoaWqaLAuIzMyqTjWOrjYE8WlQgSKZHs target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">manage your preferences</a>.
</td>
</tr>
</table>
</div>
<div submit-error>
<a href=https://notifications.google.com/g/p/ANiao5pVGL0PiiGdVXPsRPji2J57DhE_cOwjqvVmlV_SkJgD9ERjCRMztBNK_ZqlrfvueiW9mf2x1M82G2FmRZ8vAg1NIIsznBvgKBi-0v9H6sw1MM9AgKxvNFIyMZwb7KVyKIN4OueoBLXtGc75Ij8B3_rDFDwUFLVQk0XGjIbVBIdrRjTmI4JaecuUybTzIsJW5CfZp4FF-woB56D8Ra7fzEfABP_iIjX0Z5qfc7H9e4SHz0bwC7ozzxQxpghWAXrkTMq1VBjFg2agx6_j2J10T8u8t50jUg3ezt8cdUPzHkt-RcKXr1fYm7HWpiwGmWiaZo3pjPeFrhVrOyxkOXmHiwwmZMuliO6o6jHMCHgyf7e_kvNEWVKeacwO28xzSacgimjYDNzrBloPzUZ0hKzBHv7mc9SXE39ob38HRWa1yS-19fKb8L3L8rmrSIgrRmXstxdORZY5mQ96YgiRN1j0brm1Q-Bh-V5TtT3fcPrJFPFao9Wljs_SUxPJAUkypo7twzwt5mXZaT0wyf7Wn5i2HgzZ8dLpYI_naFYVlha5T2DW_pmWXQDsAebqhJngZFknzTas2x8lJZAtHOtXY35kRTMXZUu_QZ7_uEImb7lfSAQ3en5hWNbZZMbe4_k7vcinH6rfuwU target=_blank>
<table role=presentation cellspacing=0 cellpadding=0>
<tbody>
<tr>
<td style="text-align: center; background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:167px; padding:8px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal;direction:ltr;" dir=ltr class=cta_gl>Try again...</td>
</tr>
</tbody></table>
</a>
</div>
</form>
</td>
</tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 3px; height:3px; border-top-left-radius: 4px; border-top-right-radius: 4px; display:inline-block; text-align: center;"></td>
</tr>
</table>
</table>
</td>
</tr>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/google-logo.png style="width: 48px; height:48px; text-align: center; border: none; font-size:9px;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Stay in the know with the Google app</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Stay in the know with the Google app</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Find quick answers, explore your interests, and stay up to date.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td class=space4 style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw" style="height:48px; v-text-anchor:middle; width:150px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Try it</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod2_mobile2 enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Try it
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
<tr><td height=50></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=514 height=207 src=https://www.gstatic.com/gumdrop/files/apps-icons-image-2x-wd972px-ht390px.png style="width: 100%; text-align: center; border: none; border-top-left-radius: 8px; border-top-right-radius: 8px;" layout=responsive>
</td>
</tr>
<tr><td height=7></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">More from Google</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>More from Google</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Discover the latest apps from Google.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V" style="height:48px; v-text-anchor:middle; width:160px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For Android</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; direction:ltr;">
For Android
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
<span style="" class=addingspace>  </span>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94" style="height:48px; v-text-anchor:middle; width:130px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For iOS</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94 target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8;; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; white-space:normal; direction:ltr;">
For iOS
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/security-logo.png style="width: 48px; height:48px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Review and change your privacy and security options to make <span style="white-space:nowrap; " class="">Google</span> work better <span style="white-space:nowrap; " class="">for you.</span></td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding-top: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA" style="height:48px; v-text-anchor:middle; width:180px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Confirm</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod4_mobile enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Confirm
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=480 style="border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
<!--[if mso]>
<td style="margin-bottom:67px; padding: 21px 10px 35px 20px;"> <amp-img role="presentation" class="fa_mobile" width="24" height="24" src="https://www.gstatic.com/gumdrop/files/help-outline.png" style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<![endif]-->
<!--[if !mso]><!-->
<td style="padding: 47px 10px 40px 20px;" valign=top> <amp-img role=presentation class=fa_mobile width=24 height=24 src=https://www.gstatic.com/gumdrop/files/help-outline.png style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<!--<![endif]-->
<td valign=top>
<!--[if mso]>
<div class="device_txt" style="margin-bottom:15px; padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:18px; padding-bottom:12px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Find answers</div>
<![endif]-->
<!--[if !mso]><!-->
<div class=device_txt style="padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:45px; padding-bottom:12px; word-break:normal;direction:ltr;" dir=ltr>Find answers</div>
<!--<![endif]-->
<!--[if mso]>
<div class="subheadline space7" style="margin-bottom:20px; padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:35px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Visit the <a href="https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ" target="_blank" style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<![endif]-->
<!--[if !mso]><!-->
<div class="subheadline space7" style="padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:50px; word-break:normal;direction:ltr;" dir=ltr>Visit the <a href=https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<!--<![endif]-->
</td>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
</tr>
</table>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=30></td></tr>
<tr>
<td width=134 height=46 align=center style="font-size:8px; word-break:normal;direction:ltr;" dir=ltr> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-footer.png style="width: 82px; height:26px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:12px; line-height:18px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Replies to this email aren&#39;t monitored. If you have a question about your new account, the <a href=https://notifications.google.com/g/p/ANiao5rTjkBxyW3fJJZoX4P9D_6vTIpEyPkjkx72A5ZOucL-qnhiUap2yhWQsEAbi5j-mOEqpmaB9UC7BGsgXJmh1Aq12RIOoGT-Qedihwobq8PGaxMuXKR2Tv-NrcMz1qGxoGTMSy6VA6_GEsG84AnHYYhA9BKaTq5HRC7kPrAbVD7s2JcMH0NcaAH_uzUCAu7UxIbdxjGnFin-oRS-Guve3IIpVJivRvxXA_10nzZgIHE2uwHI7GsEuM4DqBApZnGckanWMnQhqznDpXEYL4AFj6sISuMHWRFD3_DWX9KxQ-JiqxkM-Gjdgpityw target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> likely has the answer you&#39;re looking for.</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 valign=middle style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:10px; line-height:15px; margin:0; text-align:center" align=center>
<span style="font-size:inherit; color:inherit; font-weight:inherit; line-height:inherit; font-family:inherit;">Google LLC<br>1600 Amphitheatre Parkway,<br>Mountain View, CA 94043</span>
<br><br><span style=word-break:normal;direction:ltr; dir=ltr>This email was sent to you because you created a Google Account.</span></td>
</tr>
</table>
</td>
</tr>
<tr><td height=18></td></tr>
</table>
<div style="display:none; white-space:nowrap; font:15px courier; line-height:0;">
                            
                             
</div>
<amp-img alt="" height=1 width=3 src=https://notifications.google.com/g/img/ANiao5redogZGkiXNpH8PTOz6QtmTWmDl5Kn_b-3kYHZEpRf5kYRMZOqPG7UV5ATGDUF-xPoFCENQragusUa3fuTQ31HzvUNEm--NO6eqkX1t8aqN87kYcIef-IsUSl-vHPhy8GyyWK6r6h3huKtutBqC4tTAwVNqRai_7Ir3A.gif></body>
</html>" + } +] \ No newline at end of file diff --git a/test_data/files/email_reader.txt b/test_data/files/email_reader.txt index e69de29b..73f04c90 100644 --- a/test_data/files/email_reader.txt +++ b/test_data/files/email_reader.txt @@ -0,0 +1,42 @@ +Subject : Action Required - Your OAuth Verification Request +From : API OAuth Dev Verification +To : moduspytestboilerplate@gmail.com +Date : Thu, 11 Apr 2024 01:30:39 -0700 +Message : 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 +Url : <p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P> + +Subject : Action Required - Your OAuth Verification Request +From : API OAuth Dev Verification +To : moduspytestboilerplate@gmail.com +Date : Thu, 11 Apr 2024 01:19:18 -0700 +Message : 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 +Url : <p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P> + +Subject : Security alert +From : Google +To : moduspytestboilerplate@gmail.com +Date : Thu, 07 Mar 2024 09:40:59 GMT +Message : W2ltYWdlOiBHb29nbGVdDQpOZXcgcGFzc2tleSBhZGRlZCB0byB5b3VyIGFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KSWYgeW91IGRpZG7igJl0IGFkZCBhIHBhc3NrZXksIHNvbWVvbmUgbWlnaHQgYmUgdXNpbmcgeW91ciBhY2NvdW50LiBDaGVjayBhbmQNCnNlY3VyZSB5b3VyIGFjY291bnQgbm93Lg0KQ2hlY2sgYWN0aXZpdHkNCjxodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20vQWNjb3VudENob29zZXI/RW1haWw9bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb20mY29udGludWU9aHR0cHM6Ly9teWFjY291bnQuZ29vZ2xlLmNvbS9hbGVydC9udC8xNzA5ODA0NDU5NjIxP3JmbiUzRDM2NCUyNnJmbmMlM0QxJTI2ZWlkJTNEMjk3NjEwNjI0OTY2Nzc3OTY5OSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K +Url : 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 + +Subject : Security alert +From : Google +To : moduspytestboilerplate@gmail.com +Date : Thu, 07 Mar 2024 07:26:07 GMT +Message : W2ltYWdlOiBHb29nbGVdDQptb2R1cy1hcHAgd2FzIGdyYW50ZWQgYWNjZXNzIHRvIHlvdXIgR29vZ2xlIEFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KDQpJZiB5b3UgZGlkIG5vdCBncmFudCBhY2Nlc3MsIHlvdSBzaG91bGQgY2hlY2sgdGhpcyBhY3Rpdml0eSBhbmQgc2VjdXJlIHlvdXINCmFjY291bnQuDQpDaGVjayBhY3Rpdml0eQ0KPGh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9BY2NvdW50Q2hvb3Nlcj9FbWFpbD1tb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbSZjb250aW51ZT1odHRwczovL215YWNjb3VudC5nb29nbGUuY29tL2FsZXJ0L250LzE3MDk3OTYzNjcwMDA/cmZuJTNEMTI3JTI2cmZuYyUzRDElMjZlaWQlM0QtMjM3Mzc5MzMxNzk3MTIzODg4MSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K +Url : 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 + +Subject : test +From : Modus Pytest Boilerplate +To : moduspytestboilerplate@gmail.com +Date : Thu, 7 Mar 2024 12:07:37 +0500 +Message : dGVzdA0K +Url : PGRpdiBkaXI9Imx0ciI+dGVzdDwvZGl2Pg0K + +Subject : Modus Pytest, finish setting up your new Google Account +From : Google Community Team +To : moduspytestboilerplate@gmail.com +Date : Wed, 06 Mar 2024 22:58:19 -0800 +Message : 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 +Url : <!doctype html>
<html ⚡4email data-css-strict lang=en>
<head>
<meta charset=utf-8>
<script async src=https://cdn.ampproject.org/v0.js></script>
<script custom-element=amp-bind src=https://cdn.ampproject.org/v0/amp-bind-0.1.js async></script>
<script async custom-element=amp-form src=https://cdn.ampproject.org/v0/amp-form-0.1.js></script>
<style amp4email-boilerplate>body{visibility:hidden}</style>
<style amp-custom>
body{text-decoration:none;}
td.table-cell.subheadline.space6.module_para {
padding: 0 50px;
}
.pdngrtl{padding:7px 24px 7px 24px}
.localepading{padding:8px 26px 7px 26px; font-size:16px;}
.space6{padding:0 80px 0 80px;}
.space2{padding:0 70px 0 70px;}
.widthmin{min-width:115px;}
.addingspace{width:6px; display: inline-block;}
@media only screen and (max-width: 767px){
.btn_mod2_mobile1{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod2_mobile2{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod3_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod4_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.pdngrtl{padding:7px 11px 7px 11px}
.space1{height:19px ;}
.space2{padding:3px 35px 0 35px ;}
.space3{padding-top: 22px ;}
.space4{padding: 6px 0 0 0 ;}
.space5{padding-top: 17px ;}
.space6{padding:0 35px 0 35px ;}
.space7{padding-right: 0px ;}
}
@media screen and (min-resolution: 288dpi) {
.device_txt{font-size:26px;}
}
/* Potrait for iPhone */
@media only screen and (device-width: 375px) and (orientation:portrait){
.fmd_mobile {padding-top:5px ;color:red ;}
}
body{text-decoration:none;}
</style>
<!--[if gte mso 9]>
<xml>
<o:OfficeDocumentSettings>
<o:AllowPNG/>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
<![endif]-->
<!--[if mso]>
<style>a{color:4285f4; text-decoration:none;}</style>
<![endif]-->
</head>
<body class=body_wrapper style="padding: 0 6px;">
<div style="font-size: 0px; line-height:0px; color: #ffffff; display: none;">                                                                                                                                                                                                                                                                                                                                                                                                                                                                           </div>
<table role=presentation class=body_size border=0 cellspacing=0 cellpadding=0 align=center width=100% bgcolor=#ffffff style="background: #ffffff; width:100%;max-width: 520px;">
<tr><td align=center style="padding-top: 20px;"> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-header.png style="width: 82px; height:26px; text-align: center; border: none;">
</td></tr>
<tr><td class=space1 height=15></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=516 height=109 src=https://www.gstatic.com/gumdrop/files/banner.png style="width: 100%; text-align: center; border: none;" layout=responsive>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<!--[if mso]>
<td align="center" class="greeting_name space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; padding:0 80px 20px 80px; text-align:center;word-break:normal;direction:ltr;' dir="ltr">
Hi Modus Pytest,
</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="greeting_name space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>
Hi Modus Pytest,
</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space2" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Welcome to Google. Your new account comes with access to Google products, apps, and services.</td>
</tr>
<tr>
<td class="subheadline space6" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Here are a few tips to get you started.</td>
</tr>
<tr><td height=45></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style=padding-bottom:50px;>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr class=table-row>
<td class=table-cell style=height:50px></td>
</tr>
<tr class=table-row>
<td class=table-cell align=center>
<amp-img role=presentation width=48 height=48 src=https://www.gstatic.com/images/branding/product/2x/email_64dp.png style=width:48px;height:48px;text-align:center;border:none;font-size:9px class=CToWUd></amp-img>
</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px></td>
</tr>
<tr class=table-row>
<td class=table-cell style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 30px 0 30px; text-align:center; word-break:normal; direction:ltr;" dir=ltr>Get the most out of your Google Account</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px;line-height:4px;font-size:4px></td>
</tr>
<tr class=table-row>
<td class="table-cell subheadline space6 module_para" style="color:#5f6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal; direction:ltr;" dir=ltr>We&#39;ll send you personalized tips, news and recommendations from Google.</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:30px;></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 4px; height:4px;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<form class="sample-form hide-inputs" method=post action-xhr=https://www.google.com/dynamicmail/optin?tok=AMkCvlsFcJCAyjqfUBxSVGWAeBaDxQHayXK1a_iSygC0P5WIJzQpCgwOq_QGO4--tFaOgh2xFQ==&amp;ctrk=https://notifications.google.com/g/p/ANiao5q00zyMvvt-jpKiJuw2CiYJi4Zthu6gBCDeof77qPoiCT8zlM3PPyyOyRNfW-SdckVvjI80pItjYNDwllNhjx_HUgBJpo4LLItagUMohE1NqTkHrbn0SSI9IbhZ-_Z32JH9hateW-9WM7yDZMEE4XUZ9io7V5E5cTwFd0ZMyEVbrA0EQgEJz_92MjMdpA8yQp_w0s7QeryNRValYk4hDaOXA_O8adsO9Z6u7r1briiE>
<button [hidden]=cta_submit role="" tabindex="" on="tap:AMP.setState({sign_up: true, cta_submit: true})" type=submit value="" style="background-color:#1a73e8; border:1px solid #1a73e8; border-radius:4px; color:#FFFFFF; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:180px; font-weight:500; text-align:center; word-break:normal; direction:ltr;" class=localepading>Yes, keep me updated</button>
<div submitting>
<a style="background-color:#5F6368; border:1px solid #5F6368; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>One moment...</a>
</div>
<div submit-success>
<a style="background-color:#188038; border:1px solid #188038; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>You&#39;ve signed up</a>
<div class=table-row>
<div class=table-cell style=height:20px></div>
</div>
<table width=80% role=presentation align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto; width: 80%;">
<tr class=table-row>
<td align=center class=table-cell style="background-color: #ffffff; color: #5F6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size: 14px; line-height: 21px; text-align:center; margin: 0 auto; padding:0px;">You can unsubscribe at any time in the messages you receive. You can also <a href=https://notifications.google.com/g/p/ANiao5qjymW_t0uPjVYrfJYbgdo9waKj9lw3lnGdYyZInr8de_Lbr1yE5-ZbxhCGD_sfBGRNjMWFNQNqPltxa3ymYfMUw697szlzaHHLqyb_-RffxxmvXmBphBpgrfjKcOvo9nmgFhqWehnEc5wf8owpdvFlGxmpyKSAr-ORgcymVQWIVTorL5_w45Eyly2nT-mnfy-8ILD1ok6--PbSp_Kehm0iUDwWduXRajhouKlgIpN2WPGvmHxvwhm_TeBQjNfanPY1d5yM9Zk9ysa7fHSxIqNr4RM-_mJHEblWYw5JeG07Z__4Rl6qr7PSFZf5FD3CxeUBGSqOyEBE28fpvNuTmTI6e29NYCj4G2Gc14LCI4lcVnrmRoWpdsw4Mx_w89zRFQUOolVZF8SeAde9ifXDcDk-V37gi7FNp2QK2pqi7mgaERONST_QVWUPz7FRwwSPNUfUBlqz7vnsYrB1w0r5vogVgOrG_Qz-oR8wejXLYNKL2tOahU2v5E_EbvRi53_evxgB6oKnPWQODn6LFXi1yB0peGxcGLSuoT62HzV1l5DHvwZUh21HO0niraoX78aIBmWrLL1LKYmRnHnEeMVOCXWVmMaO6bsX8mMR9rc1yhbvJae4RpMjmJSkOfSIkoaWqaLAuIzMyqTjWOrjYE8WlQgSKZHs target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">manage your preferences</a>.
</td>
</tr>
</table>
</div>
<div submit-error>
<a href=https://notifications.google.com/g/p/ANiao5pVGL0PiiGdVXPsRPji2J57DhE_cOwjqvVmlV_SkJgD9ERjCRMztBNK_ZqlrfvueiW9mf2x1M82G2FmRZ8vAg1NIIsznBvgKBi-0v9H6sw1MM9AgKxvNFIyMZwb7KVyKIN4OueoBLXtGc75Ij8B3_rDFDwUFLVQk0XGjIbVBIdrRjTmI4JaecuUybTzIsJW5CfZp4FF-woB56D8Ra7fzEfABP_iIjX0Z5qfc7H9e4SHz0bwC7ozzxQxpghWAXrkTMq1VBjFg2agx6_j2J10T8u8t50jUg3ezt8cdUPzHkt-RcKXr1fYm7HWpiwGmWiaZo3pjPeFrhVrOyxkOXmHiwwmZMuliO6o6jHMCHgyf7e_kvNEWVKeacwO28xzSacgimjYDNzrBloPzUZ0hKzBHv7mc9SXE39ob38HRWa1yS-19fKb8L3L8rmrSIgrRmXstxdORZY5mQ96YgiRN1j0brm1Q-Bh-V5TtT3fcPrJFPFao9Wljs_SUxPJAUkypo7twzwt5mXZaT0wyf7Wn5i2HgzZ8dLpYI_naFYVlha5T2DW_pmWXQDsAebqhJngZFknzTas2x8lJZAtHOtXY35kRTMXZUu_QZ7_uEImb7lfSAQ3en5hWNbZZMbe4_k7vcinH6rfuwU target=_blank>
<table role=presentation cellspacing=0 cellpadding=0>
<tbody>
<tr>
<td style="text-align: center; background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:167px; padding:8px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal;direction:ltr;" dir=ltr class=cta_gl>Try again...</td>
</tr>
</tbody></table>
</a>
</div>
</form>
</td>
</tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 3px; height:3px; border-top-left-radius: 4px; border-top-right-radius: 4px; display:inline-block; text-align: center;"></td>
</tr>
</table>
</table>
</td>
</tr>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/google-logo.png style="width: 48px; height:48px; text-align: center; border: none; font-size:9px;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Stay in the know with the Google app</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Stay in the know with the Google app</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Find quick answers, explore your interests, and stay up to date.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td class=space4 style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw" style="height:48px; v-text-anchor:middle; width:150px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Try it</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod2_mobile2 enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Try it
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
<tr><td height=50></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=514 height=207 src=https://www.gstatic.com/gumdrop/files/apps-icons-image-2x-wd972px-ht390px.png style="width: 100%; text-align: center; border: none; border-top-left-radius: 8px; border-top-right-radius: 8px;" layout=responsive>
</td>
</tr>
<tr><td height=7></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">More from Google</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>More from Google</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Discover the latest apps from Google.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V" style="height:48px; v-text-anchor:middle; width:160px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For Android</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; direction:ltr;">
For Android
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
<span style="" class=addingspace>  </span>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94" style="height:48px; v-text-anchor:middle; width:130px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For iOS</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94 target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8;; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; white-space:normal; direction:ltr;">
For iOS
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/security-logo.png style="width: 48px; height:48px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Review and change your privacy and security options to make <span style="white-space:nowrap; " class="">Google</span> work better <span style="white-space:nowrap; " class="">for you.</span></td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding-top: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA" style="height:48px; v-text-anchor:middle; width:180px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Confirm</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod4_mobile enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Confirm
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=480 style="border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
<!--[if mso]>
<td style="margin-bottom:67px; padding: 21px 10px 35px 20px;"> <amp-img role="presentation" class="fa_mobile" width="24" height="24" src="https://www.gstatic.com/gumdrop/files/help-outline.png" style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<![endif]-->
<!--[if !mso]><!-->
<td style="padding: 47px 10px 40px 20px;" valign=top> <amp-img role=presentation class=fa_mobile width=24 height=24 src=https://www.gstatic.com/gumdrop/files/help-outline.png style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<!--<![endif]-->
<td valign=top>
<!--[if mso]>
<div class="device_txt" style="margin-bottom:15px; padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:18px; padding-bottom:12px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Find answers</div>
<![endif]-->
<!--[if !mso]><!-->
<div class=device_txt style="padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:45px; padding-bottom:12px; word-break:normal;direction:ltr;" dir=ltr>Find answers</div>
<!--<![endif]-->
<!--[if mso]>
<div class="subheadline space7" style="margin-bottom:20px; padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:35px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Visit the <a href="https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ" target="_blank" style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<![endif]-->
<!--[if !mso]><!-->
<div class="subheadline space7" style="padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:50px; word-break:normal;direction:ltr;" dir=ltr>Visit the <a href=https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<!--<![endif]-->
</td>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
</tr>
</table>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=30></td></tr>
<tr>
<td width=134 height=46 align=center style="font-size:8px; word-break:normal;direction:ltr;" dir=ltr> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-footer.png style="width: 82px; height:26px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:12px; line-height:18px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Replies to this email aren&#39;t monitored. If you have a question about your new account, the <a href=https://notifications.google.com/g/p/ANiao5rTjkBxyW3fJJZoX4P9D_6vTIpEyPkjkx72A5ZOucL-qnhiUap2yhWQsEAbi5j-mOEqpmaB9UC7BGsgXJmh1Aq12RIOoGT-Qedihwobq8PGaxMuXKR2Tv-NrcMz1qGxoGTMSy6VA6_GEsG84AnHYYhA9BKaTq5HRC7kPrAbVD7s2JcMH0NcaAH_uzUCAu7UxIbdxjGnFin-oRS-Guve3IIpVJivRvxXA_10nzZgIHE2uwHI7GsEuM4DqBApZnGckanWMnQhqznDpXEYL4AFj6sISuMHWRFD3_DWX9KxQ-JiqxkM-Gjdgpityw target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> likely has the answer you&#39;re looking for.</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 valign=middle style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:10px; line-height:15px; margin:0; text-align:center" align=center>
<span style="font-size:inherit; color:inherit; font-weight:inherit; line-height:inherit; font-family:inherit;">Google LLC<br>1600 Amphitheatre Parkway,<br>Mountain View, CA 94043</span>
<br><br><span style=word-break:normal;direction:ltr; dir=ltr>This email was sent to you because you created a Google Account.</span></td>
</tr>
</table>
</td>
</tr>
<tr><td height=18></td></tr>
</table>
<div style="display:none; white-space:nowrap; font:15px courier; line-height:0;">
                            
                             
</div>
<amp-img alt="" height=1 width=3 src=https://notifications.google.com/g/img/ANiao5redogZGkiXNpH8PTOz6QtmTWmDl5Kn_b-3kYHZEpRf5kYRMZOqPG7UV5ATGDUF-xPoFCENQragusUa3fuTQ31HzvUNEm--NO6eqkX1t8aqN87kYcIef-IsUSl-vHPhy8GyyWK6r6h3huKtutBqC4tTAwVNqRai_7Ir3A.gif></body>
</html> + From 8f60790c2f76b7ebb539032b060b2cd3c868bd59 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 10:28:18 +0500 Subject: [PATCH 05/12] combined email tests --- .../features/web/email_tests.feature | 6 --- .../features/web/web_tests.feature | 17 +++++- .../test_steps/test_site_steps.py | 2 - .../frontend/common/step_definitions/email.py | 27 ++++++---- main/utils/email_reader.py | 20 ++++--- test_data/files/email_data.json | 54 ++++++------------- test_data/files/email_reader.txt | 51 ++++++------------ 7 files changed, 73 insertions(+), 104 deletions(-) delete mode 100644 frontend/test_project/features/web/email_tests.feature diff --git a/frontend/test_project/features/web/email_tests.feature b/frontend/test_project/features/web/email_tests.feature deleted file mode 100644 index 59167e71..00000000 --- a/frontend/test_project/features/web/email_tests.feature +++ /dev/null @@ -1,6 +0,0 @@ -@nondestructive @email_tests -Feature: Email Test - - @email @automated - Scenario: Email verification - When I get email for 'moduspytestboilerplate@gmail.com' \ No newline at end of file diff --git a/frontend/test_project/features/web/web_tests.feature b/frontend/test_project/features/web/web_tests.feature index 57854169..a7163dd6 100644 --- a/frontend/test_project/features/web/web_tests.feature +++ b/frontend/test_project/features/web/web_tests.feature @@ -173,4 +173,19 @@ Feature: OrangeHRM Login and Modus QA blog And I click item 'Contractor. Understanding' for element 'Modus_Site > Careers > form_dropdown' And I click item 'Yes' for element 'Modus_Site > Careers > position_dropdown' And I click item 'data protection apps upon hire' for element 'Modus_Site > Careers > form_dropdown' - And I click item 'Yes' for element 'Modus_Site > Careers > protection_dropdown' \ No newline at end of file + And I click item 'Yes' for element 'Modus_Site > Careers > protection_dropdown' + + + @email @automated @firefox + Scenario: Email Verification with email link + Given I set web base url '{%BASE_URL%}' + And Browser is maximized + And The title is 'OrangeHRM' + When The element 'OrangeHRM > username' is displayed + And I set text '{%HRM_USER_NAME%}' to field 'OrangeHRM > username' + And I set text '{%HRM_PASSWORD%}' to field 'OrangeHRM > password' + And I click on element 'OrangeHRM > login_button' + Then The title is 'OrangeHRM' + And The page url contains 'dashboard' + When I get about link from email 'moduspytestboilerplate@gmail.com' + Then I reopen the email link \ No newline at end of file diff --git a/frontend/test_project/step_definitions/test_steps/test_site_steps.py b/frontend/test_project/step_definitions/test_steps/test_site_steps.py index 49061c4e..20d2baca 100644 --- a/frontend/test_project/step_definitions/test_steps/test_site_steps.py +++ b/frontend/test_project/step_definitions/test_steps/test_site_steps.py @@ -6,8 +6,6 @@ scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/web/web_tests.feature")) scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/visual/visual_tests.feature")) -scenarios(os.path.join(PROJECT_DIR, "frontend/test_project/features/web/email_tests.feature")) - diff --git a/main/frontend/common/step_definitions/email.py b/main/frontend/common/step_definitions/email.py index 0ce48fc3..7503f1ab 100644 --- a/main/frontend/common/step_definitions/email.py +++ b/main/frontend/common/step_definitions/email.py @@ -1,13 +1,13 @@ -import structlog - import base64 -import os, re +import json +import os +import re import time import pytest -import json - +import structlog from bs4 import BeautifulSoup +from collections import defaultdict from main.utils.email_reader import create_json @@ -18,9 +18,12 @@ from main.frontend.common.helpers.selenium_generics import SeleniumGenerics logger = structlog.get_logger(__name__) +pytest.globalDict = defaultdict() -@when(parsers.re("I get email for '(?P.*)'"), +@when(parsers.re("I get about link from email '(?P.*)'"), + converters=dict(user_type=str)) +@then(parsers.re("I get about link from email '(?P.*)'"), converters=dict(user_type=str)) def check_email(user_type, selenium_generics: SeleniumGenerics): time.sleep(5) @@ -38,8 +41,8 @@ def check_email(user_type, selenium_generics: SeleniumGenerics): data = json.load(f) for i in data: value = i - if "Test Data" in value["Subject"] or "Test Data" in value["Subject"] and \ - "noreply@test.com" in value["From"] and date_today in value["Date"] or \ + if "Test Project Data" in value["Subject"] or "Test Data" in value["Subject"] and \ + "tauqirsarwar1@gmail.com" in value["From"] and date_today in value["Date"] or \ date_yesterday in value["Date"] and user_type in value["To"]: decoded_data = base64.b64decode(value["Message"]) soup = BeautifulSoup(decoded_data, "lxml") @@ -57,7 +60,7 @@ def check_email(user_type, selenium_generics: SeleniumGenerics): email_body) new_url = '' for j in url: - if 'Test Data' in j or 'Test Data' in j: + if 'Test Project Data' in j or 'Test Data' in j: new_url = j final_url = str(new_url).replace('amp;', '') pytest.globalDict['final_url'] = final_url @@ -65,3 +68,9 @@ def check_email(user_type, selenium_generics: SeleniumGenerics): break f.close() + + +@then('I reopen the email link') +def reopen_final_url(selenium_generics: SeleniumGenerics): + final_url = pytest.globalDict['final_url'] + selenium_generics.navigate_to_url(final_url) diff --git a/main/utils/email_reader.py b/main/utils/email_reader.py index ffbdad34..b50d03c0 100644 --- a/main/utils/email_reader.py +++ b/main/utils/email_reader.py @@ -4,21 +4,20 @@ import pickle import os.path import json + SCOPES = ['https://www.googleapis.com/auth/gmail.readonly'] PROJECT_DIR = os.getcwd() test_data_dir_utils = os.path.join(PROJECT_DIR, "main/utils") test_data_dir_email = os.path.join(PROJECT_DIR, "test_data/files") -# if 'utils' in PROJECT_DIRECTORY: -# PROJECT_DIR = PROJECT_DIRECTORY.replace("utils", "test_data") print(PROJECT_DIR) def get_email(): count = 0 creds = None - with open(test_data_dir_utils+'/token.pickle', 'rb') as token: + with open(test_data_dir_utils + '/token.pickle', 'rb') as token: creds = pickle.load(token) - with open(test_data_dir_utils+'/cred.json', 'r') as infile: + with open(test_data_dir_utils + '/cred.json', 'r') as infile: my_data = json.load(infile) if not creds.valid: @@ -29,16 +28,15 @@ def get_email(): if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: - # creds.refresh(Request()) - creds = None - flow = InstalledAppFlow.from_client_secrets_file(test_data_dir_utils+'/cred.json', scopes=SCOPES) - creds = flow.run_local_server(port=0, timeout_seconds=10) - session = flow.authorized_session() + creds.refresh(Request()) + else: + flow = InstalledAppFlow.from_client_secrets_file(test_data_dir_utils + '/cred.json', SCOPES) + creds = flow.run_local_server(port=0, timeout_seconds=20) - with open(test_data_dir_utils+'/token.pickle', 'wb') as token: + with open(test_data_dir_utils + '/token.pickle', 'wb') as token: pickle.dump(creds, token) my_data['installed']['refresh_token'] = creds.refresh_token - with open(test_data_dir_utils+'/cred.json', 'w') as outfile: + with open(test_data_dir_utils + '/cred.json', 'w') as outfile: json.dump(my_data, outfile, indent=4) service = build('gmail', 'v1', credentials=creds) diff --git a/test_data/files/email_data.json b/test_data/files/email_data.json index 19387c40..77deaae1 100644 --- a/test_data/files/email_data.json +++ b/test_data/files/email_data.json @@ -1,50 +1,26 @@ [ { - "Subject": "Action Required - Your OAuth Verification Request", - "From": "API OAuth Dev Verification ", + "Subject": "Test Data", + "From": "tauqir sarwar ", "To": "moduspytestboilerplate@gmail.com", - "Date": "Thu, 11 Apr 2024 01:30:39 -0700", - "Message": "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", - "Url": "<p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P>" + "Date": "Mon, 15 Apr 2024 10:04:25 +0500", + "Message": "VGVzdCBEYXRhDQoNCmh0dHBzOi8vbW9kdXNjcmVhdGUuY29tL2Fib3V0Lw0K", + "Url": "PGRpdiBkaXI9Imx0ciI+VGVzdCBEYXRhPGJyPjxkaXY+PGJyPjwvZGl2PjxkaXY+PGEgaHJlZj0iaHR0cHM6Ly9tb2R1c2NyZWF0ZS5jb20vYWJvdXQvIj5odHRwczovL21vZHVzY3JlYXRlLmNvbS9hYm91dC88L2E+PGJyPjwvZGl2PjxkaXY+PGJyPjwvZGl2PjwvZGl2Pg0K" }, { - "Subject": "Action Required - Your OAuth Verification Request", - "From": "API OAuth Dev Verification ", + "Subject": "Test Project Data", + "From": "tauqir sarwar ", "To": "moduspytestboilerplate@gmail.com", - "Date": "Thu, 11 Apr 2024 01:19:18 -0700", - "Message": "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", - "Url": "<p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P>" + "Date": "Mon, 15 Apr 2024 09:02:37 +0500", + "Message": "VGVzdCBQcm9qZWN0IERhdGENCg==", + "Url": "PGRpdiBkaXI9Imx0ciI+VGVzdCBQcm9qZWN0IERhdGE8L2Rpdj4NCg==" }, { - "Subject": "Security alert", - "From": "Google ", + "Subject": "test subject", + "From": "tauqir sarwar ", "To": "moduspytestboilerplate@gmail.com", - "Date": "Thu, 07 Mar 2024 09:40:59 GMT", - "Message": "W2ltYWdlOiBHb29nbGVdDQpOZXcgcGFzc2tleSBhZGRlZCB0byB5b3VyIGFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KSWYgeW91IGRpZG7igJl0IGFkZCBhIHBhc3NrZXksIHNvbWVvbmUgbWlnaHQgYmUgdXNpbmcgeW91ciBhY2NvdW50LiBDaGVjayBhbmQNCnNlY3VyZSB5b3VyIGFjY291bnQgbm93Lg0KQ2hlY2sgYWN0aXZpdHkNCjxodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20vQWNjb3VudENob29zZXI/RW1haWw9bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb20mY29udGludWU9aHR0cHM6Ly9teWFjY291bnQuZ29vZ2xlLmNvbS9hbGVydC9udC8xNzA5ODA0NDU5NjIxP3JmbiUzRDM2NCUyNnJmbmMlM0QxJTI2ZWlkJTNEMjk3NjEwNjI0OTY2Nzc3OTY5OSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K", - "Url": "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" - }, - { - "Subject": "Security alert", - "From": "Google ", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Thu, 07 Mar 2024 07:26:07 GMT", - "Message": "W2ltYWdlOiBHb29nbGVdDQptb2R1cy1hcHAgd2FzIGdyYW50ZWQgYWNjZXNzIHRvIHlvdXIgR29vZ2xlIEFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KDQpJZiB5b3UgZGlkIG5vdCBncmFudCBhY2Nlc3MsIHlvdSBzaG91bGQgY2hlY2sgdGhpcyBhY3Rpdml0eSBhbmQgc2VjdXJlIHlvdXINCmFjY291bnQuDQpDaGVjayBhY3Rpdml0eQ0KPGh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9BY2NvdW50Q2hvb3Nlcj9FbWFpbD1tb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbSZjb250aW51ZT1odHRwczovL215YWNjb3VudC5nb29nbGUuY29tL2FsZXJ0L250LzE3MDk3OTYzNjcwMDA/cmZuJTNEMTI3JTI2cmZuYyUzRDElMjZlaWQlM0QtMjM3Mzc5MzMxNzk3MTIzODg4MSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K", - "Url": "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" - }, - { - "Subject": "test", - "From": "Modus Pytest Boilerplate ", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Thu, 7 Mar 2024 12:07:37 +0500", - "Message": "dGVzdA0K", - "Url": "PGRpdiBkaXI9Imx0ciI+dGVzdDwvZGl2Pg0K" - }, - { - "Subject": "Modus Pytest, finish setting up your new Google Account", - "From": "Google Community Team ", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Wed, 06 Mar 2024 22:58:19 -0800", - "Message": "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", - "Url": "<!doctype html>
<html ⚡4email data-css-strict lang=en>
<head>
<meta charset=utf-8>
<script async src=https://cdn.ampproject.org/v0.js></script>
<script custom-element=amp-bind src=https://cdn.ampproject.org/v0/amp-bind-0.1.js async></script>
<script async custom-element=amp-form src=https://cdn.ampproject.org/v0/amp-form-0.1.js></script>
<style amp4email-boilerplate>body{visibility:hidden}</style>
<style amp-custom>
body{text-decoration:none;}
td.table-cell.subheadline.space6.module_para {
padding: 0 50px;
}
.pdngrtl{padding:7px 24px 7px 24px}
.localepading{padding:8px 26px 7px 26px; font-size:16px;}
.space6{padding:0 80px 0 80px;}
.space2{padding:0 70px 0 70px;}
.widthmin{min-width:115px;}
.addingspace{width:6px; display: inline-block;}
@media only screen and (max-width: 767px){
.btn_mod2_mobile1{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod2_mobile2{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod3_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod4_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.pdngrtl{padding:7px 11px 7px 11px}
.space1{height:19px ;}
.space2{padding:3px 35px 0 35px ;}
.space3{padding-top: 22px ;}
.space4{padding: 6px 0 0 0 ;}
.space5{padding-top: 17px ;}
.space6{padding:0 35px 0 35px ;}
.space7{padding-right: 0px ;}
}
@media screen and (min-resolution: 288dpi) {
.device_txt{font-size:26px;}
}
/* Potrait for iPhone */
@media only screen and (device-width: 375px) and (orientation:portrait){
.fmd_mobile {padding-top:5px ;color:red ;}
}
body{text-decoration:none;}
</style>
<!--[if gte mso 9]>
<xml>
<o:OfficeDocumentSettings>
<o:AllowPNG/>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
<![endif]-->
<!--[if mso]>
<style>a{color:4285f4; text-decoration:none;}</style>
<![endif]-->
</head>
<body class=body_wrapper style="padding: 0 6px;">
<div style="font-size: 0px; line-height:0px; color: #ffffff; display: none;">                                                                                                                                                                                                                                                                                                                                                                                                                                                                           </div>
<table role=presentation class=body_size border=0 cellspacing=0 cellpadding=0 align=center width=100% bgcolor=#ffffff style="background: #ffffff; width:100%;max-width: 520px;">
<tr><td align=center style="padding-top: 20px;"> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-header.png style="width: 82px; height:26px; text-align: center; border: none;">
</td></tr>
<tr><td class=space1 height=15></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=516 height=109 src=https://www.gstatic.com/gumdrop/files/banner.png style="width: 100%; text-align: center; border: none;" layout=responsive>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<!--[if mso]>
<td align="center" class="greeting_name space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; padding:0 80px 20px 80px; text-align:center;word-break:normal;direction:ltr;' dir="ltr">
Hi Modus Pytest,
</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="greeting_name space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>
Hi Modus Pytest,
</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space2" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Welcome to Google. Your new account comes with access to Google products, apps, and services.</td>
</tr>
<tr>
<td class="subheadline space6" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Here are a few tips to get you started.</td>
</tr>
<tr><td height=45></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style=padding-bottom:50px;>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr class=table-row>
<td class=table-cell style=height:50px></td>
</tr>
<tr class=table-row>
<td class=table-cell align=center>
<amp-img role=presentation width=48 height=48 src=https://www.gstatic.com/images/branding/product/2x/email_64dp.png style=width:48px;height:48px;text-align:center;border:none;font-size:9px class=CToWUd></amp-img>
</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px></td>
</tr>
<tr class=table-row>
<td class=table-cell style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 30px 0 30px; text-align:center; word-break:normal; direction:ltr;" dir=ltr>Get the most out of your Google Account</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px;line-height:4px;font-size:4px></td>
</tr>
<tr class=table-row>
<td class="table-cell subheadline space6 module_para" style="color:#5f6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal; direction:ltr;" dir=ltr>We&#39;ll send you personalized tips, news and recommendations from Google.</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:30px;></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 4px; height:4px;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<form class="sample-form hide-inputs" method=post action-xhr=https://www.google.com/dynamicmail/optin?tok=AMkCvlsFcJCAyjqfUBxSVGWAeBaDxQHayXK1a_iSygC0P5WIJzQpCgwOq_QGO4--tFaOgh2xFQ==&amp;ctrk=https://notifications.google.com/g/p/ANiao5q00zyMvvt-jpKiJuw2CiYJi4Zthu6gBCDeof77qPoiCT8zlM3PPyyOyRNfW-SdckVvjI80pItjYNDwllNhjx_HUgBJpo4LLItagUMohE1NqTkHrbn0SSI9IbhZ-_Z32JH9hateW-9WM7yDZMEE4XUZ9io7V5E5cTwFd0ZMyEVbrA0EQgEJz_92MjMdpA8yQp_w0s7QeryNRValYk4hDaOXA_O8adsO9Z6u7r1briiE>
<button [hidden]=cta_submit role="" tabindex="" on="tap:AMP.setState({sign_up: true, cta_submit: true})" type=submit value="" style="background-color:#1a73e8; border:1px solid #1a73e8; border-radius:4px; color:#FFFFFF; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:180px; font-weight:500; text-align:center; word-break:normal; direction:ltr;" class=localepading>Yes, keep me updated</button>
<div submitting>
<a style="background-color:#5F6368; border:1px solid #5F6368; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>One moment...</a>
</div>
<div submit-success>
<a style="background-color:#188038; border:1px solid #188038; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>You&#39;ve signed up</a>
<div class=table-row>
<div class=table-cell style=height:20px></div>
</div>
<table width=80% role=presentation align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto; width: 80%;">
<tr class=table-row>
<td align=center class=table-cell style="background-color: #ffffff; color: #5F6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size: 14px; line-height: 21px; text-align:center; margin: 0 auto; padding:0px;">You can unsubscribe at any time in the messages you receive. You can also <a href=https://notifications.google.com/g/p/ANiao5qjymW_t0uPjVYrfJYbgdo9waKj9lw3lnGdYyZInr8de_Lbr1yE5-ZbxhCGD_sfBGRNjMWFNQNqPltxa3ymYfMUw697szlzaHHLqyb_-RffxxmvXmBphBpgrfjKcOvo9nmgFhqWehnEc5wf8owpdvFlGxmpyKSAr-ORgcymVQWIVTorL5_w45Eyly2nT-mnfy-8ILD1ok6--PbSp_Kehm0iUDwWduXRajhouKlgIpN2WPGvmHxvwhm_TeBQjNfanPY1d5yM9Zk9ysa7fHSxIqNr4RM-_mJHEblWYw5JeG07Z__4Rl6qr7PSFZf5FD3CxeUBGSqOyEBE28fpvNuTmTI6e29NYCj4G2Gc14LCI4lcVnrmRoWpdsw4Mx_w89zRFQUOolVZF8SeAde9ifXDcDk-V37gi7FNp2QK2pqi7mgaERONST_QVWUPz7FRwwSPNUfUBlqz7vnsYrB1w0r5vogVgOrG_Qz-oR8wejXLYNKL2tOahU2v5E_EbvRi53_evxgB6oKnPWQODn6LFXi1yB0peGxcGLSuoT62HzV1l5DHvwZUh21HO0niraoX78aIBmWrLL1LKYmRnHnEeMVOCXWVmMaO6bsX8mMR9rc1yhbvJae4RpMjmJSkOfSIkoaWqaLAuIzMyqTjWOrjYE8WlQgSKZHs target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">manage your preferences</a>.
</td>
</tr>
</table>
</div>
<div submit-error>
<a href=https://notifications.google.com/g/p/ANiao5pVGL0PiiGdVXPsRPji2J57DhE_cOwjqvVmlV_SkJgD9ERjCRMztBNK_ZqlrfvueiW9mf2x1M82G2FmRZ8vAg1NIIsznBvgKBi-0v9H6sw1MM9AgKxvNFIyMZwb7KVyKIN4OueoBLXtGc75Ij8B3_rDFDwUFLVQk0XGjIbVBIdrRjTmI4JaecuUybTzIsJW5CfZp4FF-woB56D8Ra7fzEfABP_iIjX0Z5qfc7H9e4SHz0bwC7ozzxQxpghWAXrkTMq1VBjFg2agx6_j2J10T8u8t50jUg3ezt8cdUPzHkt-RcKXr1fYm7HWpiwGmWiaZo3pjPeFrhVrOyxkOXmHiwwmZMuliO6o6jHMCHgyf7e_kvNEWVKeacwO28xzSacgimjYDNzrBloPzUZ0hKzBHv7mc9SXE39ob38HRWa1yS-19fKb8L3L8rmrSIgrRmXstxdORZY5mQ96YgiRN1j0brm1Q-Bh-V5TtT3fcPrJFPFao9Wljs_SUxPJAUkypo7twzwt5mXZaT0wyf7Wn5i2HgzZ8dLpYI_naFYVlha5T2DW_pmWXQDsAebqhJngZFknzTas2x8lJZAtHOtXY35kRTMXZUu_QZ7_uEImb7lfSAQ3en5hWNbZZMbe4_k7vcinH6rfuwU target=_blank>
<table role=presentation cellspacing=0 cellpadding=0>
<tbody>
<tr>
<td style="text-align: center; background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:167px; padding:8px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal;direction:ltr;" dir=ltr class=cta_gl>Try again...</td>
</tr>
</tbody></table>
</a>
</div>
</form>
</td>
</tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 3px; height:3px; border-top-left-radius: 4px; border-top-right-radius: 4px; display:inline-block; text-align: center;"></td>
</tr>
</table>
</table>
</td>
</tr>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/google-logo.png style="width: 48px; height:48px; text-align: center; border: none; font-size:9px;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Stay in the know with the Google app</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Stay in the know with the Google app</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Find quick answers, explore your interests, and stay up to date.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td class=space4 style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw" style="height:48px; v-text-anchor:middle; width:150px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Try it</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod2_mobile2 enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Try it
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
<tr><td height=50></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=514 height=207 src=https://www.gstatic.com/gumdrop/files/apps-icons-image-2x-wd972px-ht390px.png style="width: 100%; text-align: center; border: none; border-top-left-radius: 8px; border-top-right-radius: 8px;" layout=responsive>
</td>
</tr>
<tr><td height=7></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">More from Google</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>More from Google</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Discover the latest apps from Google.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V" style="height:48px; v-text-anchor:middle; width:160px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For Android</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; direction:ltr;">
For Android
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
<span style="" class=addingspace>  </span>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94" style="height:48px; v-text-anchor:middle; width:130px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For iOS</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94 target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8;; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; white-space:normal; direction:ltr;">
For iOS
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/security-logo.png style="width: 48px; height:48px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Review and change your privacy and security options to make <span style="white-space:nowrap; " class="">Google</span> work better <span style="white-space:nowrap; " class="">for you.</span></td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding-top: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA" style="height:48px; v-text-anchor:middle; width:180px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Confirm</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod4_mobile enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Confirm
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=480 style="border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
<!--[if mso]>
<td style="margin-bottom:67px; padding: 21px 10px 35px 20px;"> <amp-img role="presentation" class="fa_mobile" width="24" height="24" src="https://www.gstatic.com/gumdrop/files/help-outline.png" style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<![endif]-->
<!--[if !mso]><!-->
<td style="padding: 47px 10px 40px 20px;" valign=top> <amp-img role=presentation class=fa_mobile width=24 height=24 src=https://www.gstatic.com/gumdrop/files/help-outline.png style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<!--<![endif]-->
<td valign=top>
<!--[if mso]>
<div class="device_txt" style="margin-bottom:15px; padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:18px; padding-bottom:12px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Find answers</div>
<![endif]-->
<!--[if !mso]><!-->
<div class=device_txt style="padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:45px; padding-bottom:12px; word-break:normal;direction:ltr;" dir=ltr>Find answers</div>
<!--<![endif]-->
<!--[if mso]>
<div class="subheadline space7" style="margin-bottom:20px; padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:35px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Visit the <a href="https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ" target="_blank" style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<![endif]-->
<!--[if !mso]><!-->
<div class="subheadline space7" style="padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:50px; word-break:normal;direction:ltr;" dir=ltr>Visit the <a href=https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<!--<![endif]-->
</td>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
</tr>
</table>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=30></td></tr>
<tr>
<td width=134 height=46 align=center style="font-size:8px; word-break:normal;direction:ltr;" dir=ltr> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-footer.png style="width: 82px; height:26px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:12px; line-height:18px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Replies to this email aren&#39;t monitored. If you have a question about your new account, the <a href=https://notifications.google.com/g/p/ANiao5rTjkBxyW3fJJZoX4P9D_6vTIpEyPkjkx72A5ZOucL-qnhiUap2yhWQsEAbi5j-mOEqpmaB9UC7BGsgXJmh1Aq12RIOoGT-Qedihwobq8PGaxMuXKR2Tv-NrcMz1qGxoGTMSy6VA6_GEsG84AnHYYhA9BKaTq5HRC7kPrAbVD7s2JcMH0NcaAH_uzUCAu7UxIbdxjGnFin-oRS-Guve3IIpVJivRvxXA_10nzZgIHE2uwHI7GsEuM4DqBApZnGckanWMnQhqznDpXEYL4AFj6sISuMHWRFD3_DWX9KxQ-JiqxkM-Gjdgpityw target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> likely has the answer you&#39;re looking for.</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 valign=middle style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:10px; line-height:15px; margin:0; text-align:center" align=center>
<span style="font-size:inherit; color:inherit; font-weight:inherit; line-height:inherit; font-family:inherit;">Google LLC<br>1600 Amphitheatre Parkway,<br>Mountain View, CA 94043</span>
<br><br><span style=word-break:normal;direction:ltr; dir=ltr>This email was sent to you because you created a Google Account.</span></td>
</tr>
</table>
</td>
</tr>
<tr><td height=18></td></tr>
</table>
<div style="display:none; white-space:nowrap; font:15px courier; line-height:0;">
                            
                             
</div>
<amp-img alt="" height=1 width=3 src=https://notifications.google.com/g/img/ANiao5redogZGkiXNpH8PTOz6QtmTWmDl5Kn_b-3kYHZEpRf5kYRMZOqPG7UV5ATGDUF-xPoFCENQragusUa3fuTQ31HzvUNEm--NO6eqkX1t8aqN87kYcIef-IsUSl-vHPhy8GyyWK6r6h3huKtutBqC4tTAwVNqRai_7Ir3A.gif></body>
</html>" + "Date": "Mon, 15 Apr 2024 08:58:38 +0500", + "Message": "dGVzdCBib2R5DQo=", + "Url": "PGRpdiBkaXI9Imx0ciI+dGVzdCBib2R5PC9kaXY+DQo=" } ] \ No newline at end of file diff --git a/test_data/files/email_reader.txt b/test_data/files/email_reader.txt index 73f04c90..ec0054c8 100644 --- a/test_data/files/email_reader.txt +++ b/test_data/files/email_reader.txt @@ -1,42 +1,21 @@ -Subject : Action Required - Your OAuth Verification Request -From : API OAuth Dev Verification +Subject : Test Data +From : tauqir sarwar To : moduspytestboilerplate@gmail.com -Date : Thu, 11 Apr 2024 01:30:39 -0700 -Message : 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 -Url : <p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P> +Date : Mon, 15 Apr 2024 10:04:25 +0500 +Message : VGVzdCBEYXRhDQoNCmh0dHBzOi8vbW9kdXNjcmVhdGUuY29tL2Fib3V0Lw0K +Url : PGRpdiBkaXI9Imx0ciI+VGVzdCBEYXRhPGJyPjxkaXY+PGJyPjwvZGl2PjxkaXY+PGEgaHJlZj0iaHR0cHM6Ly9tb2R1c2NyZWF0ZS5jb20vYWJvdXQvIj5odHRwczovL21vZHVzY3JlYXRlLmNvbS9hYm91dC88L2E+PGJyPjwvZGl2PjxkaXY+PGJyPjwvZGl2PjwvZGl2Pg0K -Subject : Action Required - Your OAuth Verification Request -From : API OAuth Dev Verification +Subject : Test Project Data +From : tauqir sarwar To : moduspytestboilerplate@gmail.com -Date : Thu, 11 Apr 2024 01:19:18 -0700 -Message : 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 -Url : <p><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="width=device-width,initial-scale=1,user-scalable=yes" name=viewport><title></title>
<style type="text/css"></style>
<img height=1 src="https://www.google.com/appserve/mkt/proof/img/JWHpnYa1GmNn9lv36PT64XA9-IX3.gif" width=3>
</p><div style="height:0px; font-size:0px; max-height:0px; min-height: 0px; line-height:0px; width: 100%; color: #fff; display:none;">Appeal Received</div>


  
    
      
    
    
      
    
  
<table align=center border=0 cellpadding=0 cellspacing=0 class="outer_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; background:#fafafa; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0; mso-table-lspace:0; mso-table-rspace:0; padding:0; width:100%" width="100%"><tbody><tr><td class="outer_wrapper_td" style="border-collapse:collapse">
      
        
          
            
          
          
            
          
        
      <table align=center border=0 cellpadding=0 cellspacing=0 class="inner_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse">
            
              
                
                  
                
              
            <table align=center cellpadding=0 cellspacing=0 class=outer style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="two-column logo_holder_container" style="border-collapse:collapse; font-size:0; padding:32px 5px 28px 5px; text-align:center">
                  <div class=column style="display:inline-block; float:left; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:2px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_holder flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td style="border-collapse:collapse; text-align:left;"><img alt="Google Cloud Platform" height=auto src="http://services.google.com/fh/files/emails/gcp_new_logo.png" style="-ms-interpolation-mode:bicubic; height:auto; outline:none; text-decoration:none" width=271></td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  

                  <div class=column style="display:inline-block; float:right; max-width:290px; vertical-align:top; width:100%" valign=top width="100%">
                    
                      
                        
                          
                        
                      
                    <table cellpadding=0 cellspacing=0 style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Roboto, arial; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=inner style="border-collapse:collapse; font-size:15px; padding:10px 0 0 0">
                          
                            
                              
                                
                              
                            
                          <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td class="logo_right_holder_td" style="border-collapse:collapse; padding-right:0; padding-top:0">
                                
                                  
                                    
                                      
                                    
                                  
                                <table border=0 cellpadding=0 cellspacing=0 class="logo_right_holder_inner flexible" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:roboto, arial; font-weight:500; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=right class="logo_right_holder_inner_td" style="border-collapse:collapse; color:#90a4ae; font-family:Roboto, arial; font-size:15px; font-weight:bold; line-height:16px; text-align:right" width="100%"><a class="console_text" href="https://console.cloud.google.com" style="color:#2979ff; font-family:Roboto, arial; font-size:14px; font-weight:500; line-height:16px; text-decoration:none" target="_blank">MY CONSOLE</a></td></tr></tbody></table>
                                </td></tr></tbody></table>
                          </td></tr></tbody></table>
                  </div>
                  </td></tr></tbody></table>

            
              
                
                  
                
              
            <table align=center bgcolor="#ffffff" border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0;  border-collapse:collapse; border-left:1px solid #dddddd; border-right:1px solid #dddddd; border-top:1px solid #dddddd; font-family:Arial, sans-serif; font-weight:normal; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%;  -khtml-border-radius:5px 5px 0 0; -moz-border-radius:5px 5px 0 0; -ms-border-radius:5px 5px 0 0; -o-border-radius:5px 5px 0 0; -webkit-border-radius:5px 5px 0 0; background-color: #ffffff;" width="100%"><tbody><tr><td border=0 cellpadding=0 cellspacing=0 style="border-collapse:collapse; -premailer-cellpadding:0; -premailer-cellspacing:0;">
                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style=" max-width:600px; border-collapse:collapse; font-size:16px; padding-right:40px;" width=600>
                        
                          
                            
                              
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td align=left style="max-width:69px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:33px" width=69><img alt=Notification height=18 src="http://services.google.com/fh/files/emails/hero_icon_project_reinstatement.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none;" width=17></td><td align=left style="width:100%; max-width:531px; font-family: Roboto,arial; font-weight:500; font-size: 14px; color: #FFFFFF; letter-spacing: 0.6px;  border-collapse:collapse; padding-top:33px;" width=531>Your Google Cloud Project 443927617801</td></tr></tbody></table>

                        
                          
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="background-color:#3b78e7; max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; mso-table-lspace:0; mso-table-rspace:0; width: 100%; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;  " width=600><tbody><tr><td align=left style="width:100%; max-width:531px; padding-right:12px; padding-left:40px; border-collapse:collapse; padding-top:13px; padding-bottom:24px; font-family: Roboto,arial; font-weight:500; color:#ffffff; line-height:32px; font-size:24px;" width=531>&nbsp; [Action Needed]</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 style="max-width:600px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=600><tbody><tr><td style="width:100%; max-width:520px; padding-top:25px;padding-left:40px; padding-right:40px;" width=520>
                        
                          
                            
                              
                            
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 style="max-width:520px; -premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0; width: 100%;  " width=520><tbody><tr><td style="padding-bottom: 16px; font-family: Roboto, arial; font-weight: normal; font-size: 14px; color: rgb(69, 90, 100); line-height: 24px; background-color: rgb(221, 221, 221);">
                              <p style="text-align: center;"><strong>This is an automated email. Please ignore it if you have already responded to your prior submission.</strong></p>

                              <p style="text-align: center;"><strong>If you have not yet responded, please read the information below carefully to determine the next step of your submission review.</strong></p>
                              </td></tr><tr><td style="padding-bottom:16px; font-family: Roboto,arial; font-weight:normal; font-size: 14px; color: #455A64; line-height: 24px;">
                              <p><span style="color:#c0392b;"><strong>Please respond to this email to begin the verification process.</strong></span></p>

                              <p>Thank you for submitting your OAuth application for review. This is to seek your confirmation that your app does not fall in any of the following categories</p>

                              <ol>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Personal</em></strong><strong> use only:</strong></li>
                              </ol>

                              <p>The app is not shared with anyone else or will be used by fewer than 100 users. Hence, you can continue using the app by bypassing the unverified app warning during sign-in. It is recommended, however, that your project’s publish state is set to <strong>testing</strong> and continue to use your app under testing mode.</p>

                              <ol start=2>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Internal </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>An app is internal when the people in your domains only use it internally. Learn more about <a href="https://support.google.com/cloud/answer/6158849#public-and-internal"><u>public and internal applications</u></a>. Learn how to mark your app as <strong>I<strong>nternal</strong> in the FAQ <a href="https://support.google.com/cloud/answer/9110914#internal-only" rel=noopener><u>How can I mark my app as internal-only</u></a>?</p>

                              <ol start=3>
                                <li aria-level=1>If<strong> your application is for </strong><strong><em>Development/Testing/Staging </em></strong><strong>use only:</strong></li>
                              </ol>

                              <p>If your app is in development/testing/staging mode and not ready to be publicly accessible, then you do not need to submit your app for verification. Note that your app will be subject to the unverified app screen and the 100-user cap will be in effect when an app is in development/testing/staging. If your app is for Development/Testing/Staging, it is recommended that you keep your app’s publish status set to <strong>Testing</strong> and only update to In Production once it is ready for public use. Learn more about <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>Publishing status</u></a>.</p>

                              <p>&nbsp; &nbsp; &nbsp; 4. If<strong> your application is a </strong><strong><em>Gmail SMTP Plugin </em></strong><strong>only for use by WordPress Site Admin(s)</strong></p>

                              <p>If your app is <a href="https://support.google.com/cloud/answer/9110914#zippy=%2Cwhat-app-types-are-not-applicable-for-verification"><u>WordPress Gmail SMTP plug-in</u></a> where you and/or your other WordPress site admin(s) are the only users logging into the app,<strong> </strong>your app does not require verification. You can continue using the app by bypassing the<a href="https://support.google.com/cloud/answer/7454865?authuser=0#unverified-app-screen"> <u>unverified app warning</u></a> during sign-in. It is recommended, however, that your project’s publish state is set to <a href="https://support.google.com/cloud/answer/10311615#zippy=publishing-status-testing"><u>testing</u></a>, and you continue to use your app under testing mode.</p>

                              <p>Please note: Switching between publish states (testing or production) and/or visibility statuses (internal or external) <strong>may impact your verification process and cause delays</strong>. Therefore, we recommend avoiding unnecessary changes.</p>

                              <p><strong>Once we receive your confirmation</strong>, we will be able to start reviewing your submission and let you know if anything else is required from you.</p>

                              <p>Thank you for your patience.</p>
                              </td></tr><tr><td style="padding-bottom:15px;">
                              
                                
                                  
                                    
                                  
                                
                              <table align=center bgcolor="#2979ff" cellpadding=0 cellspacing=0 class="gcp_cta_btn_table" height=42 style="margin: auto; -moz-border-radius:3px; -premailer-cellpadding:0; -premailer-cellspacing:0; -webkit-border-radius:3px; border-collapse:collapse; border-radius:3px; box-shadow:0 3px 5px -2px rgba(0, 0, 0, 0.5); color:#2979ff; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0;"><tbody><tr><td style="border-collapse:collapse"><a align=center bgcolor="#2979ff" class="gcp_cta_btn" href="https://console.cloud.google.com" style="-khtml-border-radius:2px; -moz-border-radius:3px; -moz-border-radius-bottomleft:0; -moz-border-radius-bottomright:3px; -moz-border-radius-topleft:0; -moz-border-radius-topright:3px; -ms-border-radius:2px; -o-border-radius:2px; -webkit-border-bottom-left-radius:0; -webkit-border-bottom-right-radius:3px; -webkit-border-radius:3px; -webkit-border-top-left-radius:0; -webkit-border-top-right-radius:3px; background-color:#2979ff; border-bottom-left-radius:0; border-bottom-right-radius:3px; border-color:#2979ff; border-radius:3px; border-style:solid; border-top-left-radius:0; border-top-right-radius:3px; border-width:10px 17px 10px 17px;  color:#ffffff; display:inline-block; font-family:Roboto, Arial; font-size:14px; font-weight:500; line-height:18px; margin:0; mso-hide:all; text-align:center; text-decoration:none" target="_blank"><span align=center style="-webkit-text-size-adjust: none; display: block;padding-left:6px;padding-right:6px; ">GO TO MY CONSOLE</span> </a></td></tr></tbody></table>
                              </td></tr></tbody></table>
                        </td></tr></tbody></table>

                  
                    
                      
                        
                      
                    
                  <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0" width="100%"><tbody><tr><td class=close style="border-bottom:1px solid #dddddd; border-collapse:collapse; padding-left:40px; padding-top:19px; width:100%;padding-right:22px;" width="100%">
                        
                          
                            
                              
                            
                            
                              
                            
                          
                        <table border=0 cellpadding=0 cellspacing=0 class=signoff style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; mso-table-lspace:0; mso-table-rspace:0"><tbody><tr><td class=signoff1 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:14px; font-weight:normal; line-height:24px; padding-bottom:7px; padding-top:14px">Best regards,</td></tr><tr><td class=signoff2 style="border-collapse:collapse; color:#455a64; font-family:Roboto, arial; font-size:16px; font-weight:500; line-height:24px; padding-bottom:34px;">The Google Trust &amp; Safety Security &amp; Privacy Team</td></tr></tbody></table>
                        </td></tr></tbody></table>
                  </td></tr></tbody></table>
            </td></tr><tr><td style="border-collapse:collapse">
            
              
                
                  
                
                
                  
                
              
            <table align=center border=0 cellpadding=0 cellspacing=0 class="content_wrapper" style="-premailer-cellpadding:0; -premailer-cellspacing:0; border-collapse:collapse; font-family:Arial, sans-serif; font-weight:normal; margin:0 auto; max-width:600px; mso-table-lspace:0; mso-table-rspace:0; width:100%" width="100%"><tbody><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:36px 40px 0 40px; text-align:center"><img alt=Google src="http://services.google.com/fh/files/emails/gcp_newsletter_email_cloud_footer_logo_new.png" style="-ms-interpolation-mode:bicubic; outline:none; text-decoration:none" width=77></td></tr><tr><td align=center class="footer_wrapper_td" style="border-collapse:collapse; color:#757575; font-family:Roboto, arial; font-size:12px; line-height:16px; padding:27px 40px 20px 40px; padding-top:10px; text-align:center;">© 2023&nbsp;Google Inc. 1600 Amphitheatre Parkway, Mountain View, CA 94043<br>
                  <br>
                  You have received this mandatory service announcement to update you about important changes to Google Cloud Platform or your account.</td></tr></tbody></table>
            </td></tr></tbody></table>
      </td></tr><tr><td class="outer_wrapper_td" style="border-collapse:collapse">&nbsp;</td></tr></tbody></table><P></P> +Date : Mon, 15 Apr 2024 09:02:37 +0500 +Message : VGVzdCBQcm9qZWN0IERhdGENCg== +Url : PGRpdiBkaXI9Imx0ciI+VGVzdCBQcm9qZWN0IERhdGE8L2Rpdj4NCg== -Subject : Security alert -From : Google +Subject : test subject +From : tauqir sarwar To : moduspytestboilerplate@gmail.com -Date : Thu, 07 Mar 2024 09:40:59 GMT -Message : W2ltYWdlOiBHb29nbGVdDQpOZXcgcGFzc2tleSBhZGRlZCB0byB5b3VyIGFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KSWYgeW91IGRpZG7igJl0IGFkZCBhIHBhc3NrZXksIHNvbWVvbmUgbWlnaHQgYmUgdXNpbmcgeW91ciBhY2NvdW50LiBDaGVjayBhbmQNCnNlY3VyZSB5b3VyIGFjY291bnQgbm93Lg0KQ2hlY2sgYWN0aXZpdHkNCjxodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20vQWNjb3VudENob29zZXI/RW1haWw9bW9kdXNweXRlc3Rib2lsZXJwbGF0ZUBnbWFpbC5jb20mY29udGludWU9aHR0cHM6Ly9teWFjY291bnQuZ29vZ2xlLmNvbS9hbGVydC9udC8xNzA5ODA0NDU5NjIxP3JmbiUzRDM2NCUyNnJmbmMlM0QxJTI2ZWlkJTNEMjk3NjEwNjI0OTY2Nzc3OTY5OSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K -Url : 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 - -Subject : Security alert -From : Google -To : moduspytestboilerplate@gmail.com -Date : Thu, 07 Mar 2024 07:26:07 GMT -Message : W2ltYWdlOiBHb29nbGVdDQptb2R1cy1hcHAgd2FzIGdyYW50ZWQgYWNjZXNzIHRvIHlvdXIgR29vZ2xlIEFjY291bnQNCg0KDQptb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbQ0KDQpJZiB5b3UgZGlkIG5vdCBncmFudCBhY2Nlc3MsIHlvdSBzaG91bGQgY2hlY2sgdGhpcyBhY3Rpdml0eSBhbmQgc2VjdXJlIHlvdXINCmFjY291bnQuDQpDaGVjayBhY3Rpdml0eQ0KPGh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9BY2NvdW50Q2hvb3Nlcj9FbWFpbD1tb2R1c3B5dGVzdGJvaWxlcnBsYXRlQGdtYWlsLmNvbSZjb250aW51ZT1odHRwczovL215YWNjb3VudC5nb29nbGUuY29tL2FsZXJ0L250LzE3MDk3OTYzNjcwMDA/cmZuJTNEMTI3JTI2cmZuYyUzRDElMjZlaWQlM0QtMjM3Mzc5MzMxNzk3MTIzODg4MSUyNmV0JTNEMD4NCllvdSBjYW4gYWxzbyBzZWUgc2VjdXJpdHkgYWN0aXZpdHkgYXQNCmh0dHBzOi8vbXlhY2NvdW50Lmdvb2dsZS5jb20vbm90aWZpY2F0aW9ucw0KWW91IHJlY2VpdmVkIHRoaXMgZW1haWwgdG8gbGV0IHlvdSBrbm93IGFib3V0IGltcG9ydGFudCBjaGFuZ2VzIHRvIHlvdXINCkdvb2dsZSBBY2NvdW50IGFuZCBzZXJ2aWNlcy4NCsKpIDIwMjQgR29vZ2xlIExMQywgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMsIFVTQQ0K -Url : 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 - -Subject : test -From : Modus Pytest Boilerplate -To : moduspytestboilerplate@gmail.com -Date : Thu, 7 Mar 2024 12:07:37 +0500 -Message : dGVzdA0K -Url : PGRpdiBkaXI9Imx0ciI+dGVzdDwvZGl2Pg0K - -Subject : Modus Pytest, finish setting up your new Google Account -From : Google Community Team -To : moduspytestboilerplate@gmail.com -Date : Wed, 06 Mar 2024 22:58:19 -0800 -Message : DQoNCkhpIE1vZHVzIFB5dGVzdCwNCg0KV2VsY29tZSB0byBHb29nbGUuIFlvdXIgbmV3IGFjY291bnQgY29tZXMgd2l0aCBhY2Nlc3MgdG8gR29vZ2xlIHByb2R1Y3RzLCAgDQphcHBzLCBhbmQgc2VydmljZXMuDQoNCkhlcmUgYXJlIGEgZmV3IHRpcHMgdG8gZ2V0IHlvdSBzdGFydGVkLg0KDQoNCkdldCB0aGUgbW9zdCBvdXQgb2YgeW91ciBHb29nbGUgQWNjb3VudA0KDQpXZSdsbCBzZW5kIHlvdSBwZXJzb25hbGl6ZWQgdGlwcywgbmV3cyBhbmQgcmVjb21tZW5kYXRpb25zIGZyb20gR29vZ2xlLg0KDQpZZXMsIGtlZXAgbWUgdXBkYXRlZCAgDQo8aHR0cHM6Ly9ub3RpZmljYXRpb25zLmdvb2dsZS5jb20vZy9wL0FOaWFvNXFVUy1YT3puSXRZSmVUaFNXd25kaFlDc1RoUmREWDAtcVFnQlZZSWl1SVU1YnRMekZnN2pQZFp6eGh5Ry1FYjd5YVJUeFNtTWRncU9xNVB1dEJsTGwzV1RMcDhHZHc0R3RrNlNXVTlxSEZoM1lxZGVSdkd3bWtYVlVPdFVMOWhYV0l1eTliWDgzYzlGV2tINlVYeUE0Qm1BbGZVVm00ZzRpaE9lUFJtQ01reDIzUVZ2cjFMRi11MmNybmtzUHBOMUVaOTdnS01UaXhCRnNnZmdoSkRGOWd5cXNiLV9BY2lweG9NdDJyamRlWmNKV1RnTzU5Wl9XbjZTUVdIQi1KWjZ5N2xSTS1mRlVWdXlxTWEtRUhTTUtlYTNqOTZkbWZDMEtvRGVNNGVNUENTOUpvQ3BtaXdNMmc3T0Q3WlViUWZXT3R0M3lnSmVDUHFGXzRJZ3F2VW1QWExhdURHWUJKTUJlSnVIQWlEVldjXzB1TGFkdlRQaTg2ZklwYXhhOVpNeUR3b0lHTzhmN1FBdmFhbDlwbG5TSy1Fb2JGZ1hjWFc2bTNMSDRGNzRUcVZWYnJsR0FoRmhneEdzVV9aNWZwNG1aZWhTcXI0c2swZjhjU1BFY256dWktb0U0Q25DSWFpMkhMb0dzb0IzeFVLcS0zMFhWWnBmWkZSM2JNQ3JBSUdxNEdhcjl3cnN0Sy1ZX19rRk1BZVI5aDZqUUcyNjRKQ2tkbC1JOWp1Tzl5V2Y1TzBJX0ZVZVpvUlg5c3I5VXo4VUZDMmtvUGNaejZJcklaYnI0bG12R3pMMGZvLUNwT0ZhZl9SeGIzMld5ckc2cHFhd2sxRl9hOXhtZ19yMTlSeHc+DQoNClN0YXkgaW4gdGhlIGtub3cgd2l0aCB0aGUgR29vZ2xlIGFwcA0KDQpGaW5kIHF1aWNrIGFuc3dlcnMsIGV4cGxvcmUgeW91ciBpbnRlcmVzdHMsIGFuZCBzdGF5IHVwIHRvIGRhdGUuDQoNClRyeSBpdCAgDQo8aHR0cHM6Ly9ub3RpZmljYXRpb25zLmdvb2dsZS5jb20vZy9wL0FOaWFvNXF0blJDMU1PT0tYZDBtblZLZEZBZDBYRUZDTnpZUzBIUWxGMENFd1hPd1BJbUNGaEdiWHNLVXNmcFZHcFBHNXRRcEk3TW1fTEJZcFEtWGJOTGtPV2E3MU13T0VqemotZHV3TXZGd0ZLekVIM3BtUEp0b3NUOFo4X2dNODNkdldxTjRIM2ZHVkd5dlRWMm02aElwcHhTb0ltS0JwR0xnRnFwcm0wOGRxeVZBZFo5UDAycXBxNkRsbW5KdEgza3ZyRzdsNUNlUWZRRjhDZXpiNUpLVjg0ZGZKVGowbWJHOURvbTFOLTl4OE5DZVZEZWM5clhhbVhqVDBLUVp3Wmx5XzluSHhEZDNhazNiMHg4Mi05bjJRZkVIU05zbDE0ZFdhMmhDWHZyd08wZHpyMDkxTGJDOE1rZEIwOVlES1dmZW1xdW1LejdySzV1UWNRY2RHWEVUaW5BRmkzUEZxX3lyMXc4RGRsVGJINkZ1LVZfZkZFVGVTQUdTPg0KDQpNb3JlIGZyb20gR29vZ2xlDQoNCkRpc2NvdmVyIHRoZSBsYXRlc3QgYXBwcyBmcm9tIEdvb2dsZS4NCg0KRm9yIEFuZHJvaWQgIA0KPGh0dHBzOi8vbm90aWZpY2F0aW9ucy5nb29nbGUuY29tL2cvcC9BTmlhbzVwWG9ESURSNGhmVTFOdnFVRVd3TU14ZUFRblg1clYwSnN5eEF3NzZYYkNoTlFVZ016WVhiV3kwY29WYlJUMUhLNjRPNC1TUGxiVGhzTms3cUpfWGx5b3VXdnVwOHFnc2VpUGthZ2R0Z3JfLVltaVdvUmRfV2drZHdfeTB6TzQwajEzeFVjQjItUjhSZEx5U1p6czdlTlZyU1FpYWtOa2JSZl9tQjExbmJqRk5MdU54d3NCZllfakktbW9YdlJ0VGNnUGhrV005VnMzU1F2eXdnZTk5SFZPT2tmVm9LMk93aC1EUGN3X1hIcTE3cmZ0NHpfUWl3Qkd5QlhVcWJiUURuRjB6QWVrOUhJQW03STB4VjlPZENwZDVCVXRnWG9ib203WVpHY1ZOTU0zbFRIb2tMX2pNbkNXcEw4cnBhcFNYbTRsSmdEbGltWnloV0I3clZHcERMXzRDcG1nMElYa3ZHTHBlS0pIdUlrczVaaXdxcHpOM3ZsbXlYUHJzenU3Z09TUGdOVXBCUXJacHBheHZzaXF4bTkxMGp6ZzhCSUEtcTJLbjdmM05FbWd5cER1eGYzUVBGdjg4dkJLa3ZhbmxKeUtSTzRRWWZrWkVyV1VuenJGZC03cmFuYm1Ra2hrVFE3X2JoS0kwRjZZSlhsX0w0UngweHJPRWFfOHR6SnNJNGlnbl92YmJ0Wm91S3AtbEF3bVFvU25naGJ3WC1kYlJNeXNlX3hITW9ma1lJbWNJQ283UE4ydE9jQlp3a3dYbUs1eDEyYzlHcDJ5cERKWmoyTm1QaGxXVFhGb0pncmx2VEhyeUVhYTRGWFotM0EzZld4RDRjcVNPTXBHaGlhWFlFUE92NzZIY1NQWlYyVnF5V0VlLVZUVXBnPg0KDQpGb3IgaU9TICANCjxodHRwczovL25vdGlmaWNhdGlvbnMuZ29vZ2xlLmNvbS9nL3AvQU5pYW81cGtLMV95SnpvT0Y0TnRRMk52aklFb0k2NEtIWDJOOHRQcGFEMklxcTg1MWxBQ2ZVNUFHZTU2NmdHZnBCNFhnMkpGU2gtcDdERElWRGlaWVAwSUhsakszN3d0Rkw2eXVlSGJZYVNIME9WYlhESVdnU0RVT3NRTDVrWVQ2ODFCOTVLMkNkYmE2ZWJTYVA4RjRPVjBKWmZDQ3hRS3pTM3kyYXlTLUVyYWg3ZjBGX2F5VVVFRGVtYzZRdml5S1ctNmhBTHZVVFJiMmhrVS1VNlJtMEhmWXpPR2cwQjUxLV81cTlacFFjUnFDbS16elUxS1pUSDl3VGo3UDBBdU1HbHhyTEN4NXBFbmE4aDZlQUR6ODRtcmp6bXFCN1lTWFd2QjVHbFV4VG9uMDNvTHZhS1cweE9uX0pKNjlHMkdxVDFNOHhzOW5lb0FuQ0ZaM3FhUkM5U21iRHpNRVZQcTJTM3U0Rm9FaUFLeS1YWDQzRmZlcjFGNUowb1UzWGlVbDFwdk5Dc24zS19aQ0M0WD4NCg0KQ29uZmlybSB5b3VyIG9wdGlvbnMgYXJlIHJpZ2h0IGZvciB5b3UNCg0KUmV2aWV3IGFuZCBjaGFuZ2UgeW91ciBwcml2YWN5IGFuZCBzZWN1cml0eSBvcHRpb25zIHRvIG1ha2UgR29vZ2xlIHdvcmsgIA0KYmV0dGVyIGZvciB5b3UuDQoNCkNvbmZpcm0gIA0KPGh0dHBzOi8vbm90aWZpY2F0aW9ucy5nb29nbGUuY29tL2cvcC9BTmlhbzVxUmdqdUdreVFMVmtSaFJoNkNweFNnc1Rqakk2TTc2OVNtd2RiRHdHMlU5RENWaEg5N2xNYXRSaS1jaFE4ekJWdWZoMDBEVVUtanBzcV9jcFllR1JFekU5dU1lUmVBSjVLbkJpS193aHhjdGFwSkpUV3Z2YTQwSFNRTXBHLXNjQURfMkRfQko1ZHdVb0xrMkVHdTBRZXNnVkQ5dUpvcGdGV3IzLXdtVTM3UHVQaGZJd3lYNVRZMTdfZk15RG5KT0MtcndKRF9pTVpXMEFNQ0lpSXNDcGl1Y3AyRzRZTGhBMmE5SkczcG15RUNOektPRlk0ZE82VVZUQTB4TVF1aVNOa2lhX3pDX3hySDNTaHUxV1libWNJdThUdjAzOGQzaWY3N05MWkNrc283Yl9NYjJYWXRoa2lIZ2pya2Q3U0pXTUhJREhnbEc2cGtDUjhIVzYwPg0KDQpGaW5kIGFuc3dlcnMNCg0KVmlzaXQgdGhlIEhlbHAgQ2VudGVyICANCjxodHRwczovL25vdGlmaWNhdGlvbnMuZ29vZ2xlLmNvbS9nL3AvQU5pYW81cUlUc0RKZWxvTVNUd3YxaTdVV0JnTWExMjhVcncxTnpTSm1KZ2ZvX0ZZT2ZfYUgzLVVCU1lieTVGN0pCM1JCWmtZUXczbHpnZVM2eEFXemxyaDZGZ0Vpdk80Qk9VZ1BlUDhPVzM3ZW5DSWYtZi1ZU2E3TVdQS2JaZFZZUkFRdk8wbTJIUXRDMU13Zm1TQTJvdDZ1MHJhZjV0Vi1MMXpOQk5ZdWZuSkotNGctWkNobmN1eHd1dVdXS3pMVExjek1FUHFyRktJdkt6OW1LNzVTTXJBMmR4a2RIekl0dkdtMjkyVGNiN3k1ZTJYWVJLS251aDBSRExqeHNyZ3N6NldvY1RPVm5ZTEEtYUJ2ZnI1dTFRN2JoaG9LWDJaNHF2Y1pqS0ludFJaV1RUdF9lWT4gIA0KdG8gbGVhcm4gYWxsIGFib3V0IHlvdXIgbmV3IEdvb2dsZSBBY2NvdW50Lg0KDQoNClJlcGxpZXMgdG8gdGhpcyBlbWFpbCBhcmVuJ3QgbW9uaXRvcmVkLiBJZiB5b3UgaGF2ZSBhIHF1ZXN0aW9uIGFib3V0IHlvdXIgIA0KbmV3IGFjY291bnQsIHRoZSBIZWxwIENlbnRlciAgDQo8aHR0cHM6Ly9ub3RpZmljYXRpb25zLmdvb2dsZS5jb20vZy9wL0FOaWFvNXBaWExXanJZQjNad1pZVTF2dHhwY3g2YTUyNDN6VnZPRHdHWkN4NEtiMWNwdkY0cDVqUXU4TjlSSTRlZlZ3ZHhnY1BXSk94MlNwcmxmYXhGalY4bk95QklEenZ2S3JFZTFmbW52dXRFNlpPZjVpbXg2akY4Mzc3VmVGN0swanFQRnZxYTFkbjA2TnlLbkpOeUdnMzUxRDVXcnlXTEZfdjFZN0YxRVZ4YmFYQi1CVVd4YjNOeVJ6X213R0hjQjF5bFotbGZPbUN2ZDJWOGxfOU10Y001LUQtSWsyRTRmai0xd1pfQTZ0TURNRWMtOFd4d3I5ZUFYQkJaM0wxMzZfWTN4T2NPTFd3SmVfSzZwUHRodVJmUG5QZTAyVzc2SDhkMHBSU0c1eHVNTjdCbVkwVkFhMk9sOD4gIA0KbGlrZWx5IGhhcyB0aGUgYW5zd2VyIHlvdSdyZSBsb29raW5nIGZvci4NCg0KDQoNCkdvb2dsZSBMTEMgMTYwMCBBbXBoaXRoZWF0cmUgUGFya3dheSwgTW91bnRhaW4gVmlldywgQ0EgOTQwNDMNCg0KVGhpcyBlbWFpbCB3YXMgc2VudCB0byB5b3UgYmVjYXVzZSB5b3UgY3JlYXRlZCBhIEdvb2dsZSBBY2NvdW50Lg0K -Url : <!doctype html>
<html ⚡4email data-css-strict lang=en>
<head>
<meta charset=utf-8>
<script async src=https://cdn.ampproject.org/v0.js></script>
<script custom-element=amp-bind src=https://cdn.ampproject.org/v0/amp-bind-0.1.js async></script>
<script async custom-element=amp-form src=https://cdn.ampproject.org/v0/amp-form-0.1.js></script>
<style amp4email-boilerplate>body{visibility:hidden}</style>
<style amp-custom>
body{text-decoration:none;}
td.table-cell.subheadline.space6.module_para {
padding: 0 50px;
}
.pdngrtl{padding:7px 24px 7px 24px}
.localepading{padding:8px 26px 7px 26px; font-size:16px;}
.space6{padding:0 80px 0 80px;}
.space2{padding:0 70px 0 70px;}
.widthmin{min-width:115px;}
.addingspace{width:6px; display: inline-block;}
@media only screen and (max-width: 767px){
.btn_mod2_mobile1{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod2_mobile2{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod3_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.btn_mod4_mobile{padding:9px 24px 11px 24px ; border-radius: 4px ;}
.pdngrtl{padding:7px 11px 7px 11px}
.space1{height:19px ;}
.space2{padding:3px 35px 0 35px ;}
.space3{padding-top: 22px ;}
.space4{padding: 6px 0 0 0 ;}
.space5{padding-top: 17px ;}
.space6{padding:0 35px 0 35px ;}
.space7{padding-right: 0px ;}
}
@media screen and (min-resolution: 288dpi) {
.device_txt{font-size:26px;}
}
/* Potrait for iPhone */
@media only screen and (device-width: 375px) and (orientation:portrait){
.fmd_mobile {padding-top:5px ;color:red ;}
}
body{text-decoration:none;}
</style>
<!--[if gte mso 9]>
<xml>
<o:OfficeDocumentSettings>
<o:AllowPNG/>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
<![endif]-->
<!--[if mso]>
<style>a{color:4285f4; text-decoration:none;}</style>
<![endif]-->
</head>
<body class=body_wrapper style="padding: 0 6px;">
<div style="font-size: 0px; line-height:0px; color: #ffffff; display: none;">                                                                                                                                                                                                                                                                                                                                                                                                                                                                           </div>
<table role=presentation class=body_size border=0 cellspacing=0 cellpadding=0 align=center width=100% bgcolor=#ffffff style="background: #ffffff; width:100%;max-width: 520px;">
<tr><td align=center style="padding-top: 20px;"> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-header.png style="width: 82px; height:26px; text-align: center; border: none;">
</td></tr>
<tr><td class=space1 height=15></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=516 height=109 src=https://www.gstatic.com/gumdrop/files/banner.png style="width: 100%; text-align: center; border: none;" layout=responsive>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<!--[if mso]>
<td align="center" class="greeting_name space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; padding:0 80px 20px 80px; text-align:center;word-break:normal;direction:ltr;' dir="ltr">
Hi Modus Pytest,
</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="greeting_name space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:28px; font-weight:normal; line-height:44px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>
Hi Modus Pytest,
</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space2" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Welcome to Google. Your new account comes with access to Google products, apps, and services.</td>
</tr>
<tr>
<td class="subheadline space6" align=center style="color:#3C4043; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr> Here are a few tips to get you started.</td>
</tr>
<tr><td height=45></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style=padding-bottom:50px;>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr class=table-row>
<td class=table-cell style=height:50px></td>
</tr>
<tr class=table-row>
<td class=table-cell align=center>
<amp-img role=presentation width=48 height=48 src=https://www.gstatic.com/images/branding/product/2x/email_64dp.png style=width:48px;height:48px;text-align:center;border:none;font-size:9px class=CToWUd></amp-img>
</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px></td>
</tr>
<tr class=table-row>
<td class=table-cell style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 30px 0 30px; text-align:center; word-break:normal; direction:ltr;" dir=ltr>Get the most out of your Google Account</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:15px;line-height:4px;font-size:4px></td>
</tr>
<tr class=table-row>
<td class="table-cell subheadline space6 module_para" style="color:#5f6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal; direction:ltr;" dir=ltr>We&#39;ll send you personalized tips, news and recommendations from Google.</td>
</tr>
<tr class=table-row>
<td class=table-cell style=height:30px;></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<table role=presentation class=table align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto;">
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 4px; height:4px;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td>
</tr>
<tr class=table-row>
<td class=table-cell style=text-align:center;padding:0>
<form class="sample-form hide-inputs" method=post action-xhr=https://www.google.com/dynamicmail/optin?tok=AMkCvlsFcJCAyjqfUBxSVGWAeBaDxQHayXK1a_iSygC0P5WIJzQpCgwOq_QGO4--tFaOgh2xFQ==&amp;ctrk=https://notifications.google.com/g/p/ANiao5q00zyMvvt-jpKiJuw2CiYJi4Zthu6gBCDeof77qPoiCT8zlM3PPyyOyRNfW-SdckVvjI80pItjYNDwllNhjx_HUgBJpo4LLItagUMohE1NqTkHrbn0SSI9IbhZ-_Z32JH9hateW-9WM7yDZMEE4XUZ9io7V5E5cTwFd0ZMyEVbrA0EQgEJz_92MjMdpA8yQp_w0s7QeryNRValYk4hDaOXA_O8adsO9Z6u7r1briiE>
<button [hidden]=cta_submit role="" tabindex="" on="tap:AMP.setState({sign_up: true, cta_submit: true})" type=submit value="" style="background-color:#1a73e8; border:1px solid #1a73e8; border-radius:4px; color:#FFFFFF; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:180px; font-weight:500; text-align:center; word-break:normal; direction:ltr;" class=localepading>Yes, keep me updated</button>
<div submitting>
<a style="background-color:#5F6368; border:1px solid #5F6368; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>One moment...</a>
</div>
<div submit-success>
<a style="background-color:#188038; border:1px solid #188038; border-radius:4px; color:#FFFFFF; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; min-width:180px; padding:8px 18px 7px 17px; font-weight:500; text-align:center; word-break:normal; direction:ltr" dir=ltr target=_blank>You&#39;ve signed up</a>
<div class=table-row>
<div class=table-cell style=height:20px></div>
</div>
<table width=80% role=presentation align=center cellpadding=0 cellspacing=0 style="text-align: center; margin: 0 auto; width: 80%;">
<tr class=table-row>
<td align=center class=table-cell style="background-color: #ffffff; color: #5F6368; font-family:Roboto, OpenSans, Open Sans, Arial, sans-serif; font-size: 14px; line-height: 21px; text-align:center; margin: 0 auto; padding:0px;">You can unsubscribe at any time in the messages you receive. You can also <a href=https://notifications.google.com/g/p/ANiao5qjymW_t0uPjVYrfJYbgdo9waKj9lw3lnGdYyZInr8de_Lbr1yE5-ZbxhCGD_sfBGRNjMWFNQNqPltxa3ymYfMUw697szlzaHHLqyb_-RffxxmvXmBphBpgrfjKcOvo9nmgFhqWehnEc5wf8owpdvFlGxmpyKSAr-ORgcymVQWIVTorL5_w45Eyly2nT-mnfy-8ILD1ok6--PbSp_Kehm0iUDwWduXRajhouKlgIpN2WPGvmHxvwhm_TeBQjNfanPY1d5yM9Zk9ysa7fHSxIqNr4RM-_mJHEblWYw5JeG07Z__4Rl6qr7PSFZf5FD3CxeUBGSqOyEBE28fpvNuTmTI6e29NYCj4G2Gc14LCI4lcVnrmRoWpdsw4Mx_w89zRFQUOolVZF8SeAde9ifXDcDk-V37gi7FNp2QK2pqi7mgaERONST_QVWUPz7FRwwSPNUfUBlqz7vnsYrB1w0r5vogVgOrG_Qz-oR8wejXLYNKL2tOahU2v5E_EbvRi53_evxgB6oKnPWQODn6LFXi1yB0peGxcGLSuoT62HzV1l5DHvwZUh21HO0niraoX78aIBmWrLL1LKYmRnHnEeMVOCXWVmMaO6bsX8mMR9rc1yhbvJae4RpMjmJSkOfSIkoaWqaLAuIzMyqTjWOrjYE8WlQgSKZHs target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">manage your preferences</a>.
</td>
</tr>
</table>
</div>
<div submit-error>
<a href=https://notifications.google.com/g/p/ANiao5pVGL0PiiGdVXPsRPji2J57DhE_cOwjqvVmlV_SkJgD9ERjCRMztBNK_ZqlrfvueiW9mf2x1M82G2FmRZ8vAg1NIIsznBvgKBi-0v9H6sw1MM9AgKxvNFIyMZwb7KVyKIN4OueoBLXtGc75Ij8B3_rDFDwUFLVQk0XGjIbVBIdrRjTmI4JaecuUybTzIsJW5CfZp4FF-woB56D8Ra7fzEfABP_iIjX0Z5qfc7H9e4SHz0bwC7ozzxQxpghWAXrkTMq1VBjFg2agx6_j2J10T8u8t50jUg3ezt8cdUPzHkt-RcKXr1fYm7HWpiwGmWiaZo3pjPeFrhVrOyxkOXmHiwwmZMuliO6o6jHMCHgyf7e_kvNEWVKeacwO28xzSacgimjYDNzrBloPzUZ0hKzBHv7mc9SXE39ob38HRWa1yS-19fKb8L3L8rmrSIgrRmXstxdORZY5mQ96YgiRN1j0brm1Q-Bh-V5TtT3fcPrJFPFao9Wljs_SUxPJAUkypo7twzwt5mXZaT0wyf7Wn5i2HgzZ8dLpYI_naFYVlha5T2DW_pmWXQDsAebqhJngZFknzTas2x8lJZAtHOtXY35kRTMXZUu_QZ7_uEImb7lfSAQ3en5hWNbZZMbe4_k7vcinH6rfuwU target=_blank>
<table role=presentation cellspacing=0 cellpadding=0>
<tbody>
<tr>
<td style="text-align: center; background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; line-height:24px; text-decoration:none; min-width:167px; padding:8px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal;direction:ltr;" dir=ltr class=cta_gl>Try again...</td>
</tr>
</tbody></table>
</a>
</div>
</form>
</td>
</tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;">
<td style="border-top: 3px; height:3px; border-top-left-radius: 4px; border-top-right-radius: 4px; display:inline-block; text-align: center;"></td>
</tr>
</table>
</table>
</td>
</tr>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="width:100%; max-width:480px; border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/google-logo.png style="width: 48px; height:48px; text-align: center; border: none; font-size:9px;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Stay in the know with the Google app</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Stay in the know with the Google app</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Find quick answers, explore your interests, and stay up to date.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td class=space4 style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw" style="height:48px; v-text-anchor:middle; width:150px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Try it</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oXIoJU0AO5kbjw78W8anF-wPc3BMIrb07nPsU6hQen-nkr8_0hL28PdBUagqlAHnG8B6Ih7dSZ_x2EyfB8mXod50ygLbwjc2oWFcHTbcJhy0Kui3mibw5_Q1lrpu5Oyxfnmn8m2FEwb-Xulh0dPjG_aPlc2dgiUh7nZGukszkU1dQ1ZtMLkOI2VyTioJIB4__edWVZOXez9nvdcR0125AkUYQo9Kl9EGeSzbLbybjJkquwC-Wh3Oqqkt_VRp2Fr6t0kxE_mnbgI1u4QAdiI2m2LjpTNKOwVrHU_3Y3c0Rl-ERZ-1WVlgUAEzsPhr769PXnIS15YLveq-b8CJ0eDJLBbxCIERL6Nyv9OGGPcg5rphgQcuA3w_xcJZw target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod2_mobile2 enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Try it
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
<tr><td height=50></td></tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr>
<td align=center>
<amp-img role=presentation class=top_img width=514 height=207 src=https://www.gstatic.com/gumdrop/files/apps-icons-image-2x-wd972px-ht390px.png style="width: 100%; text-align: center; border: none; border-top-left-radius: 8px; border-top-right-radius: 8px;" layout=responsive>
</td>
</tr>
<tr><td height=7></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">More from Google</td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>More from Google</td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Discover the latest apps from Google.</td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V" style="height:48px; v-text-anchor:middle; width:160px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For Android</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ruhi0eexFlFgIBfYoHk1Y7YGnpcd88goNl4dH5j75QP7CQDgR-T7cyZ7STNPdKKxHj01Bsfd858qjVClJVn-bY_pTFsYPDrPy_AF7kBxIM5lW_e3Rtd4ukaRLEDrJ1T9uOAWQgT8ynWh4dChSGEaaYSLQyMcIPDpLzVGu9YGY3jvF43onjFPhfcjk2CCEclUPgYqUC1H8ZZ-YeQA3ncjrfrz3J2F6kFxHpqNs_KzNz3gQXjuY-72RXhfXIbWo_Gz_ph7uGZef1tMbGGT7KUGL1So5YW6H1lMcMRirTumMFL_-bKS14XF5BXi9vcDrmG4ez4bBeW7G2CkZkXmS5UYeXrbZkTfob0wvcaPa8t5-Lx1BrvwdEEO3sgOBB_c1cLYWnYyQ3uW0NNwXOCpLyupmBPo1wlnkapnnDn_ghnAB5O29DxDEoQbNCCL-hFVg0QXl8QSJU7WfZ2H07jhYSwFdJhT1XEAyYnUWQvpa2cM83v8Q4BgkdAq0lOT2StkSyFaR551vViwKd_XiUsIHiQ3BtHZ6gagvEcvYx-2dbct3Bi9RXzPOYgIb4XeRGnMI8U1YJjdwH8WiEsdv0AYOErYEpXd8KfFIfEkyggCwjuKdlPsbOLMAISr94RpV6Qdz6BUPL7G6pCuwDReaewjr6-FjSp_7V target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; direction:ltr;">
For Android
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
<span style="" class=addingspace>  </span>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94" style="height:48px; v-text-anchor:middle; width:130px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">For iOS</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5ocZDjQ9haUIIADqJdOSZK6-tcFDt7wpDvQga6ZDtVA_w1s-p2ChSfBLwt4S0Epvy0rqs_Oqn6FBmv14c7Dc1X9ndNVzC94JyRI0JZJqFUAWA8WASAqA7VOOlZdH_yZlV6zyxrLSl_XnxWmy_RTsATxEXSnyL3Lx1-YQuicL9n3EOA0TBTrN5dOanTLOxVc9Y-4pcd0HXUYdXAB_Bc8sArU9VXC5b3ZRJEvbejmyZe5oUpBAJjkFQ4s__4bFxVwGSgx-7l3qZaMaxlc-MVPak3EH2pTAov8IbnRIg2oHM3l3Dg_SDT6Ev0UaEstoMBQQOOUvcZhEpziwbnQyG1ImlER9noV49H0iLJWIkAT7NgoZJWG-UzZwZNLLTJ1EyQZn_HBt_p_oqK7F94 target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod3_mobile enwid pdngrtl widthmin" style="background-color:#1A73E8;; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; font-weight:500; text-align: center; word-break:normal; white-space:normal; direction:ltr;">
For iOS
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=100% style="border: 2px solid #DFE1E5; border-radius: 8px;padding-bottom:50px;width:100%;max-width:480px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=50></td></tr>
<tr>
<td align=center> <amp-img role=presentation class=module_mobile width=48 height=48 src=https://www.gstatic.com/gumdrop/files/security-logo.png style="width: 48px; height:48px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=15></td></tr>
<tr>
<!--[if mso]>
<td align="center" class="device_txt space6" style='color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; padding:0 80px 20px 80px; text-align:center; word-break:normal;direction:ltr;' dir="ltr">Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<![endif]-->
<!--[if !mso]><!-->
<td align=center class="device_txt space6" style="color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; font-weight:normal; line-height:33px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Confirm your options are right <span style="white-space:nowrap; " class="">for you</span></td>
<!--<![endif]-->
</tr>
<!--[if !mso]><!-->
<tr>
<td height=15 style="line-height: 4px; font-size: 4px;"></td>
</tr>
<!--<![endif]-->
<tr>
<td class="subheadline space6" align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:16px; font-weight:normal; line-height:24px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Review and change your privacy and security options to make <span style="white-space:nowrap; " class="">Google</span> work better <span style="white-space:nowrap; " class="">for you.</span></td>
</tr>
<tr><td height=30></td></tr>
<tr>
<td align=center valign=top>
<table role=presentation>
<tr>
<td style="text-align: center; padding-top: 0;">
<div>
<!--[if mso]>
<v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA" style="height:48px; v-text-anchor:middle; width:180px;" arcsize="10%" strokecolor="#1A73E8" fillcolor="#1A73E8;">
<w:anchorlock/>
<center style="color:#ffffff;font-family:Google Sans, Roboto, Arial; font-size:16px; font-weight:normal; word-break:normal;direction:ltr;" dir="ltr">Confirm</center>
</v:roundrect>
<![endif]-->
<!--[if !mso]><!-->
<a href=https://notifications.google.com/g/p/ANiao5oxSNtgQ-UzebNorKZ3A63lVHZJfVO_hFehKR5XPyO-r0zIgr7UwFldmLtdVIsNPx2Aa2lTgpHzssMIe7Jw4ctSnGa2SHnycW4V2vEaue7_M0tNQr3k7uyRCCfxXaC37YOW1GAjm5E0rmuALMixhuf6aGdmKSWgfn6ekHb0fxrop9e5qPpzWUiBzCWpD7H5Ndi69kXTzYR6xqigmmuY0S-S7VZaOWAMCuydma6xr5qy3Bxgj58ckjV_qgvmAyH42FeJIXB1uAVEvoiHIP6Ebm2IkGWAvgho9XXEvGqcRVCRfcBeygOpmR6NCmzlNyKYTMfAthm0_c8ebbt9P8cXrA target=_blank dir=ltr style="text-align: center; display: inline-block;">
<table role=presentation cellspacing=0 cellpadding=0 align=center>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 3px solid #ffffff;border-top-left-radius: 4px;border-top-right-radius: 4px;display:inline-block; text-align: center;"></td></tr>
<tr><td class="subheadline btn_mod4_mobile enwid" style="background-color:#1A73E8; border:1px solid #1A73E8; border-radius:4px; color:#ffffff; display:inline-block; font-family:Google Sans, Roboto, Arial; font-size:16px; line-height:25px; text-decoration:none; padding:7px 24px 7px 24px; font-weight:500; text-align: center; word-break:normal; direction:ltr; ">
Confirm
</td></tr>
<tr style="padding: 0; margin: 0; font-size: 0; line-height: 0;"><td style="border-top: 4px solid #ffffff;display:inline-block;border-bottom-left-radius: 4px;border-bottom-right-radius: 4px; text-align: center;"></td></tr>
</table></a>
<!--<![endif]-->
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr><td height=24></td></tr>
<tr>
<td width=480 style="border: 2px solid #DFE1E5; border-radius: 8px;">
<table role=presentation border=0 cellspacing=0 cellpadding=0 width=100%>
<tr>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
<!--[if mso]>
<td style="margin-bottom:67px; padding: 21px 10px 35px 20px;"> <amp-img role="presentation" class="fa_mobile" width="24" height="24" src="https://www.gstatic.com/gumdrop/files/help-outline.png" style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<![endif]-->
<!--[if !mso]><!-->
<td style="padding: 47px 10px 40px 20px;" valign=top> <amp-img role=presentation class=fa_mobile width=24 height=24 src=https://www.gstatic.com/gumdrop/files/help-outline.png style="width: 24px; height:24px; text-align: center; border: none; font-size:3px;">
</td>
<!--<![endif]-->
<td valign=top>
<!--[if mso]>
<div class="device_txt" style="margin-bottom:15px; padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:18px; padding-bottom:12px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Find answers</div>
<![endif]-->
<!--[if !mso]><!-->
<div class=device_txt style="padding-left: 20px; color:#202124; font-family:Google Sans, Roboto, Arial; font-size:18px; line-height:28px; text-align:left; padding-top:45px; padding-bottom:12px; word-break:normal;direction:ltr;" dir=ltr>Find answers</div>
<!--<![endif]-->
<!--[if mso]>
<div class="subheadline space7" style="margin-bottom:20px; padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:35px; word-break:normal;direction:ltr;" dir="ltr" valign="top">Visit the <a href="https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ" target="_blank" style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<![endif]-->
<!--[if !mso]><!-->
<div class="subheadline space7" style="padding-left: 20px; padding-right: 20px; color:#5F6368; font-family:Roboto, OpenSans, Arial, sans-serif; font-weight: normal; font-size:16px; line-height:24px; text-align:left; padding-bottom:50px; word-break:normal;direction:ltr;" dir=ltr>Visit the <a href=https://notifications.google.com/g/p/ANiao5r5H7lrR6__rj8QaEunpmXsST_hqN50duG6vvoGZ9yWz4FvDQUUv0CwwMDm4DdaMONIHzKYCY36oG6ZKHeTVIIaMttiSJjox_doYfRWdiRKYdeO93C6dQfvFVsY5czeBZrK0gvqSbiWPsRKu5eXYXIccEXo1ED1GcWZuAXO0JRifNCO5sdeKkSThrJ42ngbqlWT_9xKIBVYcPXayBuu5Gu7F76P8J0XEPAZmnNd3kg7cx9OSWIhOnP8kHZR9l2wUaeWMGHIzdLlrlJFptKg-1FQcYbW9NhZflVSRNnqW7k68-pLqQ target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> to learn all about your new Google Account.</div>
<!--<![endif]-->
</td>
<td style="font-size:0pt; line-height:0pt; padding:0; margin:0;" width=24></td>
</tr>
</table>
</td>
</tr>
<tr>
<td>
<table role=presentation border=0 cellspacing=0 cellpadding=0 align=center width=100%>
<tr><td height=30></td></tr>
<tr>
<td width=134 height=46 align=center style="font-size:8px; word-break:normal;direction:ltr;" dir=ltr> <amp-img role=presentation class=google_mobile width=82 height=26 src=https://www.gstatic.com/gumdrop/files/google-logo-footer.png style="width: 82px; height:26px; text-align: center; border: none;">
</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 align=center style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:12px; line-height:18px; margin:0; text-align:center; word-break:normal;direction:ltr;" dir=ltr>Replies to this email aren&#39;t monitored. If you have a question about your new account, the <a href=https://notifications.google.com/g/p/ANiao5rTjkBxyW3fJJZoX4P9D_6vTIpEyPkjkx72A5ZOucL-qnhiUap2yhWQsEAbi5j-mOEqpmaB9UC7BGsgXJmh1Aq12RIOoGT-Qedihwobq8PGaxMuXKR2Tv-NrcMz1qGxoGTMSy6VA6_GEsG84AnHYYhA9BKaTq5HRC7kPrAbVD7s2JcMH0NcaAH_uzUCAu7UxIbdxjGnFin-oRS-Guve3IIpVJivRvxXA_10nzZgIHE2uwHI7GsEuM4DqBApZnGckanWMnQhqznDpXEYL4AFj6sISuMHWRFD3_DWX9KxQ-JiqxkM-Gjdgpityw target=_blank style="color:#1A73E8; text-decoration: underline; font-weight:normal; border:0; white-space: nowrap; ">Help Center</a> likely has the answer you&#39;re looking for.</td>
</tr>
<tr><td height=19></td></tr>
<tr>
<td class=space6 valign=middle style="color:#5F6368; font-family:&quot;Roboto&quot;, OpenSans, &quot;Open Sans&quot;, Arial, sans-serif; font-size:10px; line-height:15px; margin:0; text-align:center" align=center>
<span style="font-size:inherit; color:inherit; font-weight:inherit; line-height:inherit; font-family:inherit;">Google LLC<br>1600 Amphitheatre Parkway,<br>Mountain View, CA 94043</span>
<br><br><span style=word-break:normal;direction:ltr; dir=ltr>This email was sent to you because you created a Google Account.</span></td>
</tr>
</table>
</td>
</tr>
<tr><td height=18></td></tr>
</table>
<div style="display:none; white-space:nowrap; font:15px courier; line-height:0;">
                            
                             
</div>
<amp-img alt="" height=1 width=3 src=https://notifications.google.com/g/img/ANiao5redogZGkiXNpH8PTOz6QtmTWmDl5Kn_b-3kYHZEpRf5kYRMZOqPG7UV5ATGDUF-xPoFCENQragusUa3fuTQ31HzvUNEm--NO6eqkX1t8aqN87kYcIef-IsUSl-vHPhy8GyyWK6r6h3huKtutBqC4tTAwVNqRai_7Ir3A.gif></body>
</html> +Date : Mon, 15 Apr 2024 08:58:38 +0500 +Message : dGVzdCBib2R5DQo= +Url : PGRpdiBkaXI9Imx0ciI+dGVzdCBib2R5PC9kaXY+DQo= From 247e4bc3ba690d352671f135974abefe7385aec2 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 11:36:44 +0500 Subject: [PATCH 06/12] removed extra email step --- .../test_project/features/web/web_tests.feature | 3 +-- main/frontend/common/step_definitions/email.py | 17 +++++------------ main/plugin.py | 1 + 3 files changed, 7 insertions(+), 14 deletions(-) diff --git a/frontend/test_project/features/web/web_tests.feature b/frontend/test_project/features/web/web_tests.feature index a7163dd6..77ab83c2 100644 --- a/frontend/test_project/features/web/web_tests.feature +++ b/frontend/test_project/features/web/web_tests.feature @@ -187,5 +187,4 @@ Feature: OrangeHRM Login and Modus QA blog And I click on element 'OrangeHRM > login_button' Then The title is 'OrangeHRM' And The page url contains 'dashboard' - When I get about link from email 'moduspytestboilerplate@gmail.com' - Then I reopen the email link \ No newline at end of file + When I get link from email 'moduspytestboilerplate@gmail.com' \ No newline at end of file diff --git a/main/frontend/common/step_definitions/email.py b/main/frontend/common/step_definitions/email.py index 7503f1ab..4a66523b 100644 --- a/main/frontend/common/step_definitions/email.py +++ b/main/frontend/common/step_definitions/email.py @@ -7,23 +7,22 @@ import pytest import structlog from bs4 import BeautifulSoup -from collections import defaultdict +from main.frontend.common.step_definitions import store_env_variable_in_local_env from main.utils.email_reader import create_json +logger = structlog.get_logger(__name__) + PROJECT_DIR = os.getcwd() test_data_dir = os.path.join(PROJECT_DIR, "test_data/files/email_data.json") from pytest_bdd import parsers, when, then from main.frontend.common.helpers.selenium_generics import SeleniumGenerics -logger = structlog.get_logger(__name__) -pytest.globalDict = defaultdict() - -@when(parsers.re("I get about link from email '(?P.*)'"), +@when(parsers.re("I get link from email '(?P.*)'"), converters=dict(user_type=str)) -@then(parsers.re("I get about link from email '(?P.*)'"), +@then(parsers.re("I get link from email '(?P.*)'"), converters=dict(user_type=str)) def check_email(user_type, selenium_generics: SeleniumGenerics): time.sleep(5) @@ -68,9 +67,3 @@ def check_email(user_type, selenium_generics: SeleniumGenerics): break f.close() - - -@then('I reopen the email link') -def reopen_final_url(selenium_generics: SeleniumGenerics): - final_url = pytest.globalDict['final_url'] - selenium_generics.navigate_to_url(final_url) diff --git a/main/plugin.py b/main/plugin.py index 1b3864b3..e7161269 100644 --- a/main/plugin.py +++ b/main/plugin.py @@ -72,6 +72,7 @@ def pytest_configure(config: pytest_config.Config) -> None: """ config.option.keyword = "automated" config.option.markexpr = "not not_in_scope" + pytest.globalDict = defaultdict() is_driver = [arg for arg in config.invocation_params.args if "driver" in arg] if is_driver and not os.environ.get('BOILERPLATE_INSTALLATION'): config.pluginmanager.import_plugin("main.frontend.frontend_plugin") From a4e364f06906279b41d175a91a7e8cb37cbba79b Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 12:28:35 +0500 Subject: [PATCH 07/12] removed extra email step --- main/frontend/common/step_definitions/email.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/main/frontend/common/step_definitions/email.py b/main/frontend/common/step_definitions/email.py index 4a66523b..9937aa2e 100644 --- a/main/frontend/common/step_definitions/email.py +++ b/main/frontend/common/step_definitions/email.py @@ -25,15 +25,14 @@ @then(parsers.re("I get link from email '(?P.*)'"), converters=dict(user_type=str)) def check_email(user_type, selenium_generics: SeleniumGenerics): - time.sleep(5) create_json() from datetime import date today = date.today() from datetime import timedelta - yesterday = today - timedelta(days=1) + thirty_days = today - timedelta(days=30) date_today = today.strftime("%d %b %Y") - date_yesterday = yesterday.strftime("%d %b %Y") + date_old = thirty_days.strftime("%d %b %Y") if '0' in date_today[0]: date_today = date_today[1:] f = open(test_data_dir) @@ -42,7 +41,7 @@ def check_email(user_type, selenium_generics: SeleniumGenerics): value = i if "Test Project Data" in value["Subject"] or "Test Data" in value["Subject"] and \ "tauqirsarwar1@gmail.com" in value["From"] and date_today in value["Date"] or \ - date_yesterday in value["Date"] and user_type in value["To"]: + date_old in value["Date"] and user_type in value["To"]: decoded_data = base64.b64decode(value["Message"]) soup = BeautifulSoup(decoded_data, "lxml") email_body = str(soup.body()[0]) From 3c27d97aae57cb1750f14e4abc5c4c4833a68d2b Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 12:29:21 +0500 Subject: [PATCH 08/12] removed extra email step --- main/plugin.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/plugin.py b/main/plugin.py index e7161269..814930f6 100644 --- a/main/plugin.py +++ b/main/plugin.py @@ -10,7 +10,7 @@ from _pytest.fixtures import FixtureLookupError from py.xml import html -from collections import OrderedDict +from collections import OrderedDict, defaultdict from datetime import datetime from pathlib import Path from typing import List From 6a6f51a3d8d05a190e8133749b562369000c41ca Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 Date: Mon, 15 Apr 2024 12:37:01 +0500 Subject: [PATCH 09/12] removed extra IDs --- .../step_definitions/browser_navigation.py | 35 ------------------- .../common/step_definitions/date_time.py | 4 --- .../common/step_definitions/excel_and_csv.py | 17 --------- .../step_definitions/mobile_device_actions.py | 2 -- .../text_assertion_editing.py | 3 -- 5 files changed, 61 deletions(-) diff --git a/main/frontend/common/step_definitions/browser_navigation.py b/main/frontend/common/step_definitions/browser_navigation.py index 90c2f5c4..ed867f3d 100644 --- a/main/frontend/common/step_definitions/browser_navigation.py +++ b/main/frontend/common/step_definitions/browser_navigation.py @@ -22,7 +22,6 @@ # WEB context Predefined Step -# ID 101, 102 @given(parsers.re("The browser resolution is '(?P.*)' per '(?P.*)'"), converters=dict(width=data_manager.text_formatted, height=data_manager.text_formatted), ) @given(parsers.re("My screen resolution is '(?P.*)' by '(?P.*)' pixels"), @@ -36,7 +35,6 @@ def window_size(width: int, height: int, selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 103 @given("Browser is maximized") @when("Browser is maximized") def maximize(selenium_generics: SeleniumGenerics): @@ -44,7 +42,6 @@ def maximize(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 104 @given(parsers.re("I am on the (url|page|site) '(?P.*)'"), converters=dict(page_url=data_manager.text_formatted), ) @when(parsers.re("I am on the (url|page|site) '(?P.*)'"), @@ -60,7 +57,6 @@ def open_base_url(selenium_generics: SeleniumGenerics, base_url): # WEB context Predefined Step -# ID 105 @given(parsers.re("I navigate to external page '(?P.*)'"), converters=dict(url=data_manager.text_formatted), ) @when(parsers.re("I navigate to external page '(?P.*)'"), @@ -70,7 +66,6 @@ def navigate_to_external_page(selenium_generics: SeleniumGenerics, url: str): # WEB context Predefined Step -# ID 106 @given(parsers.re("I get current browser url and store it to '(?P.*)'")) @when(parsers.re("I get current browser url and store it to '(?P.*)'")) @then(parsers.re("I get current browser url and store it to '(?P.*)'")) @@ -121,7 +116,6 @@ def page_title_is_not(selenium_generics: SeleniumGenerics, soft_assert: str, tit # WEB context Predefined Step -# ID 110 @then(parsers.re("(With soft assertion '(?P.*)' )?I expect that the title contains '(?P.*)'"), converters=dict(title=data_manager.text_formatted), ) def check_title_contains(selenium_generics: SeleniumGenerics, soft_assert: str, title: str): @@ -133,7 +127,6 @@ def check_title_contains(selenium_generics: SeleniumGenerics, soft_assert: str, # WEB context Predefined Step -# ID 111 @then( parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?I expect that the title does not contain '(?P<title>.*)'"), converters=dict(title=data_manager.text_formatted), ) @@ -146,7 +139,6 @@ def check_title_not_contains(selenium_generics: SeleniumGenerics, soft_assert: s # WEB context Predefined Step -# ID 112 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The page url is '(?P<url>.*)'"), converters=dict(url=data_manager.text_formatted), ) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The page url is '(?P<url>.*)'"), @@ -162,7 +154,6 @@ def given_page_url_is(selenium_generics: SeleniumGenerics, soft_assert: str, url # WEB context Predefined Step -# ID 113 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The page url is not '(?P<url>.*)'"), converters=dict(url=data_manager.text_formatted), ) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The page url is not '(?P<url>.*)'"), @@ -178,7 +169,6 @@ def given_page_url_is_not(selenium_generics: SeleniumGenerics, soft_assert: str, # WEB context Predefined Step -# ID 114 @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The page (path is|url contains) '(?P<url>.*)'"), converters=dict(url=data_manager.text_formatted), ) def check_page_url_contains(selenium_generics: SeleniumGenerics, soft_assert: str, url: str): @@ -190,7 +180,6 @@ def check_page_url_contains(selenium_generics: SeleniumGenerics, soft_assert: st # WEB context Predefined Step -# ID 115 @then(parsers.re( "(With soft assertion '(?P<soft_assert>.*)' )?The page (path is not|url does not contain) '(?P<url>.*)'"), converters=dict(url=data_manager.text_formatted), ) @@ -203,7 +192,6 @@ def check_page_url_not_contains(selenium_generics: SeleniumGenerics, soft_assert # WEB context Predefined Step -# ID 116 @given(parsers.re("I refresh the current page")) @when(parsers.re("I refresh the current page")) def refresh_page(selenium_generics: SeleniumGenerics): @@ -211,7 +199,6 @@ def refresh_page(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 117 @given(parsers.re("There is just one (browser tab|window) open")) @when(parsers.re("There is just one (browser tab|window) open")) def close_all_but_first_tab(selenium_generics: SeleniumGenerics): @@ -223,7 +210,6 @@ def close_all_but_first_tab(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 118 @given(parsers.re("I open new tab with url '(?P<page_url>.*)'"), converters=dict(page_url=data_manager.text_formatted), ) @when(parsers.re("I open new tab with url '(?P<page_url>.*)'"), @@ -233,7 +219,6 @@ def open_specific_tab(selenium_generics: SeleniumGenerics, base_url: str, page_u # WEB context Predefined Step -# ID 119 @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The url '(?P<url>.*)' is opened in a new (tab|window)"), converters=dict(url=data_manager.text_formatted), ) def check_is_opened_in_new_window(selenium_generics: SeleniumGenerics, soft_assert: str, url: str): @@ -246,7 +231,6 @@ def check_is_opened_in_new_window(selenium_generics: SeleniumGenerics, soft_asse # WEB context Predefined Step -# ID 120 @given(parsers.re("I close the last opened window")) @given(parsers.re("I close the last opened tab")) @when(parsers.re("I close the last opened window")) @@ -266,7 +250,6 @@ def switch_to_last(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 122 @then(parsers.re( "(With soft assertion '(?P<soft_assert>.*)' )?There are '(?P<count>.*)' (tabs|windows) currently opened"), converters=dict(count=data_manager.text_formatted)) @@ -279,7 +262,6 @@ def check_number_of_tabs(selenium_generics: SeleniumGenerics, soft_assert: str, # WEB context Predefined Step -# ID 123 @given(parsers.re("I close the current opened tab")) @when(parsers.re("I close the current opened tab")) def close_current_opened_tab(selenium_generics: SeleniumGenerics): @@ -367,7 +349,6 @@ def disable_cache(driver, cache_option: str): # WEB context Predefined Step -# ID 132 @given(parsers.re("I attach file '(?P<file_path>.*)' to input field '(?P<locator_path>.*)'"), converters=dict(file_path=data_manager.text_formatted), ) @when(parsers.re("I attach file '(?P<file_path>.*)' to input field '(?P<locator_path>.*)'"), @@ -382,7 +363,6 @@ def attach_file(selenium_generics: SeleniumGenerics, file_path: str, locators: L # WEB context Predefined Step -# ID 133 @given(parsers.re( "(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' contains the value '(?P<value>.*)'"), converters=dict(value=data_manager.text_formatted)) @@ -401,7 +381,6 @@ def check_cookie_content(selenium_generics: SeleniumGenerics, soft_assert: str, # WEB context Predefined Step -# ID 134 @given(parsers.re( "(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' does not contain the value '(?P<value>.*)'"), converters=dict(value=data_manager.text_formatted)) @@ -420,7 +399,6 @@ def check_cookie_content_is_not(selenium_generics: SeleniumGenerics, soft_assert # WEB context Predefined Step -# ID 135 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' exists")) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' exists")) @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' exists")) @@ -433,7 +411,6 @@ def check_cookie_exists(selenium_generics: SeleniumGenerics, soft_assert: str, n # WEB context Predefined Step -# ID 136 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' does not exist")) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' does not exist")) @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?The cookie '(?P<name>.*)' does not exist")) @@ -446,7 +423,6 @@ def check_cookie_does_not_exist(selenium_generics: SeleniumGenerics, soft_assert # WEB context Predefined Step -# ID 137 @given("I fetch existing cookies from the site") @when("I fetch existing cookies from the site") def fetch_cookies(selenium_generics: SeleniumGenerics): @@ -454,7 +430,6 @@ def fetch_cookies(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 138, 139 @given( parsers.re("I update the value of newly added cookie '(?P<name>.*)' with '(?P<value>.*)' for path '(?P<path>.*)'"), converters=dict(value=data_manager.text_formatted)) @@ -470,7 +445,6 @@ def check_cookie_content(selenium_generics: SeleniumGenerics, name, value: str, # WEB context Predefined Step -# ID 140 @given(parsers.re("I delete the cookie '(?P<name>.*)'")) @when(parsers.re("I delete the cookie '(?P<name>.*)'")) def delete_cookie(selenium_generics: SeleniumGenerics, name): @@ -478,7 +452,6 @@ def delete_cookie(selenium_generics: SeleniumGenerics, name): # WEB context Predefined Step -# ID 141 @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?I expect the cookies to be present")) def check_cookies_presence(selenium_generics: SeleniumGenerics, soft_assert: str): if soft_assert is not None and soft_assert.lower() == 'true': @@ -489,7 +462,6 @@ def check_cookies_presence(selenium_generics: SeleniumGenerics, soft_assert: str # WEB context Predefined Step -# ID 142, 143 @then(parsers.re( "(With soft assertion '(?P<soft_assert>.*)' )?I expect cookie '(?P<name>.*)' with value '(?P<value>.*)' to be present"), converters=dict(value=data_manager.text_formatted)) @@ -505,7 +477,6 @@ def check_cookie_presence(selenium_generics: SeleniumGenerics, soft_assert: str, # WEB context Predefined Step -# ID 144 @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?I expect cookie '(?P<name>.*)' to be deleted")) def check_cookie_delete(selenium_generics: SeleniumGenerics, soft_assert: str, name): if soft_assert is not None and soft_assert.lower() == 'true': @@ -516,7 +487,6 @@ def check_cookie_delete(selenium_generics: SeleniumGenerics, soft_assert: str, n # WEB context Predefined Step -# ID 145 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is opened")) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is opened")) @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is opened")) @@ -529,7 +499,6 @@ def step_presence_of_alert(selenium_generics: SeleniumGenerics, soft_assert: str # WEB context Predefined Step -# ID 146 @given(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is not opened")) @when(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is not opened")) @then(parsers.re("(With soft assertion '(?P<soft_assert>.*)' )?A (alertbox|confirmbox|prompt) is not opened")) @@ -542,7 +511,6 @@ def check_modal_not_present(selenium_generics: SeleniumGenerics, soft_assert: st # WEB context Predefined Step -# ID 147 @given(parsers.re("I accept popup (prompt|alertbox|confirmbox)")) @when(parsers.re("I accept popup (prompt|alertbox|confirmbox)")) def accept_alert(selenium_generics: SeleniumGenerics): @@ -550,7 +518,6 @@ def accept_alert(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 148 @given(parsers.re("I dismiss popup (prompt|alertbox|confirmbox)")) @when(parsers.re("I dismiss popup (prompt|alertbox|confirmbox)")) def dismiss_modal(selenium_generics: SeleniumGenerics): @@ -558,7 +525,6 @@ def dismiss_modal(selenium_generics: SeleniumGenerics): # WEB context Predefined Step -# ID 149 @given(parsers.re("I enter '(?P<text>.*)' into popup (alertbox|confirmbox|prompt)"), converters=dict(text=data_manager.text_formatted), ) @when(parsers.re("I enter '(?P<text>.*)' into popup (alertbox|confirmbox|prompt)"), @@ -568,7 +534,6 @@ def check_modal(selenium_generics: SeleniumGenerics, text: str): # WEB context Predefined Step -# ID 150, 151 @given(parsers.re("I set the (locale|language) for locators to '(?P<locale>.*)'"), converters=dict(locale=data_manager.text_formatted), ) @when(parsers.re("I set the (locale|language) for locators to '(?P<locale>.*)'"), diff --git a/main/frontend/common/step_definitions/date_time.py b/main/frontend/common/step_definitions/date_time.py index 76557f16..91cbddea 100644 --- a/main/frontend/common/step_definitions/date_time.py +++ b/main/frontend/common/step_definitions/date_time.py @@ -20,7 +20,6 @@ # WEB context Predefined Step -# ID 1001 @given(parsers.re("I pause for '(?P<seconds>.*)' s"), converters=dict(seconds=int)) @when(parsers.re("I pause for '(?P<seconds>.*)' s"), converters=dict(seconds=int)) def pause_execution(seconds: int): @@ -28,7 +27,6 @@ def pause_execution(seconds: int): # WEB & MOBILE contexts Predefined Step -# ID 1002 @given(parsers.re(r"I add current date to '(?P<locator_path>.*)' with '(?P<date_format>MM/dd/yyyy|MM/dd/yy|dd/MM/yyyy|dd/MM/yy|dd MMM yyyy)'")) @when(parsers.re(r"I add current date to '(?P<locator_path>.*)' with '(?P<date_format>MM/dd/yyyy|MM/dd/yy|dd/MM/yyyy|dd/MM/yy|dd MMM yyyy)'")) def add_current_date_for_element(selenium_generics: SeleniumGenerics, locators: Locators, locator_path, date_format: str): @@ -52,7 +50,6 @@ def add_current_date_for_element(selenium_generics: SeleniumGenerics, locators: # WEB & MOBILE contexts Predefined Step -# ID 1003 @given(parsers.re(r"I add random '(?P<direction>future|past)' date to '(?P<locator_path>.*)' with '(?P<date_format>MM/dd/yyyy|MM/dd/yy|dd/MM/yyyy|dd/MM/yy|dd MMM yyyy)' format")) @when(parsers.re(r"I add random '(?P<direction>future|past)' date to '(?P<locator_path>.*)' with '(?P<date_format>MM/dd/yyyy|MM/dd/yy|dd/MM/yyyy|dd/MM/yy|dd MMM yyyy)' format")) def add_custom_date_for_element(selenium_generics: SeleniumGenerics, locators: Locators, locator_path, date_format: str, direction: str): @@ -85,7 +82,6 @@ def add_custom_date_for_element(selenium_generics: SeleniumGenerics, locators: L # WEB & MOBILE contexts Predefined Step -# ID 1004 @given(parsers.re(r"I add '(?P<direction>Past|Current|Future)' time to '(?P<locator_path>.*)' with '(?P<time_format>HH:MM:SS|HH:MM)' format(\s+)?((?:and clock format)\s+(?:')(?P<clock_format>\w+)(?:'))?(\s+)?((?:and delimiter)\s+(?:')(?P<delimiter>.*)(?:'))?$")) @when(parsers.re(r"I add '(?P<direction>Past|Current|Future)' time to '(?P<locator_path>.*)' with '(?P<time_format>HH:MM:SS|HH:MM)' format(\s+)?((?:and clock format)\s+(?:')(?P<clock_format>\w+)(?:'))?(\s+)?((?:and delimiter)\s+(?:')(?P<delimiter>.*)(?:'))?$")) def add_custom_time_for_element(selenium_generics: SeleniumGenerics, locators: Locators, locator_path, time_format: str, direction: str, delimiter: str, clock_format: str): diff --git a/main/frontend/common/step_definitions/excel_and_csv.py b/main/frontend/common/step_definitions/excel_and_csv.py index 94de1de9..be9002cc 100644 --- a/main/frontend/common/step_definitions/excel_and_csv.py +++ b/main/frontend/common/step_definitions/excel_and_csv.py @@ -12,7 +12,6 @@ logger = structlog.get_logger(__name__) -# ID 901 @given(parsers.re("Text inside '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' is equal to '(?P<expected_text>.+)'"), converters=dict(cell=data_manager.text_formatted, sheet_name=data_manager.text_formatted, expected_text=data_manager.text_formatted)) @when(parsers.re("Text inside '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' is equal to '(?P<expected_text>.+)'"), @@ -36,7 +35,6 @@ def cell_text_contains(cell:str, sheet_name: str, file_path: str, expected_text: assert_that(sheet[cell].value).contains(expected_text) -# ID 903 @given(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' does not contain any text"), converters=dict(cell=data_manager.text_formatted, sheet_name=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' does not contain any text"), @@ -48,7 +46,6 @@ def cell_text_is_empty(cell:str, sheet_name: str, file_path: str): assert_that(sheet[cell].value).is_none() -# ID 904 @given(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' text is equal with the text of the '(?P<locator_path>.+)'"), converters=dict(cell=data_manager.text_formatted, sheet_name=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' text is equal with the text of the '(?P<locator_path>.+)'"), @@ -60,7 +57,6 @@ def cell_text_equals_element_text(selenium_generics, locators, cell:str, sheet_n assert_that(sheet[cell].value).is_equal_to(selenium_generics.get_element_text(locators.parse_and_get(locator_path, selenium_generics))) -# ID 905 @given(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' is contained in the text of '(?P<locator_path>.+)'"), converters=dict(cell=data_manager.text_formatted, sheet_name=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.+)' on sheet '(?P<sheet_name>.+)' of excel file '(?P<file_path>.+)' is contained in the text of '(?P<locator_path>.+)'"), @@ -72,7 +68,6 @@ def element_text_contains_cell_text(selenium_generics, locators, cell:str, sheet assert_that(selenium_generics.get_element_text(locators.parse_and_get(locator_path, selenium_generics))).contains(sheet[cell].value) -# ID 906 @given(parsers.re("I delete '(?P<file_path>.*)' file")) @when(parsers.re("I delete '(?P<file_path>.*)' file")) def delete_file(file_path: str): @@ -91,7 +86,6 @@ def create_excel_file(file_name: str, file_path: str): openpyxl.Workbook().save(excel_file.as_posix()) -# ID 908 @given(parsers.re("I write '(?P<text>.*)' to '(?P<cell>.*)' on '(?P<sheet_name>.*)' of excel file '(?P<file_path>.*)'"), converters=dict(cell=data_manager.text_formatted, sheet_name=data_manager.text_formatted, text=data_manager.text_formatted)) @@ -105,7 +99,6 @@ def write_text_to_excel_file(text: str, cell: str, sheet_name: str, file_path: s wb.save(excel_file) -# ID 911 @given(parsers.re("Number of total rows on '(?P<sheet_name>.*)' of excel file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), converters=dict(row_count=data_manager.text_formatted, sheet_name=data_manager.text_formatted)) @when(parsers.re("Number of total rows on '(?P<sheet_name>.*)' of excel file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), @@ -121,7 +114,6 @@ def total_rows_number_with_data_is_equal_to(sheet_name: str, file_path: str, row assert_that(int(num_rows)).is_equal_to(int(row_count)) -# ID 912 @given(parsers.re("Number of rows containing '(?P<expected_text>.*)' on '(?P<sheet_name>.*)' of excel file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), converters=dict(row_count=data_manager.text_formatted, sheet_name=data_manager.text_formatted, text=data_manager.text_formatted)) @when(parsers.re("Number of rows containing '(?P<expected_text>.*)' on '(?P<sheet_name>.*)' of excel file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), @@ -137,7 +129,6 @@ def number_rows_with_text_is_equal_to(expected_text: str, sheet_name: str, file_ assert_that(int(num_rows)).is_equal_to(int(row_count)) -# ID 913 @given(parsers.re("Text inside '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' is equal to '(?P<expected_text>.+)'"), converters=dict(expected_text=data_manager.text_formatted, cell=data_manager.text_formatted)) @when(parsers.re("Text inside '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' is equal to '(?P<expected_text>.+)'"), @@ -161,7 +152,6 @@ def csv_cell_text_is_equal_to(cell: str, file_path: str, expected_text: str): assert_that(sheet[cell].value).is_equal_to(expected_text) -# ID 914 @given(parsers.re("Text inside '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' contains '(?P<expected_text>.+)'"), converters=dict(expected_text=data_manager.text_formatted, cell=data_manager.text_formatted)) @when(parsers.re("Text inside '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' contains '(?P<expected_text>.+)'"), @@ -185,7 +175,6 @@ def csv_cell_text_contains(cell: str, file_path: str, expected_text: str): assert_that(sheet[cell].value).contains(expected_text) -# ID 915 @given(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' text is equal with the text of the '(?P<locator_path>.+)'"), converters=dict(cell=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' text is equal with the text of the '(?P<locator_path>.+)'"), @@ -209,7 +198,6 @@ def csv_cell_text_equals_element_text(selenium_generics, locators, cell: str, fi assert_that(sheet[cell].value).is_equal_to(selenium_generics.get_element_text(locators.parse_and_get(locator_path, selenium_generics))) -# ID 916 @given(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' is contained in the text of '(?P<locator_path>.+)'"), converters=dict(cell=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' is contained in the text of '(?P<locator_path>.+)'"), @@ -234,7 +222,6 @@ def element_text_contains_csv_cell_text(selenium_generics, locators, cell: str, sheet[cell].value) -# ID 917 @given(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' does not contain any text"), converters=dict(cell=data_manager.text_formatted)) @when(parsers.re("The '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)' does not contain any text"), @@ -258,7 +245,6 @@ def csv_cell_text_is_empty(cell: str, file_path: str): assert_that(sheet[cell].value).is_empty() -# ID 918 @given(parsers.re("Number of rows containing '(?P<expected_text>.*)' of csv file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), converters=dict(expected_text=data_manager.text_formatted, row_count=data_manager.text_formatted)) @when(parsers.re("Number of rows containing '(?P<expected_text>.*)' of csv file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), @@ -287,7 +273,6 @@ def number_csv_rows_with_text_is_equal_to(expected_text: str, file_path: str, ro assert_that(int(num_rows)).is_equal_to(int(row_count)) -# ID 919 @given(parsers.re("Number of total rows of csv file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), converters=dict(row_count=data_manager.text_formatted)) @when(parsers.re("Number of total rows of csv file '(?P<file_path>.*)' is '(?P<row_count>.*)'"), @@ -316,7 +301,6 @@ def total_csv_rows_number_with_data_is_equal_to(file_path: str, row_count: str): assert_that(int(num_rows)).is_equal_to(int(row_count)) -# ID 921 @given(parsers.re("I Write '(?P<text>.+)' to '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)'"), converters=dict(cell=data_manager.text_formatted, text=data_manager.text_formatted)) @when(parsers.re("I Write '(?P<text>.+)' to '(?P<cell>.*)' cell of csv file '(?P<file_path>.*)'"), @@ -350,7 +334,6 @@ def write_text_to_csv_cell(text: str, cell: str, file_path: str): writer.writerow([cell.value for cell in row]) -# ID 922 @given(parsers.re("I create csv file '(?P<file_name>.*)' and save on '(?P<file_path>.+)'")) @when(parsers.re("I create csv file '(?P<file_name>.*)' and save on '(?P<file_path>.+)'")) def create_csv_file(file_name: str, file_path: str): diff --git a/main/frontend/common/step_definitions/mobile_device_actions.py b/main/frontend/common/step_definitions/mobile_device_actions.py index 833c6ee5..fe8c2576 100644 --- a/main/frontend/common/step_definitions/mobile_device_actions.py +++ b/main/frontend/common/step_definitions/mobile_device_actions.py @@ -12,7 +12,6 @@ # MOBILE Predefined Step -# ID 1202 @when("I reset the mobile app") @then("I reset the mobile app") def reset_app(selenium_generics: SeleniumGenerics): @@ -23,7 +22,6 @@ def reset_app(selenium_generics: SeleniumGenerics): # MOBILE Predefined Step -# 1203 @when(parsers.re("I put the mobile app in background for '(?P<seconds>.*)' seconds"), converters=dict(seconds=data_manager.text_formatted)) @then(parsers.re("I put the mobile app in background for '(?P<seconds>.*)' seconds"), diff --git a/main/frontend/common/step_definitions/text_assertion_editing.py b/main/frontend/common/step_definitions/text_assertion_editing.py index 666e47ee..1f85f5e7 100644 --- a/main/frontend/common/step_definitions/text_assertion_editing.py +++ b/main/frontend/common/step_definitions/text_assertion_editing.py @@ -324,7 +324,6 @@ def step_realistic_typing(selenium_generics: SeleniumGenerics, locators: Locator # WEB context Predefined Step -# ID 417 @given(parsers.re( "I add text '(?P<text>.*)' in input field whose attribute '(?P<attribute>.*)' is equal to '(?P<value>.*)'"), converters=dict(text=data_manager.text_formatted), ) @@ -342,7 +341,6 @@ def add_text_based_on_attribute(selenium_generics: SeleniumGenerics, locators, t # WEB & MOBILE contexts Predefined Step -# ID 418, 805 @given(parsers.re( r"I add random string of length (?:')(?P<length>.*)(?:') composed of (?:')(?P<character_type>alphabetic characters|numeric characters|alphabetic and numeric characters)(?:') to field (?:')(?P<locator_path>.*)(?:')(\s+)?((?:and save as)\s+(?:')(?P<storage_var>\w+)(?:') environment variable)?$")) @when(parsers.re( @@ -364,7 +362,6 @@ def set_random_element_value(selenium_generics: SeleniumGenerics, length: str, c # WEB & MOBILE contexts Predefined Step -# ID 419 @given( parsers.re(r"I add a random email to field '(?P<locator_path>.*)'((\s+)?with (?:')(?P<domain>.*)(?:') domain)?$"), converters=dict(domain=data_manager.text_formatted), ) From 99a1a9ffeb67649abfdc6e004a08089d47af0d58 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 <tauqir.sarwar@pfizer.com> Date: Mon, 15 Apr 2024 12:38:52 +0500 Subject: [PATCH 10/12] removed emails --- test_data/files/email_data.json | 26 -------------------------- test_data/files/email_reader.txt | 21 --------------------- 2 files changed, 47 deletions(-) diff --git a/test_data/files/email_data.json b/test_data/files/email_data.json index 77deaae1..e69de29b 100644 --- a/test_data/files/email_data.json +++ b/test_data/files/email_data.json @@ -1,26 +0,0 @@ -[ - { - "Subject": "Test Data", - "From": "tauqir sarwar <tauqirsarwar1@gmail.com>", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Mon, 15 Apr 2024 10:04:25 +0500", - "Message": "VGVzdCBEYXRhDQoNCmh0dHBzOi8vbW9kdXNjcmVhdGUuY29tL2Fib3V0Lw0K", - "Url": "PGRpdiBkaXI9Imx0ciI+VGVzdCBEYXRhPGJyPjxkaXY+PGJyPjwvZGl2PjxkaXY+PGEgaHJlZj0iaHR0cHM6Ly9tb2R1c2NyZWF0ZS5jb20vYWJvdXQvIj5odHRwczovL21vZHVzY3JlYXRlLmNvbS9hYm91dC88L2E+PGJyPjwvZGl2PjxkaXY+PGJyPjwvZGl2PjwvZGl2Pg0K" - }, - { - "Subject": "Test Project Data", - "From": "tauqir sarwar <tauqirsarwar1@gmail.com>", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Mon, 15 Apr 2024 09:02:37 +0500", - "Message": "VGVzdCBQcm9qZWN0IERhdGENCg==", - "Url": "PGRpdiBkaXI9Imx0ciI+VGVzdCBQcm9qZWN0IERhdGE8L2Rpdj4NCg==" - }, - { - "Subject": "test subject", - "From": "tauqir sarwar <tauqirsarwar1@gmail.com>", - "To": "moduspytestboilerplate@gmail.com", - "Date": "Mon, 15 Apr 2024 08:58:38 +0500", - "Message": "dGVzdCBib2R5DQo=", - "Url": "PGRpdiBkaXI9Imx0ciI+dGVzdCBib2R5PC9kaXY+DQo=" - } -] \ No newline at end of file diff --git a/test_data/files/email_reader.txt b/test_data/files/email_reader.txt index ec0054c8..e69de29b 100644 --- a/test_data/files/email_reader.txt +++ b/test_data/files/email_reader.txt @@ -1,21 +0,0 @@ -Subject : Test Data -From : tauqir sarwar <tauqirsarwar1@gmail.com> -To : moduspytestboilerplate@gmail.com -Date : Mon, 15 Apr 2024 10:04:25 +0500 -Message : VGVzdCBEYXRhDQoNCmh0dHBzOi8vbW9kdXNjcmVhdGUuY29tL2Fib3V0Lw0K -Url : PGRpdiBkaXI9Imx0ciI+VGVzdCBEYXRhPGJyPjxkaXY+PGJyPjwvZGl2PjxkaXY+PGEgaHJlZj0iaHR0cHM6Ly9tb2R1c2NyZWF0ZS5jb20vYWJvdXQvIj5odHRwczovL21vZHVzY3JlYXRlLmNvbS9hYm91dC88L2E+PGJyPjwvZGl2PjxkaXY+PGJyPjwvZGl2PjwvZGl2Pg0K - -Subject : Test Project Data -From : tauqir sarwar <tauqirsarwar1@gmail.com> -To : moduspytestboilerplate@gmail.com -Date : Mon, 15 Apr 2024 09:02:37 +0500 -Message : VGVzdCBQcm9qZWN0IERhdGENCg== -Url : PGRpdiBkaXI9Imx0ciI+VGVzdCBQcm9qZWN0IERhdGE8L2Rpdj4NCg== - -Subject : test subject -From : tauqir sarwar <tauqirsarwar1@gmail.com> -To : moduspytestboilerplate@gmail.com -Date : Mon, 15 Apr 2024 08:58:38 +0500 -Message : dGVzdCBib2R5DQo= -Url : PGRpdiBkaXI9Imx0ciI+dGVzdCBib2R5PC9kaXY+DQo= - From 9bfb0f5ab12cc7d3534dd748b5647930f9527295 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 <tauqir.sarwar@pfizer.com> Date: Mon, 15 Apr 2024 12:39:22 +0500 Subject: [PATCH 11/12] removed emails --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 5d000003..79ba50c6 100644 --- a/.gitignore +++ b/.gitignore @@ -160,3 +160,4 @@ allure-report/* reports/screenshots/* /test_data/visualtesting/test/* /output/ +/test_data/files/ From 58f2ad00e48c3f8cc7278443ff662e66a0e7e5a0 Mon Sep 17 00:00:00 2001 From: tauqirsarwar1 <tauqir.sarwar@pfizer.com> Date: Mon, 15 Apr 2024 12:45:36 +0500 Subject: [PATCH 12/12] removed emails --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 79ba50c6..cc37a4f9 100644 --- a/.gitignore +++ b/.gitignore @@ -160,4 +160,4 @@ allure-report/* reports/screenshots/* /test_data/visualtesting/test/* /output/ -/test_data/files/ +/test_data/files/*