def start(self):
self._sender = self._socket.peerAddress()
stream = QDataStream(self._socket)
if (self._file_size == 0):
if (self._socket.bytesAvailable() < getsizeof(int)):
return
self._file_size = stream.readUInt32()
if (self._socket.bytesAvailable() < self._file_size):
return
self._file_name = stream.readString()
line = QByteArray()
line = self._socket.readAll()
directory = Path(Setup().get_download_dir())
if not (directory.exists() and directory.is_dir()):
directory.mkdir()
self._receiving_file = QFile(Setup().get_download_dir() +
str(self._file_name))
print(Setup().get_download_dir() + str(self._file_name))
if not (self._receiving_file.open(QIODevice.WriteOnly)):
print("can't open file")
return
self._receiving_file.write(line)
self._receiving_file.close()
self._socket.disconnectFromHost()
print("finished")
return self._receiving_file
def send_file(self):
self._transaction.set_status(TransactionStatus.SENDING)
file_to_byte_array = QByteArray()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
QFile.open(self._file, QIODevice.ReadOnly)
stream.writeUInt32(0)
stream.writeString(self._file_name)
print("size of name ", getsizeof(self._file_name))
file_to_byte_array = self._file.readAll()
data.append(file_to_byte_array)
self._file.close()
stream.device().seek(0)
stream.writeUInt32(data.size() - getsizeof(self._file_name))
print("total ", data.size() - getsizeof(self._file_name))
x = 0
while (x < data.size()):
y = self._socket.write(data)
print("poslato ", y)
x += y
print("x ", x)
self._transaction.set_status(TransactionStatus.FINISHED)
def run(self):
# Try to connect to an incoming tcp socket using its socket descriptor
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
FreeCAD.Console.PrintError("Socket not accepted.\n")
return
FreeCAD.Console.PrintLog("Socket accepted.\n")
# Wait for an incoming message
if not tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
FreeCAD.Console.PrintError("No request send.\n")
return
# Make an input data stream
instr = QDataStream(tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
# Try to read the message size
if self.blockSize == 0:
if tcpSocket.bytesAvailable() < 2:
FreeCAD.Console.PrintError("Received message "
+ "has too few bytes.\n")
return
self.blockSize = instr.readUInt16()
# Check message is sent complete
if tcpSocket.bytesAvailable() < self.blockSize:
FreeCAD.Console.PrintError("Received message has less bytes "
+ "then it's supposed to.\n")
return
# Read message and inform about it
cmd = instr.readRawData(self.blockSize).decode("UTF-8")
FreeCAD.Console.PrintLog("CommandServer received> "
+ cmd + "\n")
# Try to execute the message string and prepare a response
try:
exec(cmd)
except Exception as e:
FreeCAD.Console.PrintError("Executing external command failed:"
+ str(e) + "\n")
message = "Command failed - " + str(e)
else:
FreeCAD.Console.PrintLog("Executing external command succeeded!\n")
message = COMMAND_EXECUTED_CONFIRMATION_MESSAGE
# Prepare the data block to send back and inform about it
FreeCAD.Console.PrintLog("CommandServer sending> " + message + " \n")
block = QByteArray(
len(message.encode("UTF-8")).to_bytes(2, byteorder='big')
+ message.encode("UTF-8"))
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
# Send the block, disconnect from the socket and terminate the QThread
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def setUp(self):
super(QPixmapQDatastream, self).setUp()
self.source_pixmap = QPixmap(100, 100)
self.source_pixmap.fill(Qt.red)
self.output_pixmap = QPixmap()
self.buffer = QByteArray()
self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)
def __lshift__(self, Sender: QDataStream):
self.AngleMotor1 = Sender.readInt16()
self.AngleMotor2 = Sender.readInt16()
self.AngleMotor3 = Sender.readInt16()
self.SpeedMotor1 = Sender.readInt16()
self.SpeedMotor2 = Sender.readInt16()
self.SpeedMotor3 = Sender.readInt16()
def __lshift__(self, Sender: QDataStream):
self.AccelX = Sender.readUInt16()
self.AccelY = Sender.readUInt16()
self.AccelZ = Sender.readUInt16()
self.AngularSpeedX = Sender.readUInt16()
self.AngularSpeedY = Sender.readUInt16()
self.AngularSpeedZ = Sender.readUInt16()
self.MessageCount = Sender.readUInt16()
def _check_bitarray(self, data_set):
'''Check the >> operator for the given data set'''
for data, expectedStatus, expectedString in data_set:
stream = QDataStream(data, QIODevice.ReadOnly)
string = QBitArray()
stream >> string
self.assertEqual(stream.status(), expectedStatus)
self.assertEqual(string.size(), expectedString.size())
self.assertEqual(string, expectedString)
def testRawData(self):
data = QDataStream()
self.assertEqual(data.readRawData(4), None)
ba = QByteArray()
data = QDataStream(ba, QIODevice.WriteOnly)
data.writeRawData('AB\x00C')
self.assertEqual(ba.data(), py3k.b('AB\x00C'))
data = QDataStream(ba)
self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
def _check_bitarray(self, data_set):
'''Check the >> operator for the given data set'''
for data, expectedStatus, expectedString in data_set:
stream = QDataStream(data, QIODevice.ReadOnly)
string = QBitArray()
stream >> string
self.assertEqual(stream.status(), expectedStatus)
self.assertEqual(string.size(), expectedString.size())
self.assertEqual(string, expectedString)
def SendData(self):
Req = ConnectCheckRequest()
self.SendBuffer.clear()
self.SendBuffer.resize(Req.MESSAGE_SIZE)
WriteDataStream = QDataStream(self.SendBuffer, QIODevice.ReadWrite)
WriteDataStream.setByteOrder(QDataStream.LittleEndian)
Req >> WriteDataStream
self.CommandSocket.write(self.SendBuffer)
self.CommandSocket.waitForBytesWritten(20)
self.SignalDataRec.emit("CHECK CONNECT - " + str(Req.Connect), 1)
def MoveDCMotors(self, MotorsSpeed: DC_Motor_Control_Data):
self.STEP_MOTOR_COMMAND = QByteArray()
stream = QDataStream(self.STEP_MOTOR_COMMAND,
QtCore.QIODevice.ReadWrite)
stream.writeInt8(self.MotorsState.HEADER_B1)
stream.writeInt8(self.MotorsState.HEADER_B2)
stream.writeInt8(self.MotorsState.UNIT_SIZE)
stream.writeInt16(self.MotorsState.Speed1)
stream.writeInt16(self.MotorsState.Speed2)
stream.writeInt16(self.MotorsState.Speed3)
stream.writeInt16(self.MotorsState.Speed4)
def dropMimeData(
self,
mime_data: "QMimeData",
action: "Qt.DropAction",
row: int,
column: int,
parent: "QModelIndex",
):
"""
Decodes and inserts the MIME data (layers) from a drop operation onto the table.
"""
if action == Qt.IgnoreAction:
return True
if not mime_data.hasFormat(Dial.KerasLayerListMIME.value):
return False
# Get the row number where the layers will be inserted
if row != -1:
begin_row = row
else:
begin_row = self.rowCount()
LOGGER.debug("Drop action type: %s", action)
LOGGER.debug("Adding a new row at index %s...", begin_row)
# Get the serilalized data from the MIME data and prepare for decoding
encoded_data: QByteArray = mime_data.data(
Dial.KerasLayerListMIME.value)
stream = QDataStream(encoded_data, QIODevice.ReadOnly)
# Unserialize binary data
layers = []
while not stream.atEnd():
layer = stream.readQVariant()
layers.append(layer)
LOGGER.debug("Values to insert: %s", len(layers))
LOGGER.debug(layers)
# When adding new layers we must ensure that the names are all uniques
if action == Qt.CopyAction:
self.__set_unique_layer_names(layers)
# Insert the decoded layers on the model
self.insertRows(begin_row, len(layers),
self.createIndex(begin_row, 0, layers))
return True
def dropEvent(self, event):
if event.mimeData().hasFormat("application/x-lista-item"):
data = event.mimeData().data("application/x-lista-item")
stream = QDataStream(data, QIODevice.ReadOnly)
text = stream.readQString()
id = stream.readInt16()
# icon = QIcon()
# stream >> icon
item = QListWidgetItem(text, self)
item.setData(1, id)
# item.setIcon(icon)
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
def saveStackToFile(self, filename):
qf = QFile(filename)
if not qf.open(QIODevice.WriteOnly):
raise IOError('cannot open file %s' % filename)
dataStream = QDataStream(qf)
self.writeStackToStream(dataStream)
qf.close()
def startDrag(self, event):
item = self.itemAt(event.scenePos(), self.page_view_transform)
if item is None:
event.ignore()
return
self.item_being_dragged = item.parent
self.remove_component_controller(item.parent)
hotspot = event.scenePos() - item.scenePos()
hot_spot_point = hotspot.toPoint()
hot_spot_point = self.page_view_transform.map(hot_spot_point)
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
data_stream << hot_spot_point # pixmap << location
mime_data = QMimeData()
mime_data.setData(config_controller.component_mime, item_data)
drag = QDrag(self)
drag.setMimeData(mime_data)
horizontal_scaling = self.page_view_transform.m11()
logger.info(f"sceneBoundingRect {item.sceneBoundingRect().width()}")
logger.info(
f"sceneBoundingRect {item.sceneBoundingRect().width()*horizontal_scaling}"
)
drag.setPixmap(
item.parent.pixmap.scaledToWidth(item.sceneBoundingRect().width() *
horizontal_scaling))
drag.setHotSpot(hot_spot_point)
result = drag.start(QtCore.Qt.MoveAction)
if result: # == QtCore.Qt.MoveAction:
pass
def startDrag(self, event: QEvent) -> None:
item = self.currentItem()
if item is None:
event.ignore()
return
self.item_being_dragged = self.takeItem(self.row(item)).parent
hot_spot_point = event.pos()
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
data_stream << hot_spot_point # pixmap << location
mime_data = QMimeData()
mime_data.setData(config_controller.component_mime, item_data)
drag = QDrag(self)
pixmap = item.parent.pixmap.scaledToWidth(64)
drag.setHotSpot(QPoint(pixmap.width() / 2, pixmap.height() / 2))
drag.setPixmap(pixmap)
drag.setMimeData(mime_data)
result = drag.start(QtCore.Qt.MoveAction)
if result: # == QtCore.Qt.MoveAction:
pass
def loadStackFromFile(self, filename):
qf = QFile(filename)
if not qf.open(QIODevice.ReadOnly):
raise IOError('cannot open file %s' % filename)
dataStream = QDataStream(qf)
script = self.readStackFromStream(dataStream)
#qf.close()
return script, qf, dataStream
def sendClientCommand(host, port, cmd, wait_time=WAIT_TIME_MS):
# Try to connect to a host server
tcpSocket = QTcpSocket()
tcpSocket.connectToHost(host, port, QIODevice.ReadWrite)
if not tcpSocket.waitForConnected(msecs=wait_time):
return CLIENT_ERROR_NO_CONNECTION
# Prepare a command message to be sent
block = QByteArray(
len(cmd.encode("UTF-8")).to_bytes(2, byteorder='big')
+ cmd.encode("UTF-8"))
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
tcpSocket.write(block)
# Try to send the message
if not tcpSocket.waitForBytesWritten(msecs=wait_time):
return CLIENT_ERROR_BLOCK_NOT_WRITTEN
# Wait for a response from the host server
if not tcpSocket.waitForReadyRead(msecs=wait_time):
return CLIENT_ERROR_NO_RESPONSE
# Try to read the response
instr = QDataStream(tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
blockSize = 0
if blockSize == 0:
if tcpSocket.bytesAvailable() < 2:
return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
blockSize = instr.readUInt16()
if tcpSocket.bytesAvailable() < blockSize:
return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
# Wait until the host server terminates the connection
tcpSocket.waitForDisconnected()
# Return value representing a command execution status
if instr.readRawData(blockSize).decode("UTF-8") \
== COMMAND_EXECUTED_CONFIRMATION_MESSAGE:
return CLIENT_COMMAND_EXECUTED
else:
return CLIENT_COMMAND_FAILED
def dropEvent(self, event):
if event.mimeData().hasFormat("application/x-lista-item"):
data = event.mimeData().data("application/x-lista-item")
stream = QDataStream(data, QIODevice.ReadOnly)
self._player_name = stream.readQString()
self._player_id = stream.readInt16() # sor eseten p1, oszlopnál p2
for i in range(self.sorok_szama):
self.parent.eredmenyek[self._csoport_number][
self._csoport_sor][i]._set_p1_id(self._player_id)
self.parent.eredmenyek[self._csoport_number][i][
self._csoport_sor]._set_p2_id(self._player_id)
# print("id: ", self._player_id, "csoport: ", self._get_csoport_number(), "sor: ", self._get_csoport_sor())
# icon = QIcon()
# stream >> icon
event.setDropAction(Qt.MoveAction)
event.accept()
self.update()
else:
event.ignore()
def saveState(self):
"""
Save the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("saving config state ...")
settings = QSettings()
b = QByteArray()
ds = QDataStream(b, QIODevice.WriteOnly)
l = [
rc.data() for rc in self.recentConfigs
if rc.isVisible() and rc.data() is not None and rc.data() != ""
]
ds.writeQStringList(l)
settings.setValue("ConfigurationRecentFiles", b)
logger.debug("saving config state done (%s)", l)
def mimeData(self, indexes: List["QModelIndex"]) -> "QMimeData":
"""
Returns a serialized object representing a List of Keras Layer. Used for
drag/drop operations, for example.
"""
mime_data = QMimeData()
# Serializer
encoded_data = QByteArray()
stream = QDataStream(encoded_data, QIODevice.WriteOnly)
# Write all the layers corresponding to the indexes
for index in indexes:
if index.isValid():
layer = index.internalPointer().layer
stream.writeQVariant(layer)
# Store the serialized data on the MIME data
mime_data.setData(Dial.KerasLayerListMIME.value, encoded_data)
return mime_data
def testRawData(self):
data = QDataStream()
self.assertEqual(data.readRawData(4), None)
ba = QByteArray()
data = QDataStream(ba, QIODevice.WriteOnly)
data.writeRawData('AB\x00C')
self.assertEqual(ba.data(), py3k.b('AB\x00C'))
data = QDataStream(ba)
self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
def run(self):
self.mutex.lock()
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
while not self.quit:
Timeout = 5 * 1000
socket = QTcpSocket()
socket.connectToHost(serverName, serverPort)
if not socket.waitForConnected(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
while socket.bytesAvailable() < 2:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
instr = QDataStream(socket)
instr.setVersion(QDataStream.Qt_4_0)
blockSize = instr.readUInt16()
while socket.bytesAvailable() < blockSize:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
self.mutex.lock()
fortune = instr.readQString()
self.newFortune.emit(fortune)
self.cond.wait(self.mutex)
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
def restoreState(self):
"""
Restore the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("restoring config state ...")
settings = QSettings()
v = settings.value("ConfigurationRecentFiles")
if v is not None and isinstance(v, QByteArray):
ds = QDataStream(v)
recentFiles = ds.readQStringList()
idx = 0
for f in recentFiles:
if f != "" and f is not None:
self.recentConfigs[idx].setData(f)
self.recentConfigs[idx].setText(f)
self.recentConfigs[idx].setVisible(True)
idx += 1
if idx >= len(self.recentConfigs):
break
logger.debug("restoring config state done")
def accept_and_add(item, event):
hot_spot_point = QPoint()
item_data = event.mimeData().data(config_controller.component_mime)
data_stream = QDataStream(item_data, QIODevice.ReadOnly)
data_stream >> hot_spot_point
view_to_scene_transform, succes = self.page_view_transform.inverted(
)
if not succes:
logger.error("Page_view_transform could not be inverted")
hot_spot_point = view_to_scene_transform.map(hot_spot_point)
item.set_position(event.scenePos() - hot_spot_point)
self.add_component_controller(item)
logger.info("dropEvent")
event.setDropAction(Qt.MoveAction)
event.accept()
def mimeData(self, indexes):
""" Returns an object that contains serialized items of data corresponding to the list of indexes specified. """
mimeData = QMimeData()
encodedData = QByteArray()
stream = QDataStream(encodedData, QIODevice.WriteOnly)
for index in indexes:
if index.isValid() and index.column() == 0:
# Note: We select full rows, but only want to make one item per row
item = self.nodeFromIndex(index)
# For performance reasons we do not make a full copy
# Instead we just serialize unique name and current row
# We also don't remove the item using self.removeRows but rather handle it inside of dropMimeData
stream.writeInt32(item.typeId())
stream.writeInt64(item.uuid())
stream.writeInt32(index.row())
mimeData.setData("application/vnd.text.list", encodedData)
return mimeData
def startDrag(self, dropActions):
item = self.currentItem()
# icon = item.icon()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.writeQString(item.text())
stream.writeInt16(item.data(1))
# stream << icon
mimeData = QMimeData()
mimeData.setData("application/x-lista-item", data)
drag = QDrag(self)
drag.setMimeData(mimeData)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
self.takeItem(self.row(item))
def __init__(self, parent=None):
super(NetworkConnectionClass, self).__init__(parent=parent)
#self.CommandSocket = QTcpSocket()
self.CommandSocket = QUdpSocket()
self.CommandSocket.bind(QHostAddress("192.168.100.2"), 2323)
self.CommandSocket.connected.connect(self.EventConnectedHandle)
self.CommandSocket.readyRead.connect(self.RecieveData)
#self.CommandSocket.connectToHost("192.168.100.5",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("127.0.0.1",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("192.168.20.196",2323,QIODevice.ReadWrite)
#print("NETWORK - ",self.CommandSocket.localAddress(),self.CommandSocket.peerAddress())
self.Display = WindowNetworkConnection()
self.NetworkDataArray = QByteArray()
self.NetworkDataArray.resize(2000)
self.SignalDataRec.connect(self.Display.PrintData)
self.BufferWrite = QBuffer(self.NetworkDataArray)
self.BufferWrite.open(QBuffer.WriteOnly)
self.BufferRead = QBuffer(self.NetworkDataArray)
self.BufferRead.open(QBuffer.ReadOnly)
self.ReadDataStream = QDataStream(self.BufferRead)
self.ReadDataStream.setByteOrder(QDataStream.LittleEndian)
self.WriteDataStream = QDataStream(self.BufferWrite)
self.WriteDataStream.setByteOrder(QDataStream.LittleEndian)
self.SocketDataStream = QDataStream(self.CommandSocket)
self.SocketDataStream.setByteOrder(QDataStream.LittleEndian)
self.Timer = QTime()
self.Timer.start()
self.BufferRead.seek(0)
self.BufferWrite.seek(0)
self.LimitBufferSize = 2000
self.MinTransferUnit = 7
self.MaxTransferUnit = 18
self.bytesAvailable = 0
self.Display.ui.pushButton.clicked.connect(self.SendData)
#===================================================== WRITE BUFFER
self.SendBuffer = QByteArray()
def startDrag(self):
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.writeQString(self._player_name)
stream.writeInt16(self._player_id)
mimedata = QMimeData()
mimedata.setData("application/x-lista-item", data)
drag = QDrag(self)
drag.setMimeData(mimedata)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
self._player_name = ""
self._player_id = 0
for i in range(self.sorok_szama):
self.parent.eredmenyek[self._csoport_number][
self._csoport_sor][i]._set_p1_id(0)
self.parent.eredmenyek[self._csoport_number][i][
self._csoport_sor]._set_p2_id(0)
self.update()
def dropMimeData(self, data, action, row, column, parentIndex):
""" Handles the data supplied by a drag and drop operation that ended with the given action. """
if action == Qt.IgnoreAction:
return True
if not data.hasFormat("application/vnd.text.list"):
return False
encodedData = data.data("application/vnd.text.list")
stream = QDataStream(encodedData, QIODevice.ReadOnly)
parent = self.nodeFromIndex(parentIndex)
destRow = row if row != -1 else parent.childCount()
numPlacedBeforeDestination = 0
# MAYA-66630: We want all of this to be one undo transaction
while not stream.atEnd():
typeId = stream.readInt32()
uuid = stream.readInt64()
oldRow = stream.readInt32()
child = None
if typeId == TYPE_ID_LIGHT_ITEM:
child = self.lights[uuid]
elif typeId == TYPE_ID_GROUP_ITEM:
child = self.groups[uuid]
else:
print("Error: Unstream of unknown node type " + str(typeId))
continue
oldParent = child.parent()
oldParent.removeChild(child)
# We are inserting into range [row, row+numRows]. But we also remove. If we remove an item from our parent before this range,
# we must reduce indices that we insert at after that
if oldParent == parent and oldRow < row:
numPlacedBeforeDestination += 1
parent.insertChild(child, destRow - numPlacedBeforeDestination)
destRow += 1
return True
def run(self):
self.mutex.lock()
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
while not self.quit:
Timeout = 5 * 1000
socket = QTcpSocket()
socket.connectToHost(serverName, serverPort)
if not socket.waitForConnected(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
while socket.bytesAvailable() < 2:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
instr = QDataStream(socket)
instr.setVersion(QDataStream.Qt_4_0)
blockSize = instr.readUInt16()
while socket.bytesAvailable() < blockSize:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
self.mutex.lock()
fortune = instr.readQString()
self.newFortune.emit(fortune)
self.cond.wait(self.mutex)
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
class QDataStreamShift(unittest.TestCase):
'''Test case for << and >> operators'''
def setUp(self):
self.ba = QByteArray()
self.stream = QDataStream(self.ba, QIODevice.WriteOnly)
self.read_stream = QDataStream(self.ba, QIODevice.ReadOnly)
def testQCharValid(self):
'''QDataStream <<>> QChar - valid'''
self.stream.writeQChar(42)
res = self.read_stream.readQChar()
self.assertEqual(res, py3k.unichr(42))
def testQCharNull(self):
'''QDataStream <<>> QChar - null'''
self.stream.writeQChar(None)
res = self.read_stream.readQChar()
self.assertEqual(res, py3k.unicode_('\x00'))
def testQByteArrayValid(self):
'''QDataStream <<>> QByteArray - valid'''
self.stream << QByteArray("hello")
res = QByteArray()
self.read_stream >> res
self.assertEqual(res, QByteArray("hello"))
def testQByteArrayEmpty(self):
'''QDataStream <<>> QByteArray - empty'''
self.stream << QByteArray("")
res = QByteArray()
self.read_stream >> res
self.assertEqual(res, QByteArray(""))
self.assertTrue(res.isEmpty())
self.assertFalse(res.isNull())
def testQByteArrayNull(self):
'''QDataStream <<>> QByteArray - null'''
self.stream << QByteArray()
res = QByteArray()
self.read_stream >> res
self.assertEqual(res, QByteArray())
self.assertTrue(res.isEmpty())
self.assertTrue(res.isNull())
def testQStringValid(self):
'''QDataStream <<>> QString - valid'''
self.stream.writeQString('Ka-boom')
res = self.read_stream.readQString()
self.assertEqual(res, py3k.unicode_('Ka-boom'))
def testQStringEmpty(self):
'''QDataStream <<>> QString - empty'''
self.stream.writeQString('')
res = self.read_stream.readQString()
self.assertEqual(res, py3k.unicode_(''))
def testQStringNull(self):
'''QDataStream <<>> QString - null'''
self.stream.writeQString(None)
res = self.read_stream.readQString()
self.assertEqual(res, py3k.unicode_(''))
def testQBitArrayNull(self):
'''QDataStream <<>> QBitArray - null'''
self.stream << QBitArray()
res = QBitArray()
self.read_stream >> res
self.assertEqual(res, QBitArray())
def testQBitArrayValid(self):
'''QDataStream <<>> QBitArray - valid'''
self.stream << create_bitarray('01010101')
res = QBitArray()
self.read_stream >> res
self.assertEqual(res, create_bitarray('01010101'))
def testQDateNull(self):
'''QDataStream <<>> QDate - null'''
self.stream << QDate()
res = QDate()
self.read_stream >> res
self.assertEqual(res, QDate())
self.assertFalse(res.isValid())
self.assertTrue(res.isNull())
def testQDateValid(self):
'''QDataStream <<>> QDate - valid'''
self.stream << QDate(2012, 12, 21)
res = QDate()
self.read_stream >> res
self.assertEqual(res, QDate(2012, 12, 21))
self.assertTrue(res.isValid())
self.assertFalse(res.isNull())
def testQTimeNull(self):
'''QDataStream <<>> QTime - null'''
self.stream << QTime()
res = QTime()
self.read_stream >> res
self.assertEqual(res, QTime())
self.assertFalse(res.isValid())
self.assertTrue(res.isNull())
def testQTimeValid(self):
'''QDataStream <<>> QTime - valid'''
self.stream << QTime(12, 12, 21)
res = QTime()
self.read_stream >> res
self.assertEqual(res, QTime(12, 12, 21))
self.assertTrue(res.isValid())
self.assertFalse(res.isNull())
def testQDateTimeNull(self):
'''QDataStream <<>> QDateTime - null'''
self.stream << QDateTime()
res = QDateTime()
self.read_stream >> res
self.assertEqual(res, QDateTime())
self.assertFalse(res.isValid())
self.assertTrue(res.isNull())
def testQDateTimeValid(self):
'''QDataStream <<>> QDateTime - valid'''
time = QTime(23, 23, 23)
date = QDate(2009, 1, 1)
self.stream << QDateTime(date, time)
res = QDateTime()
self.read_stream >> res
self.assertEqual(res, QDateTime(date, time))
self.assertTrue(res.isValid())
self.assertFalse(res.isNull())
def __lshift__(self, Sender: QDataStream):
self.Speed1 = Sender.readInt16()
self.Speed2 = Sender.readInt16()
self.Speed3 = Sender.readInt16()
self.Speed4 = Sender.readInt16()
class QDataStreamWrite(unittest.TestCase):
'''Test case for QDatastream write* functions'''
def setUp(self):
self.ba = QByteArray()
self.read = QDataStream(self.ba, QIODevice.ReadOnly)
self.write = QDataStream(self.ba, QIODevice.WriteOnly)
def testWriteUInt8(self):
'''QDataStream.writeUInt8 (accepting str of size 1)'''
x = 0xFF
self.write.writeUInt8(x)
y = self.read.readUInt8()
self.assertEqual(x, y)
self.assertRaises(TypeError, self.write.writeUInt8, 'aaaaa')
def testWriteInt8(self):
'''QDataStream.writeInt8 (accepting str of size 1)'''
x = 65
self.write.writeInt8(chr(x))
y = self.read.readInt8()
self.assertEqual(x, y)
self.assertRaises(TypeError, self.write.writeInt8, 'aaaaa')
def testWriteUInt8Int(self):
'''QDataStream.writeUInt8 (accepting integer)'''
x = 0xFF
self.write.writeUInt8(x)
y = self.read.readUInt8()
self.assertEqual(x, y)
def testWriteInt8Int(self):
'''QDataStream.writeInt8 (accepting integer)'''
x = 65
self.write.writeInt8(x)
y = self.read.readInt8()
self.assertEqual(x, y)
def testWriteUInt16(self):
'''QDataStream.writeUInt16'''
x = 0x4423
self.write.writeUInt16(x)
y = int(self.read.readUInt16())
self.assertEqual(x, y)
def testWriteUInt32(self):
'''QDataStream.writeUInt32'''
x = 0xdeadbeef
self.write.writeUInt32(x)
y = int(self.read.readUInt32())
self.assertEqual(x, y)
def run(self):
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
self.error.emit(tcpSocket.error())
return
block = QByteArray()
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeQString(self.text)
outstr.device().seek(0)
outstr.writeUInt16(block.size() - 2)
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def __lshift__(self, Sender: QDataStream):
self.Connect = Sender.readInt8()
print("CONNECT CHECK REQUEST LOAD FROM DATA STREAM")
def setUp(self):
self.ba = QByteArray()
self.stream = QDataStream(self.ba, QIODevice.WriteOnly)
self.read_stream = QDataStream(self.ba, QIODevice.ReadOnly)
