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 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 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
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)