updates
This commit is contained in:
emdee
parent
18195f287c
commit
9111a1def8
303
wrapper/tox.py
303
wrapper/tox.py
|
|
@ -27,6 +27,7 @@ def LOG_TRACE(a):
|
|||
|
||||
UINT32_MAX = 2 ** 32 -1
|
||||
class ToxError(RuntimeError): pass
|
||||
TOX_MAX_STATUS_MESSAGE_LENGTH = 1007
|
||||
|
||||
global aTIMES
|
||||
aTIMES=dict()
|
||||
|
|
@ -65,6 +66,7 @@ class ToxOptions(Structure):
|
|||
('log_callback', c_void_p),
|
||||
('log_user_data', c_void_p),
|
||||
('experimental_thread_safety', c_bool),
|
||||
('operating_system', c_void_p),
|
||||
]
|
||||
|
||||
|
||||
|
|
@ -517,7 +519,8 @@ class Tox:
|
|||
|
||||
:return: length of the current nickname
|
||||
"""
|
||||
return Tox.libtoxcore.tox_self_get_name_size(self._tox_pointer)
|
||||
retval = Tox.libtoxcore.tox_self_get_name_size(self._tox_pointer)
|
||||
return int(retval)
|
||||
|
||||
def self_get_name(self, name=None):
|
||||
"""
|
||||
|
|
@ -548,9 +551,10 @@ class Tox:
|
|||
:return: True on success.
|
||||
"""
|
||||
tox_err_set_info = c_int()
|
||||
if len(status_message) > TOX_MAX_STATUS_MESSAGE_LENGTH:
|
||||
status_message = status_message[:TOX_MAX_STATUS_MESSAGE_LENGTH]
|
||||
if type(status_message) != bytes:
|
||||
status_message = bytes(status_message, 'utf-8')
|
||||
status_message = status_message[:80]
|
||||
LOG_DEBUG(f"tox.self_set_status_message")
|
||||
result = Tox.libtoxcore.tox_self_set_status_message(self._tox_pointer,
|
||||
c_char_p(status_message),
|
||||
|
|
@ -559,9 +563,9 @@ class Tox:
|
|||
tox_err_set_info = tox_err_set_info.value
|
||||
if tox_err_set_info == TOX_ERR_SET_INFO['OK']:
|
||||
return bool(result)
|
||||
elif tox_err_set_info == TOX_ERR_SET_INFO['NULL']:
|
||||
if tox_err_set_info == TOX_ERR_SET_INFO['NULL']:
|
||||
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
|
||||
elif tox_err_set_info == TOX_ERR_SET_INFO['TOO_LONG']:
|
||||
if tox_err_set_info == TOX_ERR_SET_INFO['TOO_LONG']:
|
||||
raise ArgumentError('Information length exceeded maximum permissible size.')
|
||||
raise ToxError('The function did not return OK.')
|
||||
|
||||
|
|
@ -602,7 +606,8 @@ class Tox:
|
|||
return
|
||||
if bTooSoon('self', 'tox_self_set_status', 5.0): return None
|
||||
LOG_DEBUG(f"tox.self_set_status {status}")
|
||||
Tox.libtoxcore.tox_self_set_status(self._tox_pointer, c_int(status))
|
||||
Tox.libtoxcore.tox_self_set_status(self._tox_pointer, c_uint32(status))
|
||||
return None
|
||||
|
||||
def self_get_status(self):
|
||||
"""
|
||||
|
|
@ -612,7 +617,8 @@ class Tox:
|
|||
"""
|
||||
if bTooSoon('self', 'self_set_status', 10.0): return None
|
||||
LOG_TRACE(f"tox_get_status")
|
||||
return Tox.libtoxcore.tox_self_get_status(self._tox_pointer)
|
||||
result = Tox.libtoxcore.tox_self_get_status(self._tox_pointer)
|
||||
return int(result)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Friend list management
|
||||
|
|
@ -814,7 +820,8 @@ class Tox:
|
|||
public_key = create_string_buffer(TOX_PUBLIC_KEY_SIZE)
|
||||
tox_err_friend_get_public_key = c_int()
|
||||
LOG_TRACE(f"tox_friend_get_public_key")
|
||||
Tox.libtoxcore.tox_friend_get_public_key(self._tox_pointer, c_uint32(friend_number), public_key,
|
||||
Tox.libtoxcore.tox_friend_get_public_key(self._tox_pointer,
|
||||
c_uint32(friend_number), public_key,
|
||||
byref(tox_err_friend_get_public_key))
|
||||
tox_err_friend_get_public_key = tox_err_friend_get_public_key.value
|
||||
if tox_err_friend_get_public_key == TOX_ERR_FRIEND_GET_PUBLIC_KEY['OK']:
|
||||
|
|
@ -884,7 +891,8 @@ class Tox:
|
|||
name = create_string_buffer(self.friend_get_name_size(friend_number))
|
||||
tox_err_friend_query = c_int()
|
||||
LOG_DEBUG(f"tox.friend_get_name")
|
||||
Tox.libtoxcore.tox_friend_get_name(self._tox_pointer, c_uint32(friend_number), name,
|
||||
Tox.libtoxcore.tox_friend_get_name(self._tox_pointer,
|
||||
c_uint32(friend_number), name,
|
||||
byref(tox_err_friend_query))
|
||||
tox_err_friend_query = tox_err_friend_query.value
|
||||
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
|
||||
|
|
@ -958,7 +966,9 @@ class Tox:
|
|||
status_message = create_string_buffer(self.friend_get_status_message_size(friend_number))
|
||||
tox_err_friend_query = c_int()
|
||||
LOG_DEBUG(f"tox.friend_get_status_message")
|
||||
Tox.libtoxcore.tox_friend_get_status_message(self._tox_pointer, c_uint32(friend_number), status_message,
|
||||
Tox.libtoxcore.tox_friend_get_status_message(self._tox_pointer,
|
||||
c_uint32(friend_number),
|
||||
status_message,
|
||||
byref(tox_err_friend_query))
|
||||
tox_err_friend_query = tox_err_friend_query.value
|
||||
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
|
||||
|
|
@ -1008,17 +1018,19 @@ class Tox:
|
|||
"""
|
||||
tox_err_friend_query = c_int()
|
||||
LOG_DEBUG(f"tox.friend_get_status")
|
||||
result = Tox.libtoxcore.tox_friend_get_status(self._tox_pointer, c_uint32(friend_number),
|
||||
result = Tox.libtoxcore.tox_friend_get_status(self._tox_pointer,
|
||||
c_uint32(friend_number),
|
||||
byref(tox_err_friend_query))
|
||||
tox_err_friend_query = tox_err_friend_query.value
|
||||
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
|
||||
return result
|
||||
return int(result)
|
||||
elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']:
|
||||
raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike'
|
||||
' the `_self_` variants of these functions, which have no effect when a parameter is'
|
||||
' NULL, these functions return an error in that case.')
|
||||
elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['FRIEND_NOT_FOUND']:
|
||||
raise ArgumentError('The friend_number did not designate a valid friend.')
|
||||
raise ToxError('The function did not return OK.')
|
||||
|
||||
def callback_friend_status(self, callback):
|
||||
"""
|
||||
|
|
@ -1054,11 +1066,12 @@ class Tox:
|
|||
"""
|
||||
tox_err_friend_query = c_int()
|
||||
LOG_DEBUG(f"tox.friend_get_connection_status")
|
||||
result = Tox.libtoxcore.tox_friend_get_connection_status(self._tox_pointer, c_uint32(friend_number),
|
||||
result = Tox.libtoxcore.tox_friend_get_connection_status(self._tox_pointer,
|
||||
c_uint32(friend_number),
|
||||
byref(tox_err_friend_query))
|
||||
tox_err_friend_query = tox_err_friend_query.value
|
||||
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
|
||||
return result
|
||||
return int(result)
|
||||
elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']:
|
||||
raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike'
|
||||
' the `_self_` variants of these functions, which have no effect when a parameter is'
|
||||
|
|
@ -1102,7 +1115,8 @@ class Tox:
|
|||
"""
|
||||
tox_err_friend_query = c_int()
|
||||
LOG_DEBUG(f"tox.friend_get_typing")
|
||||
result = Tox.libtoxcore.tox_friend_get_typing(self._tox_pointer, c_uint32(friend_number),
|
||||
result = Tox.libtoxcore.tox_friend_get_typing(self._tox_pointer,
|
||||
c_uint32(friend_number),
|
||||
byref(tox_err_friend_query))
|
||||
tox_err_friend_query = tox_err_friend_query.value
|
||||
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
|
||||
|
|
@ -1194,7 +1208,7 @@ class Tox:
|
|||
byref(tox_err_friend_send_message))
|
||||
tox_err_friend_send_message = tox_err_friend_send_message.value
|
||||
if tox_err_friend_send_message == TOX_ERR_FRIEND_SEND_MESSAGE['OK']:
|
||||
return result
|
||||
return int(result)
|
||||
elif tox_err_friend_send_message == TOX_ERR_FRIEND_SEND_MESSAGE['NULL']:
|
||||
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
|
||||
elif tox_err_friend_send_message == TOX_ERR_FRIEND_SEND_MESSAGE['FRIEND_NOT_FOUND']:
|
||||
|
|
@ -1311,7 +1325,7 @@ class Tox:
|
|||
if hash is None:
|
||||
hash = create_string_buffer(TOX_HASH_LENGTH)
|
||||
LOG_DEBUG(f"tox.hash")
|
||||
Tox.libtoxcore.tox_hash(hash, c_char_p(data), len(data))
|
||||
Tox.libtoxcore.tox_hash(hash, c_char_p(data), c_size_t(len(data)))
|
||||
return bin_to_string(hash, TOX_HASH_LENGTH)
|
||||
|
||||
def file_control(self, friend_number, file_number, control):
|
||||
|
|
@ -1507,7 +1521,7 @@ class Tox:
|
|||
err_file = tox_err_file_send.value
|
||||
if err_file == TOX_ERR_FILE_SEND['OK']:
|
||||
# UINT32_MAX
|
||||
return result
|
||||
return int(result)
|
||||
if err_file == TOX_ERR_FILE_SEND['NULL']:
|
||||
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
|
||||
if err_file == TOX_ERR_FILE_SEND['FRIEND_NOT_FOUND']:
|
||||
|
|
@ -1833,7 +1847,7 @@ class Tox:
|
|||
result = Tox.libtoxcore.tox_self_get_udp_port(self._tox_pointer, byref(tox_err_get_port))
|
||||
tox_err_get_port = tox_err_get_port.value
|
||||
if tox_err_get_port == TOX_ERR_GET_PORT['OK']:
|
||||
return result
|
||||
return int(result)
|
||||
if tox_err_get_port == TOX_ERR_GET_PORT['NOT_BOUND']:
|
||||
raise ToxError('The instance was not bound to any port.')
|
||||
raise ToxError('The function did not return OK')
|
||||
|
|
@ -1848,7 +1862,7 @@ class Tox:
|
|||
result = Tox.libtoxcore.tox_self_get_tcp_port(self._tox_pointer, byref(tox_err_get_port))
|
||||
tox_err_get_port = tox_err_get_port.value
|
||||
if tox_err_get_port == TOX_ERR_GET_PORT['OK']:
|
||||
return result
|
||||
return int(result)
|
||||
if tox_err_get_port == TOX_ERR_GET_PORT['NOT_BOUND']:
|
||||
raise ToxError('The instance was not bound to any port.')
|
||||
raise ToxError('The function did not return OK')
|
||||
|
|
@ -1889,7 +1903,7 @@ class Tox:
|
|||
result = Tox.libtoxcore.tox_group_new(self._tox_pointer,
|
||||
privacy_state,
|
||||
group_name,
|
||||
len(group_name),
|
||||
c_size_t(len(group_name)),
|
||||
peer_info, byref(error))
|
||||
else:
|
||||
nick_length = len(nick)
|
||||
|
|
@ -1898,9 +1912,9 @@ class Tox:
|
|||
result = Tox.libtoxcore.tox_group_new(self._tox_pointer,
|
||||
privacy_state,
|
||||
cgroup_name,
|
||||
len(group_name),
|
||||
c_size_t(len(group_name)),
|
||||
cnick,
|
||||
nick_length,
|
||||
c_size_t(nick_length),
|
||||
byref(error))
|
||||
|
||||
if error.value:
|
||||
|
|
@ -1908,7 +1922,8 @@ class Tox:
|
|||
LOG_ERROR(f"group_new {error.value} {s}")
|
||||
raise ToxError(f"group_new {s} {error.value}")
|
||||
|
||||
return result
|
||||
# TypeError: '<' not supported between instances of 'c_uint' and 'int'
|
||||
return int(result)
|
||||
|
||||
def group_join(self, chat_id, password, nick, status=''):
|
||||
"""Joins a group chat with specified Chat ID.
|
||||
|
|
@ -1945,7 +1960,6 @@ class Tox:
|
|||
peer_info,
|
||||
byref(error))
|
||||
else:
|
||||
cnick = c_char_p(nick)
|
||||
if not password:
|
||||
# dunno
|
||||
cpassword = POINTER(None)()
|
||||
|
|
@ -1953,19 +1967,19 @@ class Tox:
|
|||
cpassword = c_char_p(password)
|
||||
result = Tox.libtoxcore.tox_group_join(self._tox_pointer,
|
||||
string_to_bin(chat_id),
|
||||
cnick,
|
||||
len(nick),
|
||||
c_char_p(nick),
|
||||
c_size_t(len(nick)),
|
||||
cpassword,
|
||||
len(password) if password else 0,
|
||||
c_size_t(len(password)) if password else 0,
|
||||
|
||||
byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_JOIN)
|
||||
LOG_ERROR(f"group_new err={error.value} {s}")
|
||||
raise ToxError(f"group_new {s} err={error.value}")
|
||||
LOG_INFO(f"group_new result={result} {chat_id}")
|
||||
LOG_INFO(f"group_new result={result} chat_id={chat_id}")
|
||||
|
||||
return result
|
||||
return int(result)
|
||||
|
||||
def group_reconnect(self, group_number):
|
||||
"""
|
||||
|
|
@ -1982,12 +1996,12 @@ class Tox:
|
|||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_reconnect")
|
||||
result = Tox.libtoxcore.tox_group_reconnect(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_reconnect(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_RECONNECT)
|
||||
LOG_ERROR(f"group_new {error.value} {s}")
|
||||
raise ToxError(f"group_new {s} {error.value}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
def group_is_connected(self, group_number):
|
||||
if group_number < 0:
|
||||
|
|
@ -1995,25 +2009,25 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_is_connected")
|
||||
result = Tox.libtoxcore.tox_group_is_connected(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_is_connected(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
# TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_IS_CONNECTED)
|
||||
LOG_ERROR(f"group_new err={error.value} {s}")
|
||||
raise ToxError("group_is_connected err={error.value} {s}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
def group_disconnect(self, group_number):
|
||||
if group_number < 0:
|
||||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_disconnect")
|
||||
result = Tox.libtoxcore.tox_group_disconnect(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_disconnect(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_DISCONNECT)
|
||||
LOG_ERROR(f"group_disconnect {error.value} {s}")
|
||||
raise ToxError(f"group_disconnect {s} {error.value}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
def group_leave(self, group_number, message=None):
|
||||
"""Leaves a group.
|
||||
|
|
@ -2039,12 +2053,12 @@ class Tox:
|
|||
f.restype = c_bool
|
||||
if message is not None and type(message) != bytes:
|
||||
message = bytes(message, 'utf-8')
|
||||
result = f(self._tox_pointer, group_number, message,
|
||||
len(message) if message else 0, byref(error))
|
||||
result = f(self._tox_pointer, c_uint32(group_number), message,
|
||||
c_size_t(len(message)) if message else 0, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_leave {error.value}")
|
||||
raise ToxError("group_leave {error.value}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group user-visible client information (nickname/status/role/public key)
|
||||
|
|
@ -2069,11 +2083,11 @@ class Tox:
|
|||
if type(name) != bytes:
|
||||
topic = bytes(name, 'utf-8')
|
||||
LOG_DEBUG(f"tox.group_self_set_name")
|
||||
result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, group_number, name, len(name), byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, c_uint32(group_number), name, c_size_t(len(name)), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_self_set_name {error.value}")
|
||||
raise ToxError("group_self_set_name {error.value}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
def group_self_get_name_size(self, group_number):
|
||||
"""
|
||||
|
|
@ -2088,11 +2102,13 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_TRACE(f"tox_group_self_get_name_size")
|
||||
result = Tox.libtoxcore.tox_group_self_get_name_size(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_get_name_size(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_self_get_name_size {error.value}")
|
||||
raise ToxError("group_self_get_name_size {error.value}")
|
||||
return result
|
||||
return int(result)
|
||||
|
||||
def group_self_get_name(self, group_number):
|
||||
"""Write the nickname set by tox_group_self_set_name to a byte array.
|
||||
|
|
@ -2110,13 +2126,16 @@ class Tox:
|
|||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
|
||||
error = c_int()
|
||||
size = self.group_self_get_name_size(group_number)
|
||||
size = self.group_self_get_name_size(c_uint32(group_number))
|
||||
name = create_string_buffer(size)
|
||||
LOG_DEBUG(f"tox.group_self_get_name")
|
||||
result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer, group_number, name, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
name,
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_self_get_name {error.value}")
|
||||
raise ToxError("group_self_get_name {error.value}")
|
||||
LOG_ERROR(f"group_self_get_name err={error.value}")
|
||||
raise ToxError("group_self_get_name err={error.value}")
|
||||
return str(name[:size], 'utf-8', errors='ignore')
|
||||
|
||||
def group_self_set_status(self, group_number, status):
|
||||
|
|
@ -2130,11 +2149,11 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_self_set_status")
|
||||
result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, group_number, status, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, c_uint32(group_number), status, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_self_set_status {error.value}")
|
||||
raise ToxError("group_self_set_status {error.value}")
|
||||
return result
|
||||
return bool(result)
|
||||
|
||||
def group_self_get_status(self, group_number):
|
||||
"""
|
||||
|
|
@ -2146,11 +2165,11 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_self_get_status")
|
||||
result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_self_get_status {error.value}")
|
||||
raise ToxError("group_self_get_status {error.value}")
|
||||
return result
|
||||
raise ToxError("group_self_get_status err={error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_self_get_role(self, group_number):
|
||||
"""
|
||||
|
|
@ -2162,11 +2181,11 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_self_get_role")
|
||||
result = Tox.libtoxcore.tox_group_self_get_role(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_get_role(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
return result
|
||||
LOG_ERROR(f"group_self_get_role err={error.value}")
|
||||
raise ToxError(f"group_self_get_role err={error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_self_get_peer_id(self, group_number):
|
||||
"""
|
||||
|
|
@ -2178,11 +2197,11 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_self_get_peer_id")
|
||||
result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, c_uint32(group_number), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
LOG_ERROR(f"tox.group_self_get_peer_id err={error.value}")
|
||||
raise ToxError("tox_group_self_get_peer_id {error.value}")
|
||||
return result
|
||||
return int(result)
|
||||
|
||||
def group_self_get_public_key(self, group_number):
|
||||
"""
|
||||
|
|
@ -2202,11 +2221,11 @@ class Tox:
|
|||
error = c_int()
|
||||
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
LOG_DEBUG(f"tox.group_self_get_public_key")
|
||||
result = Tox.libtoxcore.tox_group_self_get_public_key(self._tox_pointer, group_number,
|
||||
result = Tox.libtoxcore.tox_group_self_get_public_key(self._tox_pointer, c_uint32(group_number),
|
||||
key, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}")
|
||||
raise ToxError(f"{TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}")
|
||||
LOG_ERROR(f"tox.group_self_get_public_key {TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}")
|
||||
raise ToxError(f"tox.group_self_get_public_key {TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}")
|
||||
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
|
@ -2225,12 +2244,12 @@ class Tox:
|
|||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, group_number, peer_id, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, c_uint32(group_number), c_uint32(peer_id), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
LOG_TRACE(f"tox_group_peer_get_name_size")
|
||||
return result
|
||||
return int(result)
|
||||
|
||||
def group_peer_get_name(self, group_number, peer_id):
|
||||
"""Write the name of the peer designated by the given ID to a byte
|
||||
|
|
@ -2254,10 +2273,13 @@ class Tox:
|
|||
size = self.group_peer_get_name_size(group_number, peer_id)
|
||||
name = create_string_buffer(size)
|
||||
LOG_DEBUG(f"tox.group_peer_get_name")
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name(self._tox_pointer, group_number, peer_id, name, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_uint32(peer_id),
|
||||
name, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f"tox_group_peer_get_name {error.value}")
|
||||
LOG_ERROR(f"tox.group_peer_get_name err={error.value}")
|
||||
raise ToxError(f"tox_group_peer_get_name err={error.value}")
|
||||
sRet = str(name[:], 'utf-8', errors='ignore')
|
||||
return sRet
|
||||
|
||||
|
|
@ -2270,14 +2292,17 @@ class Tox:
|
|||
`group_peer_status` callback.
|
||||
"""
|
||||
if group_number < 0:
|
||||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
raise ToxError(f"tox_group_ group_number < 0 group_number={group_number}")
|
||||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_peer_get_status")
|
||||
result = Tox.libtoxcore.tox_group_peer_get_status(self._tox_pointer, group_number, peer_id, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_peer_get_status(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_uint32(peer_id),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
LOG_ERROR(f"tox.group_peer_get_status {error.value}")
|
||||
raise ToxError(f"tox.group_peer_get_status {error.value}")
|
||||
return result
|
||||
|
||||
def group_peer_get_role(self, group_number, peer_id):
|
||||
|
|
@ -2293,11 +2318,14 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_peer_get_role")
|
||||
result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer, group_number, peer_id, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_uint32(peer_id),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
return result
|
||||
LOG_ERROR(f"tox.group_peer_get_role {error.value}")
|
||||
raise ToxError(f"tox.group_peer_get_role {error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_peer_get_public_key(self, group_number, peer_id):
|
||||
"""Write the group public key with the designated peer_id for the designated group number to public_key.
|
||||
|
|
@ -2318,11 +2346,13 @@ class Tox:
|
|||
error = c_int()
|
||||
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
LOG_DEBUG(f"tox.group_peer_get_public_key")
|
||||
result = Tox.libtoxcore.tox_group_peer_get_public_key(self._tox_pointer, group_number, peer_id,
|
||||
result = Tox.libtoxcore.tox_group_peer_get_public_key(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_uint32(peer_id),
|
||||
key, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
LOG_ERROR(f"tox.group_peer_get_public_key err={error.value}")
|
||||
raise ToxError(f"tox.group_peer_get_public_key err={error.value}")
|
||||
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
|
||||
def callback_group_peer_name(self, callback, user_data):
|
||||
|
|
@ -2343,6 +2373,7 @@ class Tox:
|
|||
Tox.libtoxcore.tox_callback_group_peer_name(self._tox_pointer, self.group_peer_name_cb)
|
||||
except Exception as e: # AttributeError
|
||||
LOG_ERROR(f"tox.callback_conference_peer_name")
|
||||
return None
|
||||
|
||||
def callback_group_peer_status(self, callback, user_data):
|
||||
"""
|
||||
|
|
@ -2365,6 +2396,7 @@ class Tox:
|
|||
Tox.libtoxcore.tox_callback_group_peer_status(self._tox_pointer, self.group_peer_status_cb)
|
||||
except Exception as e:
|
||||
LOG_WARN(f"callback_group_peer_status Exception {e}")
|
||||
return None
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat state queries and events.
|
||||
|
|
@ -2387,15 +2419,18 @@ class Tox:
|
|||
topic = bytes(topic, 'utf-8')
|
||||
try:
|
||||
LOG_DEBUG(f"tox.group_set_topic")
|
||||
result = Tox.libtoxcore.tox_group_set_topic(self._tox_pointer, group_number, topic, len(topic), byref(error))
|
||||
result = Tox.libtoxcore.tox_group_set_topic(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_char_p(topic),
|
||||
c_size_t(len(topic)),
|
||||
byref(error))
|
||||
except Exception as e:
|
||||
LOG_WARN(f" Exception {e}")
|
||||
result = None
|
||||
else:
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_set_topic {error.value}")
|
||||
raise ToxError("group_set_topic {error.value}")
|
||||
return result
|
||||
return None
|
||||
if error.value:
|
||||
LOG_ERROR(f"group_set_topic err={error.value}")
|
||||
raise ToxError("group_set_topic err={error.value}")
|
||||
return bool(result)
|
||||
|
||||
def group_get_topic_size(self, group_number):
|
||||
"""
|
||||
|
|
@ -2411,15 +2446,16 @@ class Tox:
|
|||
error = c_int()
|
||||
LOG_TRACE(f"tox_group_get_topic_size")
|
||||
try:
|
||||
result = Tox.libtoxcore.tox_group_get_topic_size(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_topic_size(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
byref(error))
|
||||
except Exception as e:
|
||||
LOG_WARN(f" Exception {e}")
|
||||
result = None
|
||||
else:
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
return result
|
||||
return None
|
||||
if error.value:
|
||||
LOG_ERROR(f"tox_group_get_topic_size err={error.value}")
|
||||
raise ToxError(f"tox_group_get_topic_size err={error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_get_topic(self, group_number):
|
||||
"""
|
||||
|
|
@ -2437,7 +2473,7 @@ class Tox:
|
|||
size = self.group_get_topic_size(group_number)
|
||||
topic = create_string_buffer(size)
|
||||
LOG_DEBUG(f"tox.group_get_topic")
|
||||
result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, group_number, topic, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, c_uint32(group_number), topic, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
|
|
@ -2451,7 +2487,9 @@ class Tox:
|
|||
if group_number < 0:
|
||||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_name_size(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_name_size(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
|
|
@ -2471,7 +2509,7 @@ class Tox:
|
|||
size = self.group_get_name_size(group_number)
|
||||
name = create_string_buffer(size)
|
||||
LOG_DEBUG(f"tox.group_get_name")
|
||||
result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, group_number,
|
||||
result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, c_uint32(group_number),
|
||||
name, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
|
|
@ -2492,7 +2530,7 @@ class Tox:
|
|||
error = c_int()
|
||||
buff = create_string_buffer(TOX_GROUP_CHAT_ID_SIZE)
|
||||
result = Tox.libtoxcore.tox_group_get_chat_id(self._tox_pointer,
|
||||
group_number,
|
||||
c_uint32(group_number),
|
||||
buff, byref(error))
|
||||
if error.value:
|
||||
if error.value == 1:
|
||||
|
|
@ -2519,9 +2557,10 @@ class Tox:
|
|||
try:
|
||||
result = Tox.libtoxcore.tox_group_get_number_groups(self._tox_pointer)
|
||||
except Exception as e:
|
||||
LOG_WARN(f" Exception {e}")
|
||||
LOG_WARN(f"tox.group_get_number_groups EXCEPTION {e}")
|
||||
result = 0
|
||||
return result
|
||||
LOG_DEBUG(f"tox.group_get_number_groups returning {result}")
|
||||
return int(result)
|
||||
|
||||
def groups_get_list(self):
|
||||
raise NotImplementedError('tox_groups_get_list')
|
||||
|
|
@ -2547,11 +2586,13 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_get_privacy_state")
|
||||
result = Tox.libtoxcore.tox_group_get_privacy_state(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_privacy_state(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
return result
|
||||
LOG_ERROR(f"tox.group_get_privacy_state {error.value}")
|
||||
raise ToxError(f"tox.group_get_privacy_state {error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_get_peer_limit(self, group_number):
|
||||
"""
|
||||
|
|
@ -2568,11 +2609,13 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_get_peer_limit")
|
||||
result = Tox.libtoxcore.tox_group_get_peer_limit(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_peer_limit(self._tox_pointer,
|
||||
c_uint(group_number),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
return result
|
||||
LOG_ERROR(f"tox.group_get_peer_limit {error.value}")
|
||||
raise ToxError(f"tox.group_get_peer_limit {error.value}")
|
||||
return int(result)
|
||||
|
||||
def group_get_password_size(self, group_number):
|
||||
"""
|
||||
|
|
@ -2584,7 +2627,8 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_TRACE(f"tox_group_get_password_size")
|
||||
result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer, group_number, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer,
|
||||
c_uint(group_number), byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
|
|
@ -2610,7 +2654,7 @@ class Tox:
|
|||
size = self.group_get_password_size(group_number)
|
||||
password = create_string_buffer(size)
|
||||
LOG_DEBUG(f"tox.group_get_password")
|
||||
result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, group_number,
|
||||
result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, c_uint(group_number),
|
||||
password, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
|
|
@ -2722,13 +2766,16 @@ class Tox:
|
|||
"""
|
||||
if group_number < 0:
|
||||
raise ToxError(f"tox_group_ group_number < 0 {group_number}")
|
||||
if type(data) != bytes:
|
||||
data = bytes(data, 'utf-8')
|
||||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_send_custom_packet")
|
||||
result = Tox.libtoxcore.tox_group_send_custom_packet(self._tox_pointer,
|
||||
group_number,
|
||||
lossless, data,
|
||||
len(data),
|
||||
c_uint(group_number),
|
||||
lossless,
|
||||
data,
|
||||
c_size_t(len(data)),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
|
|
@ -2759,9 +2806,12 @@ class Tox:
|
|||
message = bytes(message, 'utf-8')
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"group_send_private_message")
|
||||
result = Tox.libtoxcore.tox_group_send_private_message(self._tox_pointer, group_number, peer_id,
|
||||
result = Tox.libtoxcore.tox_group_send_private_message(self._tox_pointer,
|
||||
c_uint(group_number),
|
||||
c_uint32(peer_id),
|
||||
message_type, message,
|
||||
len(message), byref(error))
|
||||
c_size_t(len(message)),
|
||||
byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE)
|
||||
LOG_ERROR(f"group_send_private_message {error.value} {s}")
|
||||
|
|
@ -2797,10 +2847,10 @@ class Tox:
|
|||
LOG_DEBUG(f"tox.group_send_message")
|
||||
# bool tox_group_send_message(const Tox *tox, uint32_t group_number, Tox_Message_Type type, const uint8_t *message, size_t length, uint32_t *message_id, Tox_Err_Group_Send_Message *error)
|
||||
result = Tox.libtoxcore.tox_group_send_message(self._tox_pointer,
|
||||
group_number,
|
||||
c_uint(group_number),
|
||||
type_,
|
||||
message,
|
||||
len(message),
|
||||
c_size_t(len(message)),
|
||||
# dunno
|
||||
byref(message_id),
|
||||
byref(error))
|
||||
|
|
@ -2894,7 +2944,7 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_invite_friend")
|
||||
result = Tox.libtoxcore.tox_group_invite_friend(self._tox_pointer, group_number, c_uint32(friend_number), byref(error))
|
||||
result = Tox.libtoxcore.tox_group_invite_friend(self._tox_pointer, c_uint(group_number), c_uint32(friend_number), byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_INVITE_FRIEND)
|
||||
LOG_ERROR(f"group_invite_friend {error.value} {s}")
|
||||
|
|
@ -2945,8 +2995,10 @@ class Tox:
|
|||
assert type(invite_data) == bytes
|
||||
result = f(self._tox_pointer,
|
||||
c_uint32(friend_number),
|
||||
invite_data, len(invite_data),
|
||||
c_char_p(nick), len(nick),
|
||||
invite_data,
|
||||
c_size_t(len(invite_data)),
|
||||
c_char_p(nick),
|
||||
c_size_t(len(nick)),
|
||||
c_char_p(password), len(password) if password is not None else 0,
|
||||
byref(error))
|
||||
except Exception as e:
|
||||
|
|
@ -3111,8 +3163,9 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_founder_set_password")
|
||||
result = Tox.libtoxcore.tox_group_founder_set_password(self._tox_pointer, group_number, password,
|
||||
len(password), byref(error))
|
||||
result = Tox.libtoxcore.tox_group_founder_set_password(self._tox_pointer, c_uint(group_number), password,
|
||||
c_size_t(len(password)),
|
||||
byref(error))
|
||||
if error.value:
|
||||
s = sGetError(error.value, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD)
|
||||
LOG_ERROR(f"group_founder_set_password {error.value} {s}")
|
||||
|
|
@ -3139,7 +3192,7 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_founder_set_privacy_state")
|
||||
result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, group_number, privacy_state,
|
||||
result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, c_uint(group_number), privacy_state,
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
|
|
@ -3164,7 +3217,7 @@ class Tox:
|
|||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_founder_set_peer_limit")
|
||||
result = Tox.libtoxcore.tox_group_founder_set_peer_limit(self._tox_pointer,
|
||||
group_number,
|
||||
c_uint(group_number),
|
||||
max_peers,
|
||||
byref(error))
|
||||
if error.value:
|
||||
|
|
@ -3195,7 +3248,7 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_mod_set_role")
|
||||
result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, group_number, peer_id, role, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, c_uint(group_number), c_uint32(peer_id), role, byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f" {error.value}")
|
||||
raise ToxError(f" {error.value}")
|
||||
|
|
@ -3245,7 +3298,11 @@ class Tox:
|
|||
|
||||
error = c_int()
|
||||
LOG_DEBUG(f"tox.group_set_ignore")
|
||||
result = Tox.libtoxcore.tox_group_set_ignore(self._tox_pointer, group_number, peer_id, ignore, byref(error))
|
||||
result = Tox.libtoxcore.tox_group_set_ignore(self._tox_pointer,
|
||||
c_uint32(group_number),
|
||||
c_uint32(peer_id),
|
||||
c_bool(ignore),
|
||||
byref(error))
|
||||
if error.value:
|
||||
LOG_ERROR(f"tox.group_set_ignore {error.value}")
|
||||
raise ToxError("tox_group_set_ignore {error.value}")
|
||||
|
|
|
|||
|
|
@ -280,19 +280,6 @@ class ToxSuite(unittest.TestCase):
|
|||
assert oTOX_OPTIONS
|
||||
assert oTOX_OARGS
|
||||
|
||||
if not hasattr(cls, 'alice') and not hasattr(cls, 'bob'):
|
||||
l = prepare(cls)
|
||||
assert l
|
||||
cls.bob, cls.alice = l
|
||||
if not hasattr(cls.bob, '_main_loop'):
|
||||
cls.bob._main_loop = ToxIterateThread(cls.bob)
|
||||
cls.bob._main_loop.start()
|
||||
LOG.debug(f"cls.bob._main_loop: ") # {threading.enumerate()}
|
||||
if not hasattr(cls.alice, '_main_loop'):
|
||||
cls.alice._main_loop = ToxIterateThread(cls.alice)
|
||||
cls.alice._main_loop.start()
|
||||
LOG.debug(f"cls.alice._main_loop: ") # {threading.enumerate()}
|
||||
|
||||
cls.lUdp = ts.generate_nodes(
|
||||
oArgs=oTOX_OARGS,
|
||||
nodes_count=2*ts.iNODES,
|
||||
|
|
@ -305,29 +292,56 @@ class ToxSuite(unittest.TestCase):
|
|||
ipv='ipv4',
|
||||
udp_not_tcp=False)
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
"""
|
||||
if hasattr(self, 'bob') and self.bob.self_get_friend_list_size() >= 1:
|
||||
LOG.warn(f"tearDown BOBS STILL HAS A FRIEND LIST {self.bob.self_get_friend_list()}")
|
||||
for elt in self.bob.self_get_friend_list(): self.bob.friend_delete(elt)
|
||||
if hasattr(self, 'alice') and self.alice.self_get_friend_list_size() >= 1:
|
||||
LOG.warn(f"tearDown ALICE STILL HAS A FRIEND LIST {self.alice.self_get_friend_list()}")
|
||||
for elt in self.alice.self_get_friend_list(): self.alice.friend_delete(elt)
|
||||
|
||||
LOG.debug(f"tearDown threads={threading.active_count()}")
|
||||
if hasattr(self, 'bob'):
|
||||
bob.callback_self_connection_status(None)
|
||||
if hasattr(self.bob, 'main_loop'):
|
||||
self.bob._main_loop.stop_thread()
|
||||
del self.bob._main_loop
|
||||
# self.bob.kill()
|
||||
del self.bob
|
||||
if hasattr(self, 'alice'):
|
||||
alice.callback_self_connection_status(None)
|
||||
if hasattr(self.alice, 'main_loop'):
|
||||
self.alice._main_loop.stop_thread()
|
||||
del self.alice._main_loop
|
||||
# self.alice.kill()
|
||||
del self.alice
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.bob._main_loop.stop_thread()
|
||||
cls.alice._main_loop.stop_thread()
|
||||
if False:
|
||||
cls.alice.kill()
|
||||
if hasattr(cls, 'bob'):
|
||||
cls.bob._main_loop.stop_thread()
|
||||
cls.bob.kill()
|
||||
del cls.bob
|
||||
if hasattr(cls, 'alice'):
|
||||
cls.alice._main_loop.stop_thread()
|
||||
cls.alice.kill()
|
||||
del cls.alice
|
||||
|
||||
def bBobSetUp(self):
|
||||
def bBobNeedAlice(self):
|
||||
"""
|
||||
"""
|
||||
if hasattr(self, 'baid') and self.baid >= 0 and \
|
||||
self.baid in self.bob.self_get_friend_list():
|
||||
LOG.warn(f"setUp ALICE IS ALREADY IN BOBS FRIEND LIST")
|
||||
return False
|
||||
elif self.bob.self_get_friend_list_size() >= 1:
|
||||
elif self.bob.self_get_friend_list_size() >= 1:
|
||||
LOG.warn(f"setUp BOB STILL HAS A FRIEND LIST")
|
||||
return False
|
||||
return True
|
||||
|
||||
def bAliceSetUp(self):
|
||||
def bAliceNeedAddBob (self):
|
||||
if hasattr(self, 'abid') and self.abid >= 0 and \
|
||||
self.abid in self.alice.self_get_friend_list():
|
||||
LOG.warn(f"setUp BOB IS ALREADY IN ALICES FRIEND LIST")
|
||||
|
|
@ -338,18 +352,22 @@ class ToxSuite(unittest.TestCase):
|
|||
return True
|
||||
|
||||
def setUp(self):
|
||||
self.bBobSetUp()
|
||||
self.bAliceSetUp()
|
||||
cls = self
|
||||
if not hasattr(cls, 'alice') and not hasattr(cls, 'bob'):
|
||||
l = prepare(cls)
|
||||
assert l
|
||||
cls.bob, cls.alice = l
|
||||
if not hasattr(cls.bob, '_main_loop'):
|
||||
#? cls.bob._main_loop = ToxIterateThread(cls.bob)
|
||||
#? cls.bob._main_loop.start()
|
||||
LOG.debug(f"cls.bob._main_loop: ") # {threading.enumerate()}
|
||||
if not hasattr(cls.alice, '_main_loop'):
|
||||
#? cls.alice._main_loop = ToxIterateThread(cls.alice)
|
||||
#? cls.alice._main_loop.start()
|
||||
LOG.debug(f"cls.alice._main_loop: ") # {threading.enumerate()}
|
||||
|
||||
def tearDown(self):
|
||||
"""
|
||||
"""
|
||||
if self.bob.self_get_friend_list_size() >= 1:
|
||||
LOG.warn(f"tearDown BOBS STILL HAS A FRIEND LIST {self.bob.self_get_friend_list()}")
|
||||
for elt in self.bob.self_get_friend_list(): self.bob.friend_delete(elt)
|
||||
if self.bob.self_get_friend_list_size() >= 1:
|
||||
LOG.warn(f"tearDown ALICE STILL HAS A FRIEND LIST {self.alice.self_get_friend_list()}")
|
||||
for elt in self.alice.self_get_friend_list(): self.alice.friend_delete(elt)
|
||||
self.bBobNeedAlice()
|
||||
self.bAliceNeedAddBob()
|
||||
|
||||
def run(self, result=None):
|
||||
""" Stop after first error """
|
||||
|
|
@ -412,7 +430,7 @@ class ToxSuite(unittest.TestCase):
|
|||
bRet = None
|
||||
while i <= THRESHOLD :
|
||||
iRet = self.bob.group_is_connected(group_number)
|
||||
if iRet == 0:
|
||||
if iRet == True or iRet == 0:
|
||||
bRet = True
|
||||
break
|
||||
if i % 5 == 0:
|
||||
|
|
@ -568,7 +586,7 @@ class ToxSuite(unittest.TestCase):
|
|||
return oRet
|
||||
|
||||
def bob_add_alice_as_friend_norequest(self):
|
||||
if not self.bBobSetUp(): return True
|
||||
if not self.bBobNeedAlice(): return True
|
||||
|
||||
MSG = 'Hi, this is Bob.'
|
||||
iRet = self.bob.friend_add_norequest(self.alice._address)
|
||||
|
|
@ -583,7 +601,7 @@ class ToxSuite(unittest.TestCase):
|
|||
return True
|
||||
|
||||
def alice_add_bob_as_friend_norequest(self):
|
||||
if not self.bAliceSetUp(): return True
|
||||
if not self.bAliceNeedAddBob(): return True
|
||||
|
||||
iRet = self.alice.friend_add_norequest(self.bob._address)
|
||||
if iRet < 0:
|
||||
|
|
@ -596,10 +614,23 @@ class ToxSuite(unittest.TestCase):
|
|||
assert self.alice.self_get_friend_list_size() >= 1
|
||||
return True
|
||||
|
||||
def both_add_as_friend_norequest(self):
|
||||
if self.bBobSetUp():
|
||||
def both_add_as_friend(self):
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
assert self.alice_add_bob_as_friend_norequest()
|
||||
else:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
if self.bAliceSetUp():
|
||||
assert self.alice_add_bob_as_friend_norequest()
|
||||
if not hasattr(self, 'baid') or self.baid < 0:
|
||||
LOG.warn("both_add_as_friend no bob, baid")
|
||||
if not hasattr(self, 'abid') or self.abid < 0:
|
||||
LOG.warn("both_add_as_friend no alice, abid")
|
||||
return True
|
||||
|
||||
def both_add_as_friend_norequest(self):
|
||||
if self.bBobNeedAlice():
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
if self.bAliceNeedAddBob():
|
||||
assert self.alice_add_bob_as_friend_norequest()
|
||||
if not hasattr(self, 'baid') or self.baid < 0:
|
||||
LOG.warn("both_add_as_friend_norequest no bob, baid")
|
||||
|
|
@ -619,7 +650,7 @@ class ToxSuite(unittest.TestCase):
|
|||
"""
|
||||
MSG = 'Alice, this is Bob.'
|
||||
sSlot = 'friend_request'
|
||||
if not self.bBobSetUp(): return True
|
||||
if not self.bBobNeedAlice(): return True
|
||||
|
||||
def alices_on_friend_request(iTox,
|
||||
public_key,
|
||||
|
|
@ -666,7 +697,7 @@ class ToxSuite(unittest.TestCase):
|
|||
"""
|
||||
MSG = 'Bob, this is Alice.'
|
||||
sSlot = 'friend_request'
|
||||
if not self.bAliceSetUp(): return True
|
||||
if not self.bAliceNeedAddBob(): return True
|
||||
|
||||
def bobs_on_friend_request(iTox,
|
||||
public_key,
|
||||
|
|
@ -704,11 +735,6 @@ class ToxSuite(unittest.TestCase):
|
|||
self.bob.callback_friend_message(None)
|
||||
return True
|
||||
|
||||
def both_add_as_friend(self):
|
||||
assert self.bob_add_alice_as_friend()
|
||||
assert self.alice_add_bob_as_friend_norequest()
|
||||
return True
|
||||
|
||||
def bob_add_alice_as_friend_and_status(self):
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
|
|
@ -801,7 +827,9 @@ class ToxSuite(unittest.TestCase):
|
|||
assert otox.group_get_topic(iGrp) == topic
|
||||
assert otox.group_get_topic_size(iGrp) == len(topic)
|
||||
|
||||
assert otox.group_get_name(iGrp) == group_name
|
||||
name = otox.group_get_name(iGrp)
|
||||
if type(name) == bytes: name = str(name, 'utf-8')
|
||||
assert name == group_name, name
|
||||
assert otox.group_get_name_size(iGrp) == len(group_name)
|
||||
|
||||
sPk = otox.group_self_get_public_key(iGrp)
|
||||
|
|
@ -833,16 +861,16 @@ class ToxSuite(unittest.TestCase):
|
|||
raise
|
||||
|
||||
try:
|
||||
iRet = group_is_connected(group_number)
|
||||
bRet = otox.group_is_connected(group_number)
|
||||
except Exception as e:
|
||||
LOG.error(f"group_is_connected EXCEPTION {e}")
|
||||
return -1
|
||||
LOG.debug(f"group_is_connected group_number={group_number} iRet={iRet}")
|
||||
LOG.debug(f"group_is_connected group_number={group_number} bRet={bRet}")
|
||||
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
|
||||
if iRet != 0:
|
||||
LOG.warn(f"group_is_connected WARN iRet={iRet} group_number={group_number} ")
|
||||
if bRet:
|
||||
LOG.warn(f"group_is_connected WARN group_number={group_number} ")
|
||||
else:
|
||||
LOG.info(f"group_is_connected SUCCESS iRet={iRet} group_number={group_number} ")
|
||||
LOG.info(f"group_is_connected SUCCESS group_number={group_number} ")
|
||||
|
||||
return group_number
|
||||
|
||||
|
|
@ -875,23 +903,18 @@ class ToxSuite(unittest.TestCase):
|
|||
#?
|
||||
group_number = iGrp
|
||||
try:
|
||||
iRet = otox.group_is_connected(group_number)
|
||||
bRet = otox.group_is_connected(group_number)
|
||||
except Exception as e:
|
||||
LOG.error(f"group_is_connected ERROR {e}")
|
||||
iRet = -1
|
||||
else:
|
||||
if iRet != enums.TOX_ERR_GROUP_STATE_QUERIES['TOX_ERR_GROUP_STATE_QUERIES_OK']:
|
||||
LOG.warn(f"group_is_connected WARN iRet={iRet}")
|
||||
# The group number passed did not designate a valid group.
|
||||
# TOX_ERR_GROUP_STATE_QUERIES['TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND']
|
||||
if iRet < 0:
|
||||
return iGrp
|
||||
return -1
|
||||
|
||||
message = bytes('hello', 'utf-8')
|
||||
try:
|
||||
bRet = otox.group_send_message(group_number, TOX_MESSAGE_TYPE['NORMAL'], 'hello')
|
||||
if not bRet:
|
||||
LOG.warn(f"group_send_message {bRet}")
|
||||
else:
|
||||
LOG.debug(f"group_send_message {bRet}")
|
||||
except Exception as e:
|
||||
LOG.error(f"group_send_message ERROR {e}")
|
||||
|
||||
|
|
@ -909,7 +932,7 @@ class ToxSuite(unittest.TestCase):
|
|||
while i < n:
|
||||
iRet = otox.friend_get_connection_status(fid)
|
||||
if iRet == TOX_CONNECTION['NONE']:
|
||||
LOG.warning(f"wait_friend_get_connection_status NOT CONNECTED i={i} {iRet}")
|
||||
# LOG.debug(f"wait_friend_get_connection_status NOT CONNECTED i={i} {iRet}")
|
||||
self.loop_until_connected()
|
||||
else:
|
||||
LOG.info("wait_friend_get_connection_status {iRet}")
|
||||
|
|
@ -998,7 +1021,6 @@ class ToxSuite(unittest.TestCase):
|
|||
else:
|
||||
LOG.warning(f"bootstrap_local_netstat NOT {port} iStatus={iStatus}")
|
||||
|
||||
#?? @unittest.skipIf(not bIS_LOCAL, "local test")
|
||||
def test_bootstrap_local(self): # works
|
||||
"""
|
||||
t:call_bootstrap
|
||||
|
|
@ -1269,7 +1291,10 @@ class ToxSuite(unittest.TestCase):
|
|||
|
||||
def test_bob_add_alice_as_friend(self): # works?
|
||||
try:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
else:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
#: Test last online
|
||||
assert self.bob.friend_get_last_online(self.baid) is not None
|
||||
except AssertionError as e:
|
||||
|
|
@ -1286,7 +1311,10 @@ class ToxSuite(unittest.TestCase):
|
|||
|
||||
def test_alice_add_bob_as_friend(self): # works!
|
||||
try:
|
||||
assert self.alice_add_bob_as_friend()
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.alice_add_bob_as_friend_norequest()
|
||||
else:
|
||||
assert self.alice_add_bob_as_friend()
|
||||
#: Test last online
|
||||
assert self.alice.friend_get_last_online(self.abid) is not None
|
||||
except AssertionError as e:
|
||||
|
|
@ -1309,7 +1337,10 @@ class ToxSuite(unittest.TestCase):
|
|||
|
||||
def test_both_add_as_friend(self): # works
|
||||
try:
|
||||
assert self.both_add_as_friend()
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.both_add_as_friend_norequest()
|
||||
else:
|
||||
assert self.both_add_as_friend()
|
||||
except AssertionError as e:
|
||||
LOG.warn(f"Failed test {e}")
|
||||
raise
|
||||
|
|
@ -1380,6 +1411,8 @@ class ToxSuite(unittest.TestCase):
|
|||
LOG.error(f"bob.group_leave EXCEPTION {e}")
|
||||
raise
|
||||
|
||||
@unittest.skip("double free or corruption (fasttop)")
|
||||
# @expectedFail('fails') # assertion fails on == MSG
|
||||
def test_on_friend_status_message(self): # fails
|
||||
"""
|
||||
t:self_set_status_message
|
||||
|
|
@ -1435,10 +1468,6 @@ class ToxSuite(unittest.TestCase):
|
|||
if hasattr(self, 'abid') and self.abid >= 0:
|
||||
self.alice.friend_delete(self.abid)
|
||||
|
||||
#? @unittest.skip('malloc(): unaligned tcache chunk detected')
|
||||
#? @unittest.skip('double free or corruption (fasttop)')
|
||||
#?segv after TestS DEBUG wait_otox_attrs alice for ['friend_request'] 0 last=1701822930
|
||||
#?? @unittest.skip('segv')
|
||||
def test_friend(self): # works! sometimes
|
||||
"""
|
||||
t:friend_get_name
|
||||
|
|
@ -1477,8 +1506,7 @@ class ToxSuite(unittest.TestCase):
|
|||
if hasattr(self, 'abid') and self.abid >= 0:
|
||||
self.alice.friend_delete(self.abid)
|
||||
|
||||
#! @expectedFail('fails') # assert self.bob.friend_get_status(self.baid) == TOX_USER_STATUS['BUSY']
|
||||
@unittest.skip('malloc(): unaligned tcache chunk detected')
|
||||
@expectedFail('fails') # assert self.bob.friend_get_status(self.baid) == TOX_USER_STATUS['BUSY']
|
||||
def test_user_status(self): # fails
|
||||
"""
|
||||
t:self_get_status
|
||||
|
|
@ -1488,10 +1516,6 @@ class ToxSuite(unittest.TestCase):
|
|||
t:on_friend_status
|
||||
"""
|
||||
sSlot = 'friend_status'
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
else:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
|
||||
setattr(self.bob, sSlot, None)
|
||||
def bobs_on_friend_set_status(iTox, friend_id, new_status, *largs):
|
||||
|
|
@ -1504,6 +1528,10 @@ class ToxSuite(unittest.TestCase):
|
|||
setattr(self.bob, sSlot, True)
|
||||
|
||||
try:
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
else:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
if not self.get_connection_status():
|
||||
LOG.warning(f"test_user_status NOT CONNECTED self.get_connection_status")
|
||||
self.loop_until_connected()
|
||||
|
|
@ -1512,15 +1540,16 @@ class ToxSuite(unittest.TestCase):
|
|||
self.warn_if_no_cb(self.bob, sSlot)
|
||||
sSTATUS = TOX_USER_STATUS['BUSY']
|
||||
self.alice.self_set_status(sSTATUS)
|
||||
sSlot = 'friend_status'
|
||||
if not self.wait_otox_attrs(self.bob, [sSlot]):
|
||||
# malloc(): unaligned tcache chunk detected
|
||||
LOG_WARN(f' NO {sSlot}')
|
||||
LOG_WARN(f'test_user_status NO {sSlot}')
|
||||
|
||||
assert self.bob.friend_get_status(self.baid) == TOX_USER_STATUS['BUSY'], \
|
||||
f"{self.bob.friend_get_status(self.baid)} != {TOX_USER_STATUS['BUSY']}"
|
||||
f"friend_get_status {self.bob.friend_get_status(self.baid)} != {TOX_USER_STATUS['BUSY']}"
|
||||
|
||||
except AssertionError as e:
|
||||
LOG.error(f"Failed test_user_status {e}")
|
||||
LOG.error(f"test_user_status FAILED {e}")
|
||||
raise
|
||||
except Exception as e:
|
||||
LOG.error(f"test_user_status EXCEPTION {e}")
|
||||
|
|
@ -1548,13 +1577,13 @@ class ToxSuite(unittest.TestCase):
|
|||
setattr(self.bob, sSlot, True)
|
||||
|
||||
opts = oToxygenToxOptions(oTOX_OARGS)
|
||||
setattr(self.bob, sSlot, True)
|
||||
try:
|
||||
if bUSE_NOREQUEST:
|
||||
assert self.bob_add_alice_as_friend_norequest()
|
||||
else:
|
||||
assert self.bob_add_alice_as_friend()
|
||||
|
||||
setattr(self.bob, sSlot, True)
|
||||
self.bob.callback_friend_connection_status(bobs_on_friend_connection_status)
|
||||
|
||||
LOG.info("test_connection_status killing alice")
|
||||
|
|
@ -1576,10 +1605,8 @@ class ToxSuite(unittest.TestCase):
|
|||
if hasattr(self, 'baid') and self.baid >= 0:
|
||||
self.bob.friend_delete(self.baid)
|
||||
|
||||
# TestS DEBUG wait_otox_attrs bob for ['friend_name'] 5 last=1701826540
|
||||
# @unittest.skip('crashes')
|
||||
@expectedFail('fails') # new name if empty
|
||||
def test_friend_name(self): # works! or crashes!
|
||||
@expectedFail('fails') # new name is empty
|
||||
def test_friend_name(self): # works!
|
||||
"""
|
||||
t:self_set_name
|
||||
t:friend_get_name
|
||||
|
|
@ -1635,9 +1662,7 @@ class ToxSuite(unittest.TestCase):
|
|||
self.warn_if_cb(self.bob, sSlot)
|
||||
|
||||
|
||||
# wait_ensure_exec ArgumentError This client is currently not connected to the friend.
|
||||
@expectedFail('fails')
|
||||
# This client is currently not connected to the friend.
|
||||
@expectedFail('fails') # This client is currently not connected to the friend.
|
||||
def test_friend_message(self): # fails
|
||||
"""
|
||||
t:on_friend_action
|
||||
|
|
@ -1668,35 +1693,34 @@ class ToxSuite(unittest.TestCase):
|
|||
assert self.both_add_as_friend_norequest()
|
||||
else:
|
||||
assert self.both_add_as_friend()
|
||||
if not self.wait_friend_get_connection_status(self.alice, self.abid, n=iN):
|
||||
assert hasattr(self, 'baid'), \
|
||||
"both_add_as_friend_norequest no bob, baid"
|
||||
assert hasattr(self, 'abid'), \
|
||||
"both_add_as_friend_norequest no alice, abid"
|
||||
if not self.wait_friend_get_connection_status(self.bob, self.baid, n=2*iN):
|
||||
LOG.warn('baid not connected')
|
||||
if not self.wait_friend_get_connection_status(self.alice, self.abid, n=2*iN):
|
||||
LOG.warn('abid not connected')
|
||||
self.alice.callback_friend_message(alices_on_friend_message)
|
||||
self.warn_if_no_cb(self.alice, sSlot)
|
||||
|
||||
# dunno - both This client is currently NOT CONNECTED to the friend.
|
||||
if True:
|
||||
iMesId = self.bob.friend_send_message(self.baid,
|
||||
TOX_MESSAGE_TYPE['NORMAL'],
|
||||
bytes(MSG, 'UTF-8'))
|
||||
# ArgumentError('This client is currently NOT CONNECTED to the friend.')
|
||||
else:
|
||||
iMesId = self.wait_ensure_exec(self.bob.friend_send_message,
|
||||
[self.baid,
|
||||
TOX_MESSAGE_TYPE['NORMAL'],
|
||||
bytes(MSG, 'UTF-8')])
|
||||
assert iMesId >= 0
|
||||
iMesId = self.bob.friend_send_message(self.baid,
|
||||
TOX_MESSAGE_TYPE['NORMAL'],
|
||||
bytes(MSG, 'UTF-8'))
|
||||
assert iMesId >= 0, "iMesId >= 0"
|
||||
if not self.wait_otox_attrs(self.alice, [sSlot]):
|
||||
LOG_WARN(f"alices_on_friend_message NO {sSlot}")
|
||||
except ArgumentError as e:
|
||||
# ArgumentError('This client is currently NOT CONNECTED to the friend.')
|
||||
# dunno
|
||||
LOG.error(f"test_friend_message {e}")
|
||||
LOG.error(f"test_friend_message ArgumentError {e}")
|
||||
raise
|
||||
except AssertionError as e:
|
||||
LOG.error(f"test_friend_message {e}")
|
||||
LOG.error(f"test_friend_message AssertionError {e}")
|
||||
raise
|
||||
except Exception as e:
|
||||
LOG.error(f"test_friend_message {e}")
|
||||
LOG.error(f"test_friend_message EXCEPTION {e}")
|
||||
raise
|
||||
finally:
|
||||
self.alice.callback_friend_message(None)
|
||||
|
|
@ -2028,7 +2052,6 @@ class ToxSuite(unittest.TestCase):
|
|||
|
||||
@unittest.skip('crashes')
|
||||
def test_tox_savedata(self): # works sorta
|
||||
# but "{addr} != {self.alice.self_get_address()}"
|
||||
"""
|
||||
t:get_savedata_size
|
||||
t:get_savedata
|
||||
|
|
@ -2062,6 +2085,13 @@ class ToxSuite(unittest.TestCase):
|
|||
else:
|
||||
LOG.info("passed test_tox_savedata")
|
||||
|
||||
def test_kill(self): #
|
||||
import threading
|
||||
LOG.info(f"THE END {threading.active_count()}")
|
||||
self.tearDown()
|
||||
LOG.info(f"THE END {threading.enumerate()}")
|
||||
|
||||
|
||||
def vOargsToxPreamble(oArgs, Tox, ToxTest):
|
||||
|
||||
ts.vSetupLogging(oArgs)
|
||||
|
|
@ -2078,6 +2108,7 @@ def vOargsToxPreamble(oArgs, Tox, ToxTest):
|
|||
if len(not_tested):
|
||||
logging.info('Not tested:\n %s' % "\n ".join(sorted(list(not_tested))))
|
||||
|
||||
|
||||
###
|
||||
|
||||
def iMain(oArgs):
|
||||
|
|
@ -2190,6 +2221,3 @@ def main(lArgs=None):
|
|||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
|
||||
#Ran 38 tests in 194.492s
|
||||
#OK (skipped=10, expected failures=4)
|
||||
|
|
|
|||
Loading…
Reference in New Issue