Tests working.

Author: ioquatix

.github/workflows/test-coverage.yaml

@@ -15,7 +15,6 @@ jobs:
       matrix:
         os:
           - ubuntu
-          - macos
 
         ruby:
           - "3.2"
@@ -37,10 +36,11 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: ruby/setup-ruby@v1
+    - uses: ruby/setup-ruby-pkgs@v1
       with:
         ruby-version: ${{matrix.ruby}}
         bundler-cache: true
+        apt-get: gdb
 
     - name: Run tests
       timeout-minutes: 10

.github/workflows/test-external.yaml

@@ -28,7 +28,16 @@ def get_constant(self, name):
         """Lazy load and cache Ruby constants"""
         if name not in self._constants:
             try:
-                self._constants[name] = int(gdb.parse_and_eval(name))
+                # Handle special case for RUBY_Qnil which might not be a constant
+                if name == "RUBY_Qnil":
+                    # RUBY_Qnil is typically 8 or 4 depending on Ruby version
+                    try:
+                        self._constants[name] = int(gdb.parse_and_eval(name))
+                    except:
+                        # Default to 8 for modern Ruby
+                        self._constants[name] = 8
+                else:
+                    self._constants[name] = int(gdb.parse_and_eval(name))
                 self.debug(f"Loaded constant {name} = {self._constants[name]}")
             except Exception as e:
                 self.debug(f"Failed to load constant {name}: {e}")
@@ -138,14 +147,201 @@ def print_item_label(self, depth, index):
         """Print a consistently formatted array item label"""
         self.print_with_indent(depth, f"[{index:>4}] I: ", end='')
 
-    def safe_rp(self, obj):
-        """Safely execute rp command with error handling"""
+    def print_value(self, value):
+        """Print a primitive Ruby value (immediate values and simple types)"""
+        val_int = int(value)
+        
+        # Handle special constants
+        if val_int == 0:
+            print("false")
+            return True
+        elif val_int == 0x04 or val_int == 0x08:
+            print("nil")
+            return True
+        elif val_int == 0x14:
+            print("true")
+            return True
+        elif (val_int & 0x01) != 0:
+            # Fixnum - shift right to get actual value
+            print(val_int >> 1)
+            return True
+        elif (val_int & 0xFF) == 0x0C:
+            # Symbol - extract the symbol name
+            return self.print_symbol(value)
+        
+        # For other types, try to inspect the object
+        try:
+            basic = value.cast(self.get_type("struct RBasic").pointer())
+            flags = int(basic.dereference()['flags'])
+            type_flag = flags & self.get_constant("RUBY_T_MASK")
+            
+            if type_flag == self.get_constant("RUBY_T_STRING"):
+                return self.print_string_value(value, flags)
+            elif type_flag == self.get_constant("RUBY_T_SYMBOL"):
+                return self.print_symbol_object(value)
+            else:
+                # Unknown type - print type and address
+                print(f"<Object:0x{val_int:x} type=0x{type_flag:x}>")
+                return True
+        except Exception as e:
+            print(f"<Value:0x{val_int:x}>")
+            return True
+    
+    def get_symbol_name(self, symbol_id):
+        """Get symbol name from ID using Ruby's global symbol table
+        This is a direct translation of print_id from Ruby's .gdbinit"""
+        try:
+            # rb_id_to_serial
+            tLAST_OP_ID = 163  # This is a constant from Ruby
+            ID_ENTRY_UNIT = 512
+            ID_ENTRY_SIZE = 2
+            
+            id_val = symbol_id
+            
+            if id_val > tLAST_OP_ID:
+                try:
+                    RUBY_ID_SCOPE_SHIFT = int(self.get_constant("RUBY_ID_SCOPE_SHIFT"))
+                except:
+                    RUBY_ID_SCOPE_SHIFT = 3  # Default value
+                serial = id_val >> RUBY_ID_SCOPE_SHIFT
+            else:
+                serial = id_val
+            
+            # Access ruby_global_symbols
+            global_symbols = gdb.parse_and_eval("ruby_global_symbols")
+            last_id = int(global_symbols['last_id'])
+            
+            if not serial or serial > last_id:
+                return None
+            
+            idx = serial // ID_ENTRY_UNIT
+            ids = global_symbols['ids'].cast(self.get_type("struct RArray").pointer())
+            flags = int(ids.dereference()['basic']['flags'])
+            
+            # Get idsptr and idslen based on whether array is embedded or heap
+            if flags & self.get_constant("RUBY_FL_USER1"):
+                idsptr = ids.dereference()['as']['ary']
+                mask = self.get_constant("RUBY_FL_USER3") | self.get_constant("RUBY_FL_USER4")
+                shift = self.get_constant("RUBY_FL_USHIFT") + 3
+                idslen = (flags & mask) >> shift
+            else:
+                idsptr = ids.dereference()['as']['heap']['ptr']
+                idslen = int(ids.dereference()['as']['heap']['len'])
+            
+            if idx >= idslen:
+                return None
+            
+            t = 0
+            ary_val = idsptr[idx]
+            
+            # Check if RUBY_Qnil
+            qnil = self.get_constant("RUBY_Qnil")
+            if int(ary_val) == qnil:
+                return None
+            
+            ary = ary_val.cast(self.get_type("struct RArray").pointer())
+            ary_flags = int(ary.dereference()['basic']['flags'])
+            
+            # Get aryptr and arylen based on whether array is embedded or heap
+            if ary_flags & self.get_constant("RUBY_FL_USER1"):
+                aryptr = ary.dereference()['as']['ary']
+                mask = self.get_constant("RUBY_FL_USER3") | self.get_constant("RUBY_FL_USER4")
+                shift = self.get_constant("RUBY_FL_USHIFT") + 3
+                arylen = (ary_flags & mask) >> shift
+            else:
+                aryptr = ary.dereference()['as']['heap']['ptr']
+                arylen = int(ary.dereference()['as']['heap']['len'])
+            
+            result = aryptr[(serial % ID_ENTRY_UNIT) * ID_ENTRY_SIZE + t]
+            
+            # Check if RUBY_Qnil
+            if int(result) == qnil:
+                return None
+            
+            # Extract string from result
+            result_flags = int(result.cast(self.get_type("struct RBasic").pointer()).dereference()['flags'])
+            return self.extract_string_data(result, result_flags)
+            
+        except Exception as e:
+            self.debug(f"Error getting symbol name: {e}")
+            return None
+    
+    def extract_string_data(self, value, flags):
+        """Extract raw string data from a Ruby String object"""
         try:
-            gdb.execute(f"rp {obj}")
+            rstring = value.cast(self.get_type("struct RString").pointer())
+            length = int(rstring.dereference()['len'])
+            
+            if length == 0:
+                return ""
+            
+            # Check if embedded or heap-allocated
+            if (flags & self.get_constant("RUBY_FL_USER1")) != 0:
+                # Heap string
+                ptr = rstring.dereference()['as']['heap']['ptr']
+            else:
+                # Embedded string
+                ptr = rstring.dereference()['as']['embed']['ary']
+            
+            # Read the string data
+            string_data = gdb.selected_inferior().read_memory(ptr, length).tobytes()
+            try:
+                return string_data.decode('utf-8')
+            except:
+                return string_data.hex()
+        except Exception as e:
+            self.debug(f"Error extracting string: {e}")
+            return None
+    
+    def print_symbol(self, value):
+        """Print a symbol (immediate symbol encoding)"""
+        val_int = int(value)
+        try:
+            # Symbol ID is encoded in the VALUE
+            # Different Ruby versions encode it differently
+            # Try to extract and look up in global symbol table
+            symbol_id = val_int >> 8
+            
+            # Try to get symbol name from global symbol table
+            symbol_name = self.get_symbol_name(symbol_id)
+            
+            if symbol_name:
+                print(f":{symbol_name}")
+            else:
+                print(f":id_0x{symbol_id:x}")
             return True
         except Exception as e:
-            print(f"[Error printing object: {str(e)}]")
-            return False
+            self.debug(f"Error printing symbol: {e}")
+            print(f":0x{val_int:x}")
+            return True
+    
+    def print_symbol_object(self, value):
+        """Print a T_SYMBOL object (heap-allocated symbol)"""
+        try:
+            rsymbol = value.cast(self.get_type("struct RSymbol").pointer())
+            fstr = rsymbol.dereference()['fstr']
+            
+            # fstr is a String containing the symbol name
+            print(":", end='')
+            self.print_string_value(fstr, int(fstr.cast(self.get_type("struct RBasic").pointer()).dereference()['flags']))
+            return True
+        except Exception as e:
+            print(f":<Symbol:0x{int(value):x}>")
+            return True
+    
+    def print_string_value(self, value, flags):
+        """Print a Ruby string value"""
+        string_data = self.extract_string_data(value, flags)
+        if string_data is not None:
+            print(string_data, end='')
+            return True
+        else:
+            print(f"<String error>")
+            return True
+
+    def safe_rp(self, obj):
+        """Legacy method - now redirects to print_value"""
+        return self.print_value(obj)
 
     def print_object(self, value, depth, max_depth):
         """Print a value, recursively if it's a hash or array"""
@@ -309,7 +505,7 @@ def print_st_table(self, object_ptr, depth, max_depth):
         for i in range(num_entries):
             self.print_key_label(depth, i)
             key = st_table.dereference()['entries'][i]['key']
-            self.safe_rp(key)
+            self.print_object(key, depth + 1, max_depth)
 
             self.print_value_label(depth)
             value = st_table.dereference()['entries'][i]['record']
@@ -338,7 +534,7 @@ def print_ar_table(self, object_ptr, flags, depth, max_depth):
             # Skip undefined/deleted entries:
             if int(key) != self.get_constant("RUBY_Qundef"):
                 self.print_key_label(depth, i)
-                self.safe_rp(key)
+                self.print_object(key, depth + 1, max_depth)
 
                 self.print_value_label(depth)
                 value = ar_table.dereference()['pairs'][i]['val']

.github/workflows/test.yaml

@@ -164,7 +164,32 @@ def normalize_output(output)
 					line.match?(/^Copyright/) ||
 					line.match?(/^License/) ||
 					line.match?(/^This is free software/) ||
-					line.match?(/^There is NO WARRANTY/)
+					line.match?(/^There is NO WARRANTY/) ||
+					# Remove lines with process/thread IDs that change on each run
+					line.match?(/\bLWP \d+\b/) ||                      # Linux thread IDs
+					line.match?(/\bprocess \d+\b/) ||                  # Process IDs
+					line.match?(/0x[0-9a-f]+\s+\(LWP/) ||             # Thread addresses with LWP
+					line.match?(/^Thread \d+ "/) ||                    # Thread hit messages
+					line.match?(/^Thread 0x/) ||                       # Thread exit messages
+					line.match?(/^\[Thread /) ||                       # Thread debugging messages
+					line.match?(/^\[New Thread/) ||                    # New thread messages
+					line.match?(/^\[Inferior /) ||                     # Inferior process messages
+					line.match?(/^Using host libthread_db/) ||         # Thread debugging library
+					line.match?(/^Reading symbols from/) ||            # Symbol loading
+					line.match?(/Breakpoint \d+ at 0x[0-9a-f]+:/)     # Breakpoint addresses (keep line number only)
+				end
+				
+				# Normalize lines to remove non-deterministic values
+				lines.map! do |line|
+					if line.match?(/^Breakpoint \d+ at /)
+						# Keep only the meaningful part without the hex address
+						line.gsub(/^(Breakpoint \d+) at 0x[0-9a-f]+:/, '\1:')
+					elsif line.match?(/(AR Table|ST Table|Heap Array|Embedded Array|Heap Struct|Embedded Struct) at (0x[0-9a-f]+|\d+)/)
+						# Normalize memory addresses (both hex and decimal) in table/array/struct headers
+						line.gsub(/ at (?:0x[0-9a-f]+|\d+)/, ' at <address>')
+					else
+						line
+					end
 				end
 
 				lines.join("\n").strip + "\n"