[lit] Fix several tests that fail when using Python 3 or on Windows

[stella.stamenova]

Summary

1. In logtest.cpp, the name of the file that is reported is not always capitalized, so split the comparison to validate the file (case insensitive) and function (case sensitive) separately
2. Update the gdb remote client tests to work with Python 3. In Python 3, socket sends/receives data as bytes rather than byte strings. This also updates the usage of .hex() - this is no longer available in Python 3, so use hexlify instead

[zturner]

packages/Python/lldbsuite/test/functionalities/gdb_remote_client/gdbclientutils.py

281–285 ↗

(On Diff #146405)

It's a shame that we're not using lit here. lit has a nice function lit.util.to_string which handles this (and one other strange edge case) correctly.

389–392 ↗

(On Diff #146405)

Similarly here.

[stella.stamenova]

packages/Python/lldbsuite/test/functionalities/gdb_remote_client/gdbclientutils.py

281–285 ↗

(On Diff #146405)

I looked into using it - but currently none of the lldb tests use functionality from lit and I don't think there's a good way to do so. Let me know if you have a suggestion, but otherwise, I think this is the least impactful change that fixes the tests.

[zturner]

No it's fine, I was just thinking out loud.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestGDBRemoteClient.py

 import lldb
+import binascii
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestGDBRemoteClient(GDBRemoteTestBase):
 
     def test_connect(self):
def test_attach_fail(self):
             def qC(self):
                 return "E42"
 
             def qfThreadInfo(self):
                 return "OK" # No threads.
 
             # Then, when we are asked to attach, error out.
             def vAttach(self, pid):
-                return "E42;" + error_msg.encode("hex")
+                return "E42;" + binascii.hexlify(error_msg.encode()).decode()
 
         self.server.responder = MyResponder()
 
         target = self.dbg.CreateTarget("")
         process = self.connect(target)
         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
 
         error = lldb.SBError()
         target.AttachToProcessWithID(lldb.SBListener(), 47, error)
         self.assertEquals(error_msg, error.GetCString())

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/gdbclientutils.py

def hex_decode_bytes(hex_bytes):
     while i < hex_len - 1:
         out += chr(int(hex_bytes[i:i + 2]), 16)
         i += 2
     return out
 
 
 class MockGDBServerResponder:
     """
-    A base class for handing client packets and issuing server responses for
+    A base class for handling client packets and issuing server responses for
     GDB tests.
 
     This handles many typical situations, while still allowing subclasses to
     completely customize their responses.
 
     Most subclasses will be interested in overriding the other() method, which
     handles any packet not recognized in the common packet handling code.
     """
def _run(self):
         self._receivedData = ""
         self._receivedDataOffset = 0
         data = None
         while True:
             try:
                 data = self._client.recv(4096)
                 if data is None or len(data) == 0:
                     break
+                # In Python 2, sockets return byte strings. In Python 3, sockets return bytes.
+                # If we got bytes (and not a byte string), decode them to a string for later handling.
+                if isinstance(data, bytes) and not isinstance(data, str):
+                    data = data.decode()
+                self._receive(data)
             except Exception as e:
                 self._client.close()
                 break
-            self._receive(data)
 
     def _receive(self, data):
         """
         Collects data, parses and responds to as many packets as exist.
         Any leftover data is kept for parsing the next time around.
         """
         self._receivedData += data
         try:
def _parsePacket(self):
                 return self.PACKET_ACK
             if ord(data[0]) == 3:
                 self._receivedData = data[1:]
                 return self.PACKET_INTERRUPT
             if data[0] == '$':
                 i += 1
             else:
                 raise self.InvalidPacketException(
-                        "Unexexpected leading byte: %s" % data[0])
+                        "Unexpected leading byte: %s" % data[0])
 
         # If we're looking beyond the start of the received data, then we're
         # looking for the end of the packet content, denoted by a #.
         # Note that we pick up searching from where we left off last time
         while i < data_len and data[i] != '#':
             i += 1
 
         # If there isn't enough data left for a checksum, just remember where
class MockGDBServer:
     def _handlePacket(self, packet):
         if packet is self.PACKET_ACK:
             # Ignore ACKs from the client. For the future, we can consider
             # adding validation code to make sure the client only sends ACKs
             # when it's supposed to.
             return
         response = ""
         # We'll handle the ack stuff here since it's not something any of the
-        # tests will be concerned about, and it'll get turned off quicly anyway.
+        # tests will be concerned about, and it'll get turned off quickly anyway.
         if self._shouldSendAck:
-            self._client.sendall('+')
+            self._client.sendall('+'.encode())
         if packet == "QStartNoAckMode":
             self._shouldSendAck = False
             response = "OK"
         elif self.responder is not None:
             # Delegate everything else to our responder
             response = self.responder.respond(packet)
         # Handle packet framing since we don't want to bother tests with it.
         if response is not None:
             framed = frame_packet(response)
+            # In Python 2, sockets send byte strings. In Python 3, sockets send bytes.
+            # If we got a string (and not a byte string), encode it before sending.
+            if isinstance(framed, str) and not isinstance(framed, bytes):
+                framed = framed.encode()
             self._client.sendall(framed)
 
     PACKET_ACK = object()
     PACKET_INTERRUPT = object()
 
     class InvalidPacketException(Exception):
         pass
 
def assertPacketLogContains(self, packets):
         sent the expected packets to the server.
 
         The check does not require that the packets be consecutive, but does
         require that they are ordered in the log as they ordered in the arg.
         """
         i = 0
         j = 0
         log = self.server.responder.packetLog
+        
         while i < len(packets) and j < len(log):
             if log[j] == packets[i]:
                 i += 1
             j += 1
         if i < len(packets):
             self.fail(u"Did not receive: %s\nLast 10 packets:\n\t%s" %
                     (packets[i], u'\n\t'.join(log[-10:])))

lldb/trunk/unittests/Utility/LogTest.cpp

TEST_F(LogChannelEnabledTest, log_options) {
   {
     EXPECT_TRUE(EnableChannel(getStream(), LLDB_LOG_OPTION_PREPEND_SEQUENCE,
                               "chan", {}, Err));
     llvm::StringRef Msg = logAndTakeOutput("Hello World");
     int seq_no;
     EXPECT_EQ(1, sscanf(Msg.str().c_str(), "%d Hello World", &seq_no));
   }
 
+  {
     EXPECT_TRUE(EnableChannel(getStream(), LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION,
                               "chan", {}, Err));
-  EXPECT_EQ(
-      "LogTest.cpp:logAndTakeOutput                                 Hello "
-      "World\n",
-      logAndTakeOutput("Hello World"));
+    llvm::StringRef Msg = logAndTakeOutput("Hello World");
+    char File[12];
+    char Function[17];
+      
+    sscanf(Msg.str().c_str(), "%[^:]:%s                                 Hello World", File, Function);
+    EXPECT_STRCASEEQ("LogTest.cpp", File);
+    EXPECT_STREQ("logAndTakeOutput", Function);
+  }
 
   EXPECT_TRUE(EnableChannel(
       getStream(), LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD, "chan", {}, Err));
   EXPECT_EQ(llvm::formatv("[{0,0+4}/{1,0+4}] Hello World\n", ::getpid(),
                           llvm::get_threadid())
                 .str(),
             logAndTakeOutput("Hello World"));
 }