def test_main(self):

"""Main entry point. All the code must run inside one

print("")

print("CEF Python {ver}".format(ver=cef.__version__))

print("Python {ver}".format(ver=sys.version[:6]))

# Test initialization of CEF

settings = {

"debug": False,

"log_severity": cef.LOGSEVERITY_ERROR,

"log_file": "",

}

if not LINUX:

# On Linux you get a lot of "X error received" messages

# from Chromium's "x11_util.cc", so do not show them.

settings["log_severity"] = cef.LOGSEVERITY_WARNING

if "--debug" in sys.argv:

settings["debug"] = True

settings["log_severity"] = cef.LOGSEVERITY_INFO

if "--debug-warning" in sys.argv:

settings["debug"] = True

settings["log_severity"] = cef.LOGSEVERITY_WARNING

# Chrome 130+ blocks window.open() called without a user gesture.

switches = {"disable-popup-blocking": ""}

if LINUX:

# Open a GDK/X11 display connection before CEF initialises so

# that gdk_display_get_default() returns a valid display. On a

# desktop session this is required for the browser window to be

# visible; on xvfb (CI) it is a no-op.

init_gtk()

# cefpython does not ship a chrome-sandbox (setuid) binary.

# Disable SUID/namespace sandboxes; Chrome falls back to seccomp-BPF

# which keeps GlobalDescriptors key 7 registered for subprocesses.

# Do NOT pass --no-sandbox: it skips key 7 registration but encodes

# it in --pseudonymization-salt-handle, causing a CHECK-crash.

switches["disable-setuid-sandbox"] = ""

# /dev/shm is too small in CI containers.

switches["disable-dev-shm-usage"] = ""

# GPU acceleration is not available under xvfb.

switches["disable-gpu"] = ""

switches["disable-gpu-compositing"] = ""

# Run GPU process inside the browser process so it is not

# spawned during CefInitialize() where it would fail.

switches["in-process-gpu"] = ""

switches["no-zygote"] = ""

# Force X11 rendering via XWayland. On Ubuntu 24 GNOME/Wayland

# Chrome 130+ defaults to the Wayland Ozone backend when

# WAYLAND_DISPLAY is set; cefpython uses raw X11 APIs so the

# window would never appear. On CI (xvfb) this is a no-op.

switches["ozone-platform"] = "x11"

# Run the network service in-process so no utility subprocess

# needs to be spawned (reduces spawn overhead on CI).

# The feature string in Chrome 130+ is "NetworkServiceInProcess2".

switches["enable-features"] = "NetworkServiceInProcess2"

# Suppress the GNOME Keyring unlock prompt on desktop sessions.

switches["password-store"] = "basic"

if MAC:

# cefpython does not ship a chrome-sandbox binary.

switches["no-sandbox"] = ""

# No real GPU available on macOS CI runners.

switches["disable-gpu"] = ""

switches["disable-gpu-compositing"] = ""

switches["in-process-gpu"] = ""

# Prevent macOS keychain authorization prompts during init

# (matches CEF's own test infrastructure on macOS).

switches["use-mock-keychain"] = ""

# Chrome 130+ MachPortRendezvousServer registers via

# bootstrap_check_in; renderer subprocesses look up the service

# via bootstrap_look_up, which fails on unsigned CI processes

# because Chrome gives them a restricted bootstrap namespace.

# --in-process-renderer was removed from Chrome 130+.

# --single-process runs the renderer in the browser process,

# eliminating renderer subprocess bootstrap_look_up failures.

switches["single-process"] = ""

# --single-process puts the renderer's V8 in the browser process,

# which requires a large contiguous CodeRange for JIT code.

# On constrained CI runner images this reservation fails with an

# OOM error. --jitless disables all V8 JIT compilers, eliminating

# the CodeRange requirement entirely.

switches["js-flags"] = "--jitless"

# Run network service in-process to avoid Mach port rendezvous

# failures for utility subprocesses on macOS CI runners.

# The feature string in Chrome 130+ is "NetworkServiceInProcess2".

switches["enable-features"] = "NetworkServiceInProcess2"

cef.Initialize(settings, switches=switches)

subtest_message("cef.Initialize() ok")

# CRL set file

certrevoc_dir = ""

if WINDOWS:

certrevoc_dir = r"C:\localappdata\Google\Chrome\User Data" \

r"\CertificateRevocation"

elif LINUX:

certrevoc_dir = r"/home/*/.config/google-chrome" \

r"/CertificateRevocation"

elif MAC:

certrevoc_dir = r"/Users/*/Library/Application Support/Google" \

r"/Chrome/CertificateRevocation"

crlset_files = glob.iglob(os.path.join(certrevoc_dir, "*",

"crl-set"))

crlset = ""

for crlset in crlset_files:

pass

if os.path.exists(crlset):

cef.LoadCrlSetsFile(crlset)

subtest_message("cef.LoadCrlSetsFile ok")

# High DPI on Windows.

# Setting DPI awareness from Python is usually too late and should be done

# via manifest file. Alternatively change python.exe properties > Compatibility

# > High DPI scaling override > Application.

# Using cef.DpiAware.EnableHighDpiSupport is problematic, it can cause

# display glitches.

if WINDOWS:

self.assertIsInstance(cef.DpiAware.GetSystemDpi(), tuple)

window_size = cef.DpiAware.CalculateWindowSize(800, 600)

self.assertIsInstance(window_size, tuple)

self.assertGreater(window_size[0], 0)

self.assertGreater(cef.DpiAware.Scale((800, 600))[0], 0)

# Make some calls again after DPI Aware was set

self.assertIsInstance(cef.DpiAware.GetSystemDpi(), tuple)

self.assertGreater(cef.DpiAware.Scale([800, 600])[0], 0)

self.assertIsInstance(cef.DpiAware.Scale(800), int)

self.assertGreater(cef.DpiAware.Scale(800), 0)

subtest_message("cef.DpiAware ok")

# Global handler

global_handler = GlobalHandler(self)

cef.SetGlobalClientCallback("OnAfterCreated",

global_handler._OnAfterCreated)

subtest_message("cef.SetGlobalClientCallback() ok")

# Create browser

browser_settings = {

"inherit_client_handlers_for_popups": False,

}

browser = cef.CreateBrowserSync(url=g_datauri,

settings=browser_settings)

self.assertIsNotNone(browser, "Browser object")

browser.SetFocus(True)

subtest_message("cef.CreateBrowserSync() ok")

# Client handlers

display_handler2 = DisplayHandler2(self)

v8context_handler = V8ContextHandler(self)

client_handlers = [LoadHandler(self, g_datauri),

DisplayHandler(self),

display_handler2,

v8context_handler]

for handler in client_handlers:

browser.SetClientHandler(handler)

subtest_message("browser.SetClientHandler() ok")

# Javascript bindings

external = External(self)

bindings = cef.JavascriptBindings(

bindToFrames=False, bindToPopups=False)

bindings.SetFunction("js_code_completed", js_code_completed)

bindings.SetFunction("test_function", external.test_function)

bindings.SetProperty("test_property1", external.test_property1)

bindings.SetProperty("test_property2", external.test_property2)

# Property with a function value can also be bound. CEF Python

# supports passing functions as callbacks when called from

# javascript, and as a side effect any value and in this case

# a property can also be a function.

bindings.SetProperty("test_property3_function",

external.test_property3_function)

bindings.SetProperty("cefpython_version", cef.GetVersion())

bindings.SetObject("external", external)

browser.SetJavascriptBindings(bindings)

subtest_message("browser.SetJavascriptBindings() ok")

# Set auto resize. Call it after js bindings were set.

browser.SetAutoResizeEnabled(enabled=True,

min_size=[800, 600],

max_size=[1024, 768])

subtest_message("browser.SetAutoResizeEnabled() ok")

# Test Request.SetPostData(list)

# noinspection PyArgumentList

req = cef.Request.CreateRequest()

req_file = os.path.dirname(os.path.abspath(__file__))

req_file = os.path.join(req_file, "main_test.py")

if sys.version_info.major > 2:

req_file = req_file.encode("utf-8")

req_data = [b"--key=value", b"@"+req_file]

req.SetMethod("POST")

req.SetPostData(req_data)

self.assertEqual(req_data, req.GetPostData())

subtest_message("cef.Request.SetPostData(list) ok")

# Test Request.SetPostData(dict)

# noinspection PyArgumentList

req = cef.Request.CreateRequest()

req_data = {b"key": b"value"}

req.SetMethod("POST")

req.SetPostData(req_data)

self.assertEqual(req_data, req.GetPostData())

subtest_message("cef.Request.SetPostData(dict) ok")

# Cookie manager

self.assertIsInstance(cef.CookieManager.GetGlobalManager(),

cef.PyCookieManager)

subtest_message("cef.CookieManager ok")

# Window Utils

if WINDOWS:

hwnd = 1 # When using 0 getting issues with OnautoResize

self.assertFalse(cef.WindowUtils.IsWindowHandle(hwnd))

cef.WindowUtils.OnSetFocus(hwnd, 0, 0, 0)

cef.WindowUtils.OnSize(hwnd, 0, 0, 0)

cef.WindowUtils.OnEraseBackground(hwnd, 0, 0, 0)

cef.WindowUtils.GetParentHandle(hwnd)

cef.WindowUtils.SetTitle(browser, "Main test")

subtest_message("cef.WindowUtils ok")

elif LINUX:

cef.WindowUtils.InstallX11ErrorHandlers()

subtest_message("cef.WindowUtils ok")

elif MAC:

hwnd = 0

cef.WindowUtils.GetParentHandle(hwnd)

cef.WindowUtils.IsWindowHandle(hwnd)

subtest_message("cef.WindowUtils ok")

# Run message loop

run_message_loop()

# Make sure popup browser was destroyed

self.assertIsInstance(cef.GetBrowserByIdentifier(MAIN_BROWSER_ID),

cef.PyBrowser)

self.assertIsNone(cef.GetBrowserByIdentifier(POPUP_BROWSER_ID))

subtest_message("cef.GetBrowserByIdentifier() ok")

# Close browser and clean reference

browser.CloseBrowser(True)

del browser

subtest_message("browser.CloseBrowser() ok")

# Give it some time to close before checking asserts

# and calling shutdown.

do_message_loop_work(25)

# Asserts before shutdown

self.assertEqual(display_handler2.OnLoadingProgressChange_Progress,

1.0)

# noinspection PyTypeChecker

check_auto_asserts(self, [] + client_handlers

+ [global_handler,

external])

# Test shutdown of CEF

cef.Shutdown()

subtest_message("cef.Shutdown() ok")

# Display summary

show_test_summary(__file__)

def __init__(self, test_case):

self.test_case = test_case

# Asserts for True/False will be checked just before shutdown.

# Test whether asserts are working correctly.

self.test_for_True = True

# CEF 146+: SetAutoResizeEnabled no longer triggers OnAutoResize for

# windowed (non-OSR) browsers. Removed OnAutoResize_True assertion.

self.OnLoadingProgressChange_True = False

self.OnLoadingProgressChange_Progress = 0.0

def OnAutoResize(self, new_size, **_):

pass # CEF 146+: no longer fires for windowed browsers

def OnLoadingProgressChange(self, browser, progress, **_):

self.OnLoadingProgressChange_True = True

def __init__(self, test_case):

self.test_case = test_case

# CEF 146+: only one V8 context is created per navigation.

# The initial empty-document context that existed in older CEF

# versions (and was released immediately) is no longer created.

self.OnContextCreatedFirstCall_True = False

def OnContextCreated(self, browser, frame):

self.OnContextCreatedFirstCall_True = True

self.test_case.assertEqual(browser.GetIdentifier(), MAIN_BROWSER_ID)

self.test_case.assertTrue(frame.GetIdentifier())

def OnContextReleased(self, browser, frame):

# CEF 146+: no longer called for the initial empty-document context

# (which no longer exists). May still be called in other scenarios.

self.test_case.assertEqual(browser.GetIdentifier(), MAIN_BROWSER_ID)

"""Javascript 'window.external' object."""

def __init__(self, test_case):

self.test_case = test_case

# Test binding properties to the 'window' object.

# 2147483648 is out of INT_MAX limit and will be sent to JS as string value.

self.test_property1 = "Test binding property to the 'window' object"

self.test_property2 = {"key1": self.test_property1,

"key2": ["Inside list", 2147483647, 2147483648]}

# Asserts for True/False will be checked just before shutdown

self.test_for_True = True # Test whether asserts are working correctly

self.test_function_True = False

self.test_property3_function_True = False

self.test_callbacks_True = False

self.py_callback_True = False

def test_function(self):

"""Test binding function to the 'window' object."""

self.test_function_True = True

def test_property3_function(self):

"""Test binding function to the 'window' object."""

self.test_property3_function_True = True

def test_callbacks(self, js_callback):

"""Test both javascript and python callbacks."""

def py_callback(msg_from_js):

self.py_callback_True = True

self.test_case.assertEqual(msg_from_js,

"String sent from Javascript")

self.test_callbacks_True = True