def test_fo_graphical_icon_disappears(self):
o = get_mock_graphical_output()
overlay = FunctionOverlay([lambda: True, lambda: False])
mu = Menu([], get_mock_input(), o, name=ui_name, config={})
mu.idle_loop = lambda *a, **k: True
Canvas.fonts_dir = fonts_dir
overlay.apply_to(mu)
def activate():
mu.before_activate()
mu.to_foreground()
mu.idle_loop()
img_1 = o.display_image.call_args[0]
mu.idle_loop()
mu.refresh()
img_2 = o.display_image.call_args[0]
assert(img_1 == img_2)
for i in range(overlay.duration):
mu.idle_loop()
mu.refresh()
img_2 = o.display_image.call_args[0]
assert(img_1 != img_2)
mu.deactivate() # KEY_LEFT
with patch.object(mu, 'activate', side_effect=activate) as p:
mu.activate()
def test_left_key_returns_none(self):
num_elements = 3
contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)]
mu = Menu(contents,
get_mock_input(),
get_mock_output(),
name=mu_name,
config={})
mu.refresh = lambda *args, **kwargs: None
# Checking at the start of the list
def scenario():
mu.deactivate() # KEY_LEFT
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert return_value is None
# Checking at the end of the list
def scenario():
for i in range(num_elements):
mu.move_down() # KEY_DOWN x3
mu.deactivate() # KEY_LEFT
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert return_value is None
def wireless_status():
w_status = wpa_cli.connection_status()
state = w_status['wpa_state']
status_menu_contents = [[["state:", state]]] #State is an element that's always there, let's see possible states
if state == 'COMPLETED':
#We have bssid, ssid and key_mgmt at least
status_menu_contents.append(['SSID: '+w_status['ssid']])
status_menu_contents.append(['BSSID: '+w_status['bssid']])
key_mgmt = w_status['key_mgmt']
status_menu_contents.append([['Security:', key_mgmt]])
#If we have WPA in key_mgmt, we also have pairwise_cipher and group_cipher set to something other than NONE so we can show them
if key_mgmt != 'NONE':
try: #What if?
group = w_status['group_cipher']
pairwise = w_status['pairwise_cipher']
status_menu_contents.append([['Group/Pairwise:', group+"/"+pairwise]])
except:
pass
elif state in ['AUTHENTICATING', 'SCANNING', 'ASSOCIATING']:
pass #These states don't have much information
#In any case, we might or might not have IP address info
status_menu_contents.append([['IP address:',w_status['ip_address'] if 'ip_address' in w_status else 'None']])
#We also always have WiFi MAC address as 'address'
status_menu_contents.append(['MAC: '+w_status['address']])
status_menu = Menu(status_menu_contents, i, o, "Wireless status menu", entry_height=2)
status_menu.activate()
def test_contents_hook(self):
"""Tests whether menu contents hook is executed"""
ev = Event()
def gen_contents():
return [["True", ev.clear] if ev.isSet() else ["False", ev.set]]
mu = Menu([],
get_mock_input(),
get_mock_output(),
name=mu_name,
contents_hook=gen_contents,
config={})
def scenario():
assert mu.contents[0][0] == "False"
mu.select_entry()
assert mu.contents[0][0] == "True"
mu.select_entry()
assert mu.contents[0][0] == "False"
mu.deactivate()
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
def show_scan_results():
network_menu_contents = []
networks = wpa_cli.get_scan_results()
for network in networks:
network_menu_contents.append([network['ssid'], lambda x=network: network_info_menu(x)])
network_menu = Menu(network_menu_contents, i, o, "Wireless network menu")
network_menu.activate()
def wireless_status():
w_status = wpa_cli.connection_status()
state = w_status['wpa_state']
status_menu_contents = [[["state:", state]]] #State is an element that's always there, let's see possible states
if state == 'COMPLETED':
#We have bssid, ssid and key_mgmt at least
status_menu_contents.append(['SSID: '+w_status['ssid']])
status_menu_contents.append(['BSSID: '+w_status['bssid']])
key_mgmt = w_status['key_mgmt']
status_menu_contents.append([['Security:', key_mgmt]])
#If we have WPA in key_mgmt, we also have pairwise_cipher and group_cipher set to something other than NONE so we can show them
if key_mgmt != 'NONE':
try: #What if?
group = w_status['group_cipher']
pairwise = w_status['pairwise_cipher']
status_menu_contents.append([['Group/Pairwise:', group+"/"+pairwise]])
except:
pass
elif state in ['AUTHENTICATING', 'SCANNING', 'ASSOCIATING']:
pass #These states don't have much information
#In any case, we might or might not have IP address info
status_menu_contents.append([['IP address:',w_status['ip_address'] if 'ip_address' in w_status else 'None']])
#We also always have WiFi MAC address as 'address'
status_menu_contents.append(['MAC: '+w_status['address']])
status_menu = Menu(status_menu_contents, i, o, "Wireless status menu", entry_height=2)
status_menu.activate()
def launch():
try:
current_interface = wpa_cli.get_current_interface()
except OSError as e:
if e.errno == 2:
Printer(["Do you have", "wpa_cli?"], i, o, 3, skippable=True)
return
else:
raise e
except wpa_cli.WPAException:
Printer([
"Do you have", "wireless cards?", "Is wpa_supplicant", "running?"
],
i,
o,
3,
skippable=True)
return
else:
main_menu_contents = [
[current_interface, change_interface],
["Scan", scan],
["Networks", show_networks],
["Status", wireless_status],
["Save changes", save_changes],
#["Saved networks", manage_saved_networks],
["Exit", 'exit']
]
main_menu = Menu(main_menu_contents, i, o, "wpa_cli main menu")
main_menu.activate()
def test_enter_on_last_returns_right(self):
num_elements = 3
contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)]
mu = Menu(contents,
get_mock_input(),
get_mock_output(),
name=mu_name,
config={})
mu.refresh = lambda *args, **kwargs: None
# Checking at other elements - shouldn't return
def scenario():
mu.select_entry() # KEY_ENTER
assert mu.in_foreground # Should still be active
mu.deactivate(
) # because is not deactivated yet and would idle loop otherwise
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert return_value is None
# Scrolling to the end of the list and pressing Enter - should return a correct dict
def scenario():
for i in range(num_elements):
mu.move_down() # KEY_DOWN x3
mu.select_entry() # KEY_ENTER
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert isinstance(return_value, dict)
assert all(
[isinstance(key, basestring) for key in return_value.keys()])
assert all(
[isinstance(value, bool) for value in return_value.values()])
def show_scan_results():
network_menu_contents = []
networks = wpa_cli.get_scan_results()
for network in networks:
network_menu_contents.append(
[network['ssid'], lambda x=network: network_info_menu(x)])
network_menu = Menu(network_menu_contents, i, o, "Wireless network menu")
network_menu.activate()
def change_interface():
#This function builds a menu out of all the interface names, each having a callback to show_if_function with interface name as argument
menu_contents = []
interfaces = wpa_cli.get_interfaces()
for interface in interfaces:
menu_contents.append([interface, lambda x=interface: change_current_interface(x)])
interface_menu = Menu(menu_contents, i, o, "Interface change menu")
interface_menu.activate()
def change_interface():
#This function builds a menu out of all the interface names, each having a callback to show_if_function with interface name as argument
menu_contents = []
interfaces = wpa_cli.get_interfaces()
for interface in interfaces:
menu_contents.append([interface, lambda x=interface: change_current_interface(x)])
interface_menu = Menu(menu_contents, i, o, "Interface change menu")
interface_menu.activate()
def network_info_menu(network_info):
network_info_contents = [
["Connect", lambda x=network_info: connect_to_network(x)],
["BSSID", lambda x=network_info['bssid']: Printer(x, i, o, 5, skippable=True)],
["Frequency", lambda x=network_info['frequency']: Printer(x, i, o, 5, skippable=True)],
["Open" if wpa_cli.is_open_network(network_info) else "Secured", lambda x=network_info['flags']: Printer(x, i, o, 5, skippable=True)]]
network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False)
network_info_menu.activate()
def network_info_menu(network_info):
network_info_contents = [
["Connect", lambda x=network_info: connect_to_network(x)],
["BSSID", lambda x=network_info['bssid']: Printer(x, i, o, 5, skippable=True)],
["Frequency", lambda x=network_info['frequency']: Printer(x, i, o, 5, skippable=True)],
["Open" if wpa_cli.is_open_network(network_info) else "Secured", lambda x=network_info['flags']: Printer(x, i, o, 5, skippable=True)]]
network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False)
network_info_menu.activate()
def manage_networks():
global saved_networks
saved_networks = wpa_cli.list_configured_networks()
network_menu_contents = []
#As of wpa_supplicant 2.3-1, header elements are ['network id', 'ssid', 'bssid', 'flags']
for num, network in enumerate(saved_networks):
network_menu_contents.append(["{0[network id]}: {0[ssid]}".format(network), lambda x=num: saved_network_menu(saved_networks[x])])
network_menu = Menu(network_menu_contents, i, o, "Saved network menu", catch_exit=False)
network_menu.activate()
def callback():
c = [["Update ZPUI", git_updater.update, git_updater.settings],
["Bugreport", bugreport_ui.main_menu],
["Logging settings", logging_ui.config_logging],
["About", about.about]]
menu = Menu(c, i, o, "ZPUI settings menu")
help_text = "Press RIGHT on \"Update ZPUI\" to change OTA update settings (branch or git URL to use)"
HelpOverlay(help_text).apply_to(menu)
menu.activate()
def show_ifc_data(ifc_name):
ch = lambda x=ifc_name: get_ifc_menu_contents(x)
ifd_menu = Menu([],
i,
o,
"{} interface data menu".format(ifc_name),
entry_height=2,
contents_hook=ch)
ifd_menu.activate()
def manage_networks():
global saved_networks
saved_networks = wpa_cli.list_configured_networks()
network_menu_contents = []
#As of wpa_supplicant 2.3-1, header elements are ['network id', 'ssid', 'bssid', 'flags']
for num, network in enumerate(saved_networks):
network_menu_contents.append(["{0[network id]}: {0[ssid]}".format(network), lambda x=num: saved_network_menu(saved_networks[x])])
network_menu = Menu(network_menu_contents, i, o, "Saved network menu", catch_exit=False)
network_menu.activate()
def show_ifc_data(ifc_name, ifc_data):
ifd_menu_contents = [
["state: "+str(ifc_data['state'])],
["IP: "+str(ifc_data['addr'])],
["IP6: "+str(ifc_data['addr6'])],
["MAC: "+str(ifc_data['ph_addr'])]
]
ifd_menu = Menu(ifd_menu_contents, i, o, "{} interface data menu".format(ifc_name), entry_height=2)
ifd_menu.activate()
def show_scan_results():
network_menu_contents = []
networks = wpa_cli.get_scan_results()
for network in networks:
if network["ssid"] == '':
ssid = '[Hidden]'
elif network["ssid"]:
ssid = network["ssid"]
network_menu_contents.append([ssid, lambda x=network: network_info_menu(x)])
network_menu = Menu(network_menu_contents, i, o, "Wireless network menu")
network_menu.activate()
def test_ho_text_redraw(self):
overlay = HelpOverlay(lambda: True)
mu = Menu([["Hello"]], get_mock_input(), get_mock_output(), name=ui_name, config={})
overlay.apply_to(mu)
def scenario():
mu.deactivate()
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
assert mu.o.display_data.called
assert mu.o.display_data.call_count == 1 #One in to_foreground
assert mu.o.display_data.call_args[0] == ('Hello', mu.exit_entry[0])
def launch():
try:
systemctl.list_units()
except OSError as e:
if e.errno == 2:
Printer(["Do you use", "systemctl?"], i, o, 3, skippable=True)
return
else:
raise e
main_menu_contents = [["Units (filtered)", filtered_units],
["All units", all_units],
["Change filters", change_filters]]
main_menu = Menu(main_menu_contents, i, o, "systemctl main menu")
main_menu.activate()
def show_ifc_data(ifc_name, ifc_data):
ip, mask = str(ifc_data['addr']).rsplit('/', 1)
ip_header = "IP: "
mask_str = "/{}".format(mask)
ip_header_str = ip_header + mask_str.rjust(o.cols-len(ip_header)) #Magic to make it beautiful
print(ip_header_str)
ifd_menu_contents = [
["state: "+str(ifc_data['state'])],
[[ip_header_str, ip]],
["IP6: "+str(ifc_data['addr6']), lambda: Printer(str(ifc_data['addr6']), i, o, 3)],
["MAC: "+str(ifc_data['ph_addr'])]
]
ifd_menu = Menu(ifd_menu_contents, i, o, "{} interface data menu".format(ifc_name), entry_height=2)
ifd_menu.activate()
def test_fo_graphical_redraw(self):
o = get_mock_graphical_output()
overlay = FunctionOverlay([lambda: True, lambda: False])
mu = Menu([], get_mock_input(), o, name=ui_name, config={})
Canvas.fonts_dir = fonts_dir
overlay.apply_to(mu)
# Exiting immediately, but we should get at least one redraw
def scenario():
mu.deactivate() # KEY_LEFT
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
assert o.display_image.called
assert o.display_image.call_count == 1 #One in to_foreground
def launch():
try:
systemctl.list_units()
except OSError as e:
if e.errno == 2:
Printer(["Do you use", "systemctl?"], i, o, 3, skippable=True)
return
else:
raise e
main_menu_contents = [
["Units (filtered)", filtered_units],
["All units", all_units],
["Change filters", change_filters]]
main_menu = Menu(main_menu_contents, i, o, "systemctl main menu")
main_menu.activate()
class MainMenu(ZeroApp):
menu_name = "Main Menu"
def on_start(self):
self.m = Menu([], self.i, self.o)
self.overlay = SpinnerOverlay()
def test_func(x):
self.overlay.set_state(self.m, not self.overlay.get_state(self.m))
menu_contents = [[str(i), lambda x=i: test_func(x)] for i in range(16)]
self.overlay.apply_to(self.m)
self.m.set_contents(menu_contents)
self.m.activate()
def test_graphical_redraw_with_eh_2(self):
"""
Tests for a bug where a menu with one two-elements-high entry would fail to render
"""
num_elements = 3
o = get_mock_graphical_output()
contents = [[["A" + str(i), "B" + str(i)], "a" + str(i)]
for i in range(num_elements)]
mu = Menu(contents,
get_mock_input(),
o,
name=mu_name,
entry_height=2,
append_exit=False,
config={})
Canvas.fonts_dir = fonts_dir
# Exiting immediately, but we should get at least one redraw
def scenario():
mu.deactivate() # KEY_LEFT
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert o.display_image.called
assert o.display_image.call_count == 1 #One in to_foreground
def launch():
try:
status = tvservice.status()
except OSError as e:
if e.errno == 2:
Printer(["Do you have", "tvservice?"], i, o, 3, skippable=True)
return
else:
raise e
else:
main_menu_contents = [["Status", show_status],
["Choose HDMI mode", select_hdmi_mode],
["Display on", display_on],
["Display off", display_off]]
main_menu = Menu(main_menu_contents, i, o, "tvservice main menu")
main_menu.activate()
def shows_data_on_screen_wrapper(self, contents):
i = get_mock_input()
o = get_mock_output()
mu = Menu(contents, i, o, name=mu_name, config={})
def scenario():
mu.deactivate()
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
#The scenario should only be called once
assert mu.idle_loop.called
assert mu.idle_loop.call_count == 1
assert o.display_data.called
assert o.display_data.call_count == 1 #One in to_foreground
assert o.display_data.call_args[0] == ('A0', 'A1', 'A2', 'Back')
def saved_network_menu(network_info):
global saved_networks
id = network_info['network id']
bssid = network_info['bssid']
network_status = network_info["flags"] if network_info["flags"] else "[ENABLED]"
network_info_contents = [
[network_status],
["Select", lambda x=id: select_network(x)],
["Enable", lambda x=id: enable_network(x)],
["Disable", lambda x=id: disable_network(x)],
["Remove", lambda x=id: remove_network(x)],
["Set password", lambda x=id: set_password(x)],
["BSSID", lambda x=bssid: Printer(x, i, o, 5, skippable=True)]]
network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False)
network_info_menu.activate()
#After menu exits, we'll request the status again and update the
saved_networks = wpa_cli.list_configured_networks()
def saved_network_menu(network_info):
global saved_networks
id = network_info['network id']
bssid = network_info['bssid']
network_status = network_info["flags"] if network_info["flags"] else "[ENABLED]"
network_info_contents = [
[network_status],
["Select", lambda x=id: select_network(x)],
["Enable", lambda x=id: enable_network(x)],
["Disable", lambda x=id: disable_network(x)],
["Remove", lambda x=id: remove_network(x)],
["Set password", lambda x=id: set_password(x)],
["BSSID", lambda x=bssid: Printer(x, i, o, 5, skippable=True)]]
network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False)
network_info_menu.activate()
#After menu exits, we'll request the status again and update the network list
saved_networks = wpa_cli.list_configured_networks()
def init_app(input, output):
global if_menu, callback, i, o
i = input
o = output
if_menu = Menu([], i, o, "Interface selection menu")
if_menu.activate = activate_wrapper(
if_menu.activate
) #Decorating around the menu.activate module so that every time menu is activated interface data is refreshed
callback = if_menu.activate
def test_left_key_disabled_when_not_exitable(self):
"""Tests whether a menu does not exit on KEY_LEFT when exitable is set to False"""
num_elements = 3
contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)]
mu = Menu(contents,
get_mock_input(),
get_mock_output(),
name=mu_name,
exitable=False,
config={})
mu.refresh = lambda *args, **kwargs: None
def scenario():
assert "KEY_LEFT" not in mu.keymap # KEY_LEFT
mu.deactivate()
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
def test_so_spins(self):
Canvas.fonts_dir = fonts_dir
o = get_mock_graphical_output()
overlay = SpinnerOverlay()
mu = Menu([], get_mock_input(), o, name=ui_name)
mu.idle_loop = lambda *a, **k: True
overlay.apply_to(mu)
overlay.set_state(mu, False)
def activate():
mu.before_activate()
mu.to_foreground()
mu.idle_loop()
img_1 = o.display_image.call_args[0]
mu.idle_loop()
mu.refresh()
img_2 = o.display_image.call_args[0]
assert(img_1 == img_2)
# enabling the spinner
overlay.set_state(mu, True)
# first iteration of the spinner
mu.idle_loop()
img_3 = o.display_image.call_args[0]
assert(img_3 != img_1)
# second iteration of the spinner
mu.idle_loop()
img_4 = o.display_image.call_args[0]
assert(img_4 != img_1)
assert(img_4 != img_3)
# disabling the spinner
overlay.set_state(mu, False)
mu.idle_loop() # now idle_loop shouldn't contain a refresh
img_5 = o.display_image.call_args[0]
assert(img_5 == img_4)
mu.refresh() # now, after an explicit refresh, there should be no spinner left
img_6 = o.display_image.call_args[0]
assert(img_6 == img_1)
assert(img_6 != img_3)
assert(img_6 != img_4)
mu.deactivate() # KEY_LEFT
with patch.object(mu, 'activate', side_effect=activate) as p:
mu.activate()
def test_shows_data_on_screen(self):
"""Tests whether the Menu outputs data on screen when it's ran"""
num_elements = 3
contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)]
i = get_mock_input()
o = get_mock_output()
mu = Menu(contents, i, o, name=mu_name, config={})
def scenario():
mu.deactivate()
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
#The scenario should only be called once
assert mu.idle_loop.called
assert mu.idle_loop.call_count == 1
assert o.display_data.called
assert o.display_data.call_count == 1 #One in to_foreground
assert o.display_data.call_args[0] == ('A0', 'A1', 'A2', 'Back')
def callback():
if systemctl is None:
PrettyPrinter(
"python-gi not found! Please install it using 'apt-get install python-gi' ",
i, o, 5)
return
try:
systemctl.list_units()
except OSError as e:
if e.errno == 2:
PrettyPrinter("Do you use systemctl?", i, o, 3, skippable=True)
return
else:
raise e
main_menu_contents = [["Pinned units", pinned_units],
["Units (filtered)", filtered_units],
["All units", all_units],
["Change filters", change_filters]]
main_menu = Menu(main_menu_contents, i, o, "systemctl main menu")
main_menu.activate()
def test_contents_hook_2(self):
"""
Tests whether menu contents hook is executed
and whether on_contents_hook_fail works when
it is supposed to work.
"""
self.test_contents_hook_2_counter = 0
contentss = [[["True"]], [["False"]], None]
def gen_contents():
if len(contentss) <= self.test_contents_hook_2_counter:
raise Exception
contents = contentss[self.test_contents_hook_2_counter]
self.test_contents_hook_2_counter += 1
return contents
ochf = Mock()
mu = Menu([],
get_mock_input(),
get_mock_output(),
name=mu_name,
contents_hook=gen_contents,
on_contents_hook_fail=ochf,
config={})
def scenario():
assert mu.contents[0][0] == "True"
mu.select_entry()
assert mu.contents[0][0] == "False"
mu.select_entry()
assert ochf.called
assert ochf.call_count == 1 # first because contents_hook returned None
mu.set_contents([])
mu.before_foreground()
assert ochf.call_count == 2 # second because of the exception raised
mu.deactivate()
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
mu.activate()
def graphical_display_redraw_wrapper(self, contents):
o = get_mock_graphical_output()
mu = Menu(contents, get_mock_input(), o, name=mu_name, config={})
Canvas.fonts_dir = fonts_dir
# Exiting immediately, but we should get at least one redraw
def scenario():
mu.deactivate() # KEY_LEFT
assert not mu.in_foreground
with patch.object(mu, 'idle_loop', side_effect=scenario) as p:
return_value = mu.activate()
assert o.display_image.called
assert o.display_image.call_count == 1 #One in to_foreground
def callback():
#Check if we have all the software necessary for the app to work
#If not, show error messages and exit
if nmap is None:
PrettyPrinter("nmap Python module not found!", i, o, 3)
return False
try:
nm = nmap.PortScanner()
except nmap.nmap.PortScannerError:
PrettyPrinter("nmap not installed!", i, o, 3)
return False
#Dump function support
i.set_maskable_callback("KEY_F6", dump_current_scan_to_file)
#Constructing and loading app main menu
menu_contents = [["Smart scan", smart_scan],
["Scan a network", scan_network_menu],
["Scan arbitrary IP", scan_arbitrary_ip],
["Scan localhost", scan_localhost]]
menu = Menu(menu_contents, i, o)
help_text = "Press F6 in the scan results menu to save the scan results into a file"
HelpOverlay(help_text).apply_to(menu)
menu.activate()
#Have to remove the dump function callback because once application exits it isn't removed automatically
i.remove_maskable_callback("KEY_F6")
def init_app(input, output):
global if_menu, callback, i, o
i = input; o = output
if_menu = Menu([], i, o, "Interface selection menu")
if_menu.activate = activate_wrapper(if_menu.activate) #Decorating around the menu.activate module so that every time menu is activated interface data is refreshed
callback = if_menu.activate
