def test_add_element(self):
n, A0, S = setup()
x0 = secrets.randbelow(pow(2, 256))
x1 = secrets.randbelow(pow(2, 256))
# first addition
A1 = add(A0, S, x0, n)
nonce = S[x0]
proof = prove_membership(A0, S, x0, n)
self.assertEqual(len(S), 1)
self.assertEqual(A0, proof)
self.assertTrue(verify_membership(A1, x0, nonce, proof, n))
# second addition
A2 = add(A1, S, x1, n)
nonce = S[x1]
proof = prove_membership(A0, S, x1, n)
self.assertEqual(len(S), 2)
self.assertEqual(A1, proof)
self.assertTrue(verify_membership(A2, x1, nonce, proof, n))
# delete
A1_new = delete(A0, A2, S, x0, n)
proof = prove_membership(A0, S, x1, n)
proof_none = prove_membership(A0, S, x0, n)
self.assertEqual(len(S), 1)
self.assertEqual(proof_none, None)
self.assertTrue(verify_membership(A1_new, x1, nonce, proof, n))
def test_MultiGraph(self):
''' Doubled edges should only remove one edge. '''
mg = nx.MultiGraph()
mg.add_edge(1, 2)
mg.add_edge(1, 2)
mg.add_edge(2, 3)
mg.add_edge(1, 3)
newG = delete(mg, (1, 2))
self.assertEqual(newG.edges(), [(1, 2), (1, 3), (2, 3)])
def test_mem_witness_up_on_delete(total_utxo_set_size_for_accumulator,
delete_element_index):
if delete_element_index >= total_utxo_set_size_for_accumulator:
print("delete element index should smaller than total_utxo_set_size")
print("total_utxo_set_size_for_accumulator =",
total_utxo_set_size_for_accumulator)
print("--> initialize and fill up accumulator state")
n, A0, S, order = setup()
elements_for_accumulator = create_random_list(
total_utxo_set_size_for_accumulator)
tik = time.time()
A_post, _ = batch_add(A0, S, elements_for_accumulator, n)
tok = time.time()
print("<-- Done.", tok - tik)
print("--> generate other element proof")
tik = time.time()
other_element_proofs = {}
for i in range(len(elements_for_accumulator)):
if i != delete_element_index:
other_element_proofs[
elements_for_accumulator[i]] = prove_membership(
A0, S, elements_for_accumulator[i], n)
tok = time.time()
print("<-- Done.", tok - tik)
print("--> delete element and generate A_del accumulator value.")
tik = time.time()
delete_element = elements_for_accumulator[delete_element_index]
A_del = delete(A0, A_post, S, delete_element, n)
tok = time.time()
print("<-- Done.", tok - tik)
print("--> update proof on delete element")
update_proofs = {}
tik = time.time()
for x, proof in other_element_proofs.items():
update_proofs[x] = acc_del_mem_witness_update(x, proof, delete_element,
A_del, n)
tok = time.time()
print("<-- Done.", tok - tik)
print("--> verify updated proof on delete element")
tik = time.time()
result = []
for x, proof in update_proofs.items():
result.append(verify_membership(A_del, x, S[x], proof, n))
tok = time.time()
print("<-- Done.", tok - tik)
print("verify results:")
print(result)
def test_delete_not_existing(get_database_client, app):
mock_db = MockFirestore()
get_database_client.return_value = mock_db
with app.test_request_context(
json={"item": "item1"},
content_type="application/json",
method='DELETE',
headers={'Origin': 'https://inventoryapp-276220.web.app'}):
res = main.delete(flask.request)
print("%s" % str(res))
assert res.status_code == 200
assert 'https://inventoryapp-276220.web.app' == res.headers[
'Access-Control-Allow-Origin']
assert 'true' == res.headers['Access-Control-Allow-Credentials']
def test_delete_existing(get_database_client, app):
mock_db = MockFirestore()
get_database_client.return_value = mock_db
mock_db.collection('items').document('item1').set({'quantity': 1})
with app.test_request_context(
json={"item": "item1"},
content_type="application/json",
method='DELETE',
headers={'Origin': 'https://inventoryapp-276220.web.app'}):
res = main.delete(flask.request)
assert res.status_code == 200
doc = mock_db.collection('items').document('item1').get()
assert doc.to_dict() == {}
assert 'https://inventoryapp-276220.web.app' == res.headers[
'Access-Control-Allow-Origin']
assert 'true' == res.headers['Access-Control-Allow-Credentials']
async def start(ws):
"""Lance le bot sur l'adresse Web Socket donnée."""
global last_sequence # global est nécessaire pour modifier la variable
with aiohttp.ClientSession() as session:
async with session.ws_connect(f"{ws}?v=5&encoding=json") as ws:
async for msg in ws:
if msg.tp == aiohttp.WSMsgType.TEXT:
data = json.loads(msg.data)
elif msg.tp == aiohttp.WSMsgType.BINARY:
data = json.loads(zlib.decompress(msg.data))
else:
print("?", msg.tp)
# https://discordapp.com/developers/docs/topics/gateway#gateway-op-codes
if data['op'] == 10: # Hello
asyncio.ensure_future(heartbeat(ws, data['d']['heartbeat_interval']))
await identify(ws)
elif data['op'] == 11: # Heartbeat ACK
print("< Heartbeat ACK")
elif data['op'] == 0: # Dispatch
last_sequence = data['s']
if data['t'] == "MESSAGE_CREATE":
print(data['d'])
if data['d']['content'] == '?help':
helpMsg = helpTask()
await send_message(data['d']['author']['id'],helpMsg)
if '?new' in data['d']['content']:
arguments = shlex.split(data['d']['content'])
if len(arguments) != 4:
await send_message(data['d']['author']['id'],'Veuillez entrez un titre, une description et une date')
else:
newMsg = new(data['d']['author']['id'], arguments[1], arguments[2], arguments[3])
await send_message(data['d']['author']['id'],newMsg)
task = rappel(data['d']['author']['id'], arguments[1],arguments[3])
await task
listeRappel.append(task)
if '?update' in data['d']['content']:
arguments = shlex.split(data['d']['content'])
if len(arguments) != 4:
await send_message(data['d']['author']['id'],f"Veuillez entrez l'id de votre tâche, le champ que vous souhaitez changer et la nouvelle valeur.")
await send_message(data['d']['author']['id'],f"Exemple : update 0 name NewName")
else:
updateMsg = update(data['d']['author']['id'], arguments[1], arguments[2], arguments[3])
await send_message(data['d']['author']['id'],updateMsg)
if '?delete' in data['d']['content']:
arguments = shlex.split(data['d']['content'])
deleteMsg = delete(data['d']['author']['id'], arguments[1])
await send_message(data['d']['author']['id'],deleteMsg)
#listeRappel[int(arguments[1])].cancel()
if '?list' in data['d']['content']:
tacheList=listTask(data['d']['author']['id'])
await send_message(data['d']['author']['id'],tacheList)
if '?detail' in data['d']['content']:
arguments = shlex.split(data['d']['content'])
details = detail(data['d']['author']['id'], arguments[1])
await send_message(data['d']['author']['id'],details)
if data['d']['content'] == '?quit':
store()
await send_message(data['d']['author']['id'],'Bye Bye !')
break
else:
print('Todo?', data['t'])
else:
print("Unknown?", data)
def delete_payment(key_value):
delete("pagamentos", "id", key_value)
def delete_2(crd):
print(main.create("sherlock", crd.key, crd.value_dict)+"\n\n")
print(main.delete("sherlock", crd.key)+"\n\n")
def test_inputUnmodified(self):
# Input graph should not be changed.
_ = delete(self.g, (1,2))
self.assertEqual(self.g.edges(), [(1, 2), (1,3), (2, 3)])
def delete_filme(id_filme):
delete("filmes", "id", id_filme)
def delete_genero(id_genero):
delete("generos", "id", id_genero)
def delete_usuario(id, nome_completo, cpf):
delete("usuario"["nome_completo", "cpf"], [nome_completo, cpf])
def test_delete():
delete(directories, documents, '11-2')
assert '11-2' not in directories['1'], documents[1]
import main as main_file
main_file.create("Avinash", 25)
main_file.create("src", 70, 3600)
main_file.read("Avinash")
main_file.read("src")
main_file.create("Avinash", 50)
main_file.modify("Avinash", 55)
main_file.delete("Avinash")
th1 = Thread(target=(create or read or delete),
args=(key_name, value, timeout))
th1.start()
th1.sleep()
th2 = Thread(target=(create or read or delete),
args=(key_name, value, timeout))
th2.start()
th2.sleep()
from main import insert, select, update, delete, select_bancoDeDados
def insert_diretores(diretores, id, nome_completo):
return insert("diretores", ["id", "nome_completo"])
def update_diretores(diretores, id, nome_completo)
return updade("diretores", "id", id["nome_completo"], [nome_completo])
def delete_diretores(nome_completo)]
delete("diretores", "id", nome_completo)
def select_diretores(nome_completo):
return select_like("diretores", "nome_completo", nome_completo)
def get_diretores(nome_completo)
return select(nome_completo)[0]
# Tabela Filmes
def insert_filmes(filmes [titulo, ano, classificaçao, preco, diretores]
):
import main as data
data.create("chetan",30
data.create("shivam",75,3610)
data.read("chetan")
data.read("shivam")
data.create("chetan",55)
data.modify("chetan",50)
data.delete("chetan")
thread1=Thread(target=(create or read or delete),args=(key_name,value,timeout))
thread1.start()
thread1.sleep()
thread2=Thread(target=(create or read or delete),args=(key_name,value,timeout))
thread2.start()
thread2.sleep()
res = app.create(key,value)
if(res):
print("Key Value pair has been added successfully")
elif(option == 2):
print("Enter the key:")
key = input()
print("Enter its value:")
value = input()
print("Enter the time-to-live")
ttl = int(input())
res = app.create(key,value,ttl)
if(res):
print("Key Value pair has been added successfully")
elif(option == 3):
print("Enter the key:")
key = input()
app.read(key)
elif(option == 4):
print("Enter the key:")
key = input()
app.delete(key)
print("Enter your option")
option = int(input())
if(option == 5):
datastore = app.save()
with open("library.json",'w') as file:
datastore = json.dumps(datastore)
file.write(datastore)
import main as crd
crd.create("pawan", 28)
crd.create("pp", 70, 3600)
crd.read("pawan")
crd.read("pp")
crd.create("pawan",
50) #it throws an ERROR since the key already exists in the db
crd.modify("pawan", 55)
crd.delete("pawan")
# it can be access through thread
thrd1 = Thread(target=(create or read or delete), args=(key, value, t_out))
thrd1.start()
thrd1.sleep()
thrd2 = Thread(target=(create or read or delete), args=(key, value, t_out))
thrd2.start()
thrd2.sleep()
thrd3 = Thread(target=(create or read or delete), args=(key, value, t_out))
thrd3.start()
thrd3.sleep()
def delete_pagamento(locacoes_id):
delete("pagamento", "locacoes_id", locacoes_id)
def delete(self):
return main.delete(self.client, self.key, filepath=self.filepath)
def delete_pagamento(id, status, cod_pagamento, valor, data, locação_id):
delete("pagamento", [id, " status", "locação_id", "cod_pagamento", "valor", " data", "locação_id"], id, status,
locação_id, cod_pagamento, valor, data, locação_id)
import main as x
x.create("amrita", 25)
x.create("school", 70, 3600)
x.read("amrita")
x.read("src")
x.create("amrita", 50)
x.modify("amrita", 55)
x.delete("amrita")
t1 = Thread(target=(create or read or delete), args=(key_name, value, timeout))
t1.start()
t1.sleep()
t2 = Thread(target=(create or read or delete), args=(key_name, value, timeout))
t2.start()
t2.sleep()
def test_delete(self):
self.assertEqual(main.delete("Chennai"),"error: given key does not exist in database. Please enter a valid key")
def delete_locacao(id):
delete("locacoes", "id", id)
def delete_director(key_value): #rodando
delete("diretores", "id", key_value)
def delete_usuario(id_usuario):
delete("usuarios", "id", id_usuario)
def delete_genre(key_value):
delete("generos", "id", key_value)
def delete_diretor(id_diretor):
delete("diretores", "id", id_diretor)
def delete_movie(key_value):
delete("filmes", "id", key_value)
def test_simple(self):
newG = delete(self.g, (1,2))
self.assertEqual(newG.edges(), [(1,3), (2, 3)])
def delete_user(key_value):
delete("usuarios", "id", key_value)
def delete_rent(key_value):
delete("locacoes", "id", key_value)
def delete(crd):
print(main.delete(crd.client, crd.key)+"\n\n")
print(main.delete(crd.client, crd.key_more_than_32)+"\n\n")
print(main.delete("Special24", crd.key)+"\n\n")
print(main.delete(crd.client, crd.key)+"\n\n")
