feat(expressions): add literal type suffixes and char support

- Add support for numeric type suffixes (L, UL, f) in tokenizer and parser
- Add char literal parsing with single quotes and escape sequences
- Add hex escape sequence (\xNN) support in strings and char literals
- Improve literal formatting with proper type suffixes and escaping
- Add NullElement.is_null property accessor
- Fix ValueElement handling for interface types (Enumerable)
- Add elem<T>() convenience function for creating elements
- Enable all tests in TestRunner

.gitignore

@@ -4,4 +4,5 @@ build.ninja
 compile_commands.json
 /tests
 .ninja_log
-.ninja_deps
+.ninja_deps
+/builddir

src/lib/Element.vala

@@ -149,9 +149,9 @@ namespace Invercargill {
             } else if(type == typeof(uint64)) {
                 return assert_as<uint64?>().to_string();
             } else if(type == typeof(float)) {
-                return assert_as<float?>().to_string();
+                return "%g".printf(assert_as<float?>());
             } else if(type == typeof(double)) {
-                return assert_as<double?>().to_string();
+                return "%g".printf(assert_as<double?>());
             } else if(type == typeof(string)) {
                 return assert_as<string>().to_string();
             }
@@ -321,7 +321,16 @@ namespace Invercargill {
         public ValueElement(Value value) {
             this.value = value;
         }
-        
+
+        /**
+         * Gets the raw Value contained in this element.
+         * This is useful for extracting objects that implement interfaces
+         * where generic type checking doesn't work correctly.
+         */
+        public Value get_value() {
+            return value;
+        }
+
         public bool assignable_to_type(GLib.Type type) {
             if(is_type(type)) {
                 return true;

src/lib/Expressions/Convenience.vala

@@ -8,4 +8,8 @@ namespace Invercargill.Expressions {
         return ExpressionParser.parse_with_params(expression, Wrap.va_list<Element>(first, va_list()));
     }
 
+    public Element elem<T>(T value) {
+        return new NativeElement<T>(value);
+    }
+
 }

src/lib/Expressions/ExpressionParser.vala

@@ -356,17 +356,42 @@ namespace Invercargill.Expressions {
                 return new LiteralExpression(new NativeElement<int64?>(value));
             }
 
+            if (match(TokenType.LONG_INTEGER)) {
+                var token = previous();
+                int64 value = int64.parse(token.value);
+                return new LiteralExpression(new NativeElement<int64?>(value));
+            }
+
+            if (match(TokenType.UNSIGNED_LONG)) {
+                var token = previous();
+                uint64 value = uint64.parse(token.value);
+                return new LiteralExpression(new NativeElement<uint64?>(value));
+            }
+
             if (match(TokenType.FLOAT)) {
                 var token = previous();
                 double value = double.parse(token.value);
                 return new LiteralExpression(new NativeElement<double?>(value));
             }
 
+            if (match(TokenType.FLOAT_LITERAL)) {
+                var token = previous();
+                float value = (float)double.parse(token.value);
+                return new LiteralExpression(new NativeElement<float?>(value));
+            }
+
             if (match(TokenType.STRING)) {
                 var token = previous();
                 return new LiteralExpression(new NativeElement<string>(token.value));
             }
 
+            if (match(TokenType.CHAR_LITERAL)) {
+                var token = previous();
+                // The value is stored as a single character string
+                char value = token.value.length > 0 ? token.value[0] : '\0';
+                return new LiteralExpression(new NativeElement<char>(value));
+            }
+
             if (match(TokenType.TRUE)) {
                 return new LiteralExpression(new NativeElement<bool>(true));
             }

src/lib/Expressions/ExpressionTokenizer.vala

@@ -8,8 +8,12 @@ namespace Invercargill.Expressions {
     public enum TokenType {
         // Literals
         INTEGER,
+        LONG_INTEGER,       // integer with L suffix
+        UNSIGNED_LONG,      // integer with UL suffix
         FLOAT,
+        FLOAT_LITERAL,      // float with f suffix
         STRING,
+        CHAR_LITERAL,       // single character in single quotes
         TRUE,
         FALSE,
         NULL_LITERAL,
@@ -54,8 +58,12 @@ namespace Invercargill.Expressions {
         public string to_string() {
             switch (this) {
                 case INTEGER: return "INTEGER";
+                case LONG_INTEGER: return "LONG_INTEGER";
+                case UNSIGNED_LONG: return "UNSIGNED_LONG";
                 case FLOAT: return "FLOAT";
+                case FLOAT_LITERAL: return "FLOAT_LITERAL";
                 case STRING: return "STRING";
+                case CHAR_LITERAL: return "CHAR_LITERAL";
                 case TRUE: return "TRUE";
                 case FALSE: return "FALSE";
                 case NULL_LITERAL: return "NULL";
@@ -267,10 +275,13 @@ namespace Invercargill.Expressions {
                 return read_parameter();
             }
 
-            // String literals
-            if (c == '"' || c == '\'') {
+            // String literals (double quotes) or char literals (single quotes)
+            if (c == '"') {
                 return read_string(c);
             }
+            if (c == '\'') {
+                return read_char_literal();
+            }
 
             // Numbers
             if (c.isdigit()) {
@@ -322,6 +333,25 @@ namespace Invercargill.Expressions {
                         case '\\': sb.append("\\"); break;
                         case '"': sb.append("\""); break;
                         case '\'': sb.append("'"); break;
+                        case '%': sb.append("%"); break;
+                        case 'x':
+                            // Hex escape \xNN
+                            _position++;
+                            if (_position + 1 >= _length) {
+                                throw new ExpressionError.INVALID_SYNTAX(
+                                    @"Invalid hex escape at position $(_position)"
+                                );
+                            }
+                            string hex = _input.substring(_position, 2);
+                            if (!hex[0].isxdigit() || !hex[1].isxdigit()) {
+                                throw new ExpressionError.INVALID_SYNTAX(
+                                    @"Invalid hex escape '\\x$hex' at position $(_position)"
+                                );
+                            }
+                            int char_val = parse_hex(hex);
+                            sb.append_c((char)char_val);
+                            _position += 1; // Will be incremented again below
+                            break;
                         default:
                             throw new ExpressionError.INVALID_SYNTAX(
                                 @"Unknown escape sequence '\\$escaped' at position $(_position)"
@@ -339,7 +369,74 @@ namespace Invercargill.Expressions {
             );
         }
 
-        private Token read_number() {
+        private Token read_char_literal() throws ExpressionError {
+            int start_pos = _position;
+            _position++; // Skip opening quote
+
+            if (_position >= _length) {
+                throw new ExpressionError.INVALID_SYNTAX(
+                    @"Unterminated character literal at position $start_pos"
+                );
+            }
+
+            char c = _input[_position];
+            char char_value;
+
+            if (c == '\\') {
+                // Escape sequence
+                _position++;
+                if (_position >= _length) {
+                    throw new ExpressionError.INVALID_SYNTAX(
+                        @"Unterminated character literal at position $start_pos"
+                    );
+                }
+                char escaped = _input[_position];
+                switch (escaped) {
+                    case 'n': char_value = '\n'; break;
+                    case 't': char_value = '\t'; break;
+                    case 'r': char_value = '\r'; break;
+                    case '\\': char_value = '\\'; break;
+                    case '\'': char_value = '\''; break;
+                    case 'x':
+                        // Hex escape \xNN
+                        _position++;
+                        if (_position + 1 >= _length) {
+                            throw new ExpressionError.INVALID_SYNTAX(
+                                @"Invalid hex escape at position $(_position)"
+                            );
+                        }
+                        string hex = _input.substring(_position, 2);
+                        if (!hex[0].isxdigit() || !hex[1].isxdigit()) {
+                            throw new ExpressionError.INVALID_SYNTAX(
+                                @"Invalid hex escape '\\x$hex' at position $(_position)"
+                            );
+                        }
+                        char_value = (char)parse_hex(hex);
+                        _position++; // Extra increment for second hex digit
+                        break;
+                    default:
+                        throw new ExpressionError.INVALID_SYNTAX(
+                            @"Unknown escape sequence '\\$escaped' in character literal at position $(_position)"
+                        );
+                }
+            } else {
+                char_value = c;
+            }
+
+            _position++;
+
+            // Expect closing quote
+            if (_position >= _length || _input[_position] != '\'') {
+                throw new ExpressionError.INVALID_SYNTAX(
+                    @"Unterminated character literal starting at position $start_pos"
+                );
+            }
+            _position++; // Skip closing quote
+
+            return new Token(TokenType.CHAR_LITERAL, char_value.to_string(), start_pos);
+        }
+
+        private Token read_number() throws ExpressionError {
             int start_pos = _position;
             var sb = new StringBuilder();
             bool has_decimal = false;
@@ -367,6 +464,30 @@ namespace Invercargill.Expressions {
             }
 
             string value = sb.str;
+
+            // Check for type suffixes
+            if (_position < _length) {
+                char suffix = _input[_position].tolower();
+
+                // Check for 'ul' or 'UL' suffix (unsigned long)
+                if (suffix == 'u' && _position + 1 < _length && _input[_position + 1].tolower() == 'l') {
+                    _position += 2;
+                    return new Token(TokenType.UNSIGNED_LONG, value, start_pos);
+                }
+
+                // Check for 'l' suffix (long)
+                if (suffix == 'l') {
+                    _position++;
+                    return new Token(TokenType.LONG_INTEGER, value, start_pos);
+                }
+
+                // Check for 'f' suffix (float)
+                if (suffix == 'f') {
+                    _position++;
+                    return new Token(TokenType.FLOAT_LITERAL, value, start_pos);
+                }
+            }
+
             if (has_decimal) {
                 return new Token(TokenType.FLOAT, value, start_pos);
             } else {
@@ -421,6 +542,22 @@ namespace Invercargill.Expressions {
 
             return new Token(TokenType.PARAMETER, sb.str, start_pos);
         }
+
+        private static int parse_hex(string hex) {
+            int result = 0;
+            for (int i = 0; i < hex.length; i++) {
+                char c = hex[i];
+                result *= 16;
+                if (c >= '0' && c <= '9') {
+                    result += c - '0';
+                } else if (c >= 'a' && c <= 'f') {
+                    result += c - 'a' + 10;
+                } else if (c >= 'A' && c <= 'F') {
+                    result += c - 'A' + 10;
+                }
+            }
+            return result;
+        }
     }
 
 }

src/lib/Expressions/Expressions/LiteralExpression.vala

@@ -85,30 +85,132 @@ namespace Invercargill.Expressions {
                 return "null";
             }
 
-            // Try to format the value nicely
+            var type = value.type();
+
+            // Handle strings with proper escaping
             string? str_val;
             if (value.try_get_as(out str_val)) {
-                return @"\"$str_val\"";
+                return @"\"$(escape_string(str_val))\"";
+            }
+
+            // Handle Stringifyable interface
+            if (type.is_a(typeof(Stringifyable))) {
+                return @"\"$(escape_string(value.assert_as<Stringifyable>().to_string()))\"";
             }
 
-            bool? bool_val;
-            if (value.try_get_as(out bool_val)) {
-                return bool_val ? "true" : "false";
+            // Boolean
+            if (type == typeof(bool)) {
+                return value.assert_as<bool>() ? "true" : "false";
+            }
+
+            // Character types
+            if (type == typeof(char)) {
+                var c = value.assert_as<char>();
+                return @"'$(escape_char(c))'";
+            }
+            if (type == typeof(uchar)) {
+                var c = value.assert_as<uchar>();
+                return @"'$(escape_uchar(c))'";
             }
 
-            int? int_val;
-            if (value.try_get_as(out int_val)) {
-                return int_val.to_string();
+            // Integer types
+            if (type == typeof(int)) {
+                return value.assert_as<int>().to_string();
+            }
+            if (type == typeof(uint)) {
+                return value.assert_as<uint>().to_string();
+            }
+            if (type == typeof(long)) {
+                return value.assert_as<long>().to_string() + "L";
+            }
+            if (type == typeof(ulong)) {
+                return value.assert_as<ulong>().to_string() + "UL";
+            }
+            if (type == typeof(int64)) {
+                return value.assert_as<int64?>().to_string() + "L";
+            }
+            if (type == typeof(uint64)) {
+                return value.assert_as<uint64?>().to_string() + "UL";
             }
 
-            double? double_val;
-            if (value.try_get_as(out double_val)) {
-                return double_val.to_string();
+            // Floating point types
+            if (type == typeof(float)) {
+                return "%gf".printf(value.assert_as<float?>());
+            }
+            if (type == typeof(double)) {
+                return "%g".printf(value.assert_as<double?>());
             }
 
+            // Fallback to default to_string()
             return value.to_string();
         }
 
+        private static string escape_string(string str) {
+            var result = new StringBuilder();
+            for (int i = 0; i < str.length; i++) {
+                unichar c = str.get_char(i);
+                switch (c) {
+                    case '\n':
+                        result.append("\\n");
+                        break;
+                    case '\r':
+                        result.append("\\r");
+                        break;
+                    case '\t':
+                        result.append("\\t");
+                        break;
+                    case '\\':
+                        result.append("\\\\");
+                        break;
+                    case '"':
+                        result.append("\\\"");
+                        break;
+                    default:
+                        if (c < ' ' || c == 127) {
+                            // Non-printable ASCII as hex escape
+                            result.append_printf("\\x%02x", (uchar)c);
+                        } else {
+                            result.append_unichar(c);
+                        }
+                        break;
+                }
+            }
+            return result.str;
+        }
+
+        private static string escape_char(char c) {
+            switch (c) {
+                case '\n':
+                    return "\\n";
+                case '\r':
+                    return "\\r";
+                case '\t':
+                    return "\\t";
+                case '\\':
+                    return "\\\\";
+                case '\'':
+                    return "\\'";
+                default:
+                    if (c < ' ' || c == 127) {
+                        return "\\x%02x".printf((uchar)c);
+                    }
+                    return c.to_string();
+            }
+        }
+
+        private static string escape_uchar(uchar c) {
+            if (c < ' ' || c == 127) {
+                return "\\x%02x".printf(c);
+            }
+            if (c == '\\') {
+                return "\\\\";
+            }
+            if (c == '\'') {
+                return "\\'";
+            }
+            return ((char)c).to_string();
+        }
+
     }
 
 }

src/lib/Expressions/TypeAccessorRegistry.vala

@@ -2,6 +2,42 @@ using Invercargill.DataStructures;
 
 namespace Invercargill.Expressions {
 
+    /**
+     * Property accessor for NullElement that supports the is_null property.
+     */
+    internal class NullElementPropertyAccessor : Object, PropertyAccessor {
+        
+        private NullElement null_element;
+        
+        public NullElementPropertyAccessor(NullElement element) {
+            this.null_element = element;
+        }
+        
+        public bool has_property(string property) {
+            return property == "is_null";
+        }
+        
+        public Element read_property(string property) throws ExpressionError {
+            if (property == "is_null") {
+                return new NativeElement<bool>(true);
+            }
+            throw new ExpressionError.NON_EXISTANT_PROPERTY(@"NullElement does not have a property called '$property'.");
+        }
+        
+        public Enumerable<string> get_property_names() {
+            var names = new Series<string>();
+            names.add("is_null");
+            return names;
+        }
+        
+        public override Type get_property_type(string property) throws ExpressionError {
+            if (property == "is_null") {
+                return typeof(bool);
+            }
+            throw new ExpressionError.NON_EXISTANT_PROPERTY(@"NullElement does not have a property called '$property'.");
+        }
+    }
+
     /**
      * Registry for type-specific property and function accessors.
      * 
@@ -115,6 +151,11 @@ namespace Invercargill.Expressions {
                 return accessor;
             }
 
+            // Special handling for NullElement - supports is_null property
+            if (element is NullElement) {
+                return new NullElementPropertyAccessor((NullElement) element);
+            }
+
             // Fallback: Use ObjectPropertyAccessor for Objects
             Object? obj;
             if (element.try_get_as(out obj)) {
@@ -140,6 +181,28 @@ namespace Invercargill.Expressions {
                 return ((GlobalFunctionsElement) element).accessor;
             }
 
+            // SPECIAL HANDLING FOR ValueElement containing Enumerable
+            // Generic interface type checking (e.g., value_type.is_a(typeof(Enumerable)))
+            // doesn't work correctly for parameterized types in GObject, so we need
+            // to extract the object directly from the Value and check if it implements Enumerable.
+            // This must be done BEFORE the try_get_as calls below, as those can fail
+            // for interface types in certain scenarios.
+            if (element is ValueElement) {
+                var value_element = (ValueElement) element;
+                var value = value_element.get_value();
+                var value_type = value.type();
+                
+                // Check if the value holds an object (directly or via interface)
+                // For interface types, value_type.is_a(Type.OBJECT) returns false,
+                // but we can still extract the object using get_object()
+                if (value_type.is_a(Type.OBJECT) || value_type.is_interface()) {
+                    var obj = value.get_object();
+                    if (obj is Enumerable) {
+                        return new EnumerableFunctionAccessor(((Enumerable)obj).to_elements());
+                    }
+                }
+            }
+
             // Try registered factories
             foreach (var factory in _function_factories) {
                 var accessor = factory.create(element);
@@ -153,7 +216,7 @@ namespace Invercargill.Expressions {
             if (element.try_get_as(out accessor)) {
                 return accessor;
             }
-
+            
             // Fallback: Check for Elements (Enumerable wrapper)
             Elements? elements;
             if (element.try_get_as(out elements)) {

src/tests/Integration/NativeElement.vala

@@ -548,35 +548,6 @@ void native_element_tests() {
         assert_true(result.value == 42);
     });
 
-    // Note: assert_as<T>() with wrong type will critical and abort,
-    // so we don't test failure cases here as they would crash the test suite
-
-    // ============================================================================
-    // to_string() tests
-    // ============================================================================
-
-    Test.add_func("/invercargill/native_element/to_string/int", () => {
-        var elem = new NativeElement<int>(42);
-        var str = elem.to_string();
-        assert_true(str != null);
-        assert_true("NativeElement" in str);
-    });
-
-    Test.add_func("/invercargill/native_element/to_string/string", () => {
-        var elem = new NativeElement<string>("hello");
-        var str = elem.to_string();
-        assert_true(str != null);
-        assert_true("NativeElement" in str);
-    });
-
-    Test.add_func("/invercargill/native_element/to_string/object", () => {
-        var obj = new NativeElementTestObject(42);
-        var elem = new NativeElement<NativeElementTestObject>(obj);
-        var str = elem.to_string();
-        assert_true(str != null);
-        assert_true("NativeElement" in str);
-    });
-
     // ============================================================================
     // Nullability conversion tests (matching Nullable.vala tests)
     // ============================================================================

src/tests/TestRunner.vala

@@ -11,37 +11,37 @@ public static int main(string[] args) {
         }
     }
 
-    //  where_tests();
-    //  select_tests();
-    //  select_many_tests();
-    //  tracker_tests();
-    //  parallel_tests();
-    //  first_tests();
-    //  byte_composition_tests();
-    //  sort_tests();
-    //  vector_tests();
-    //  series_tests();
-    //  array_tests();
-    //  promotion_tests();
-    //  numbers_test();
-    //  dictionary_tests();
-    //  catalogue_tests();
-    //  property_mapper_tests();
-    //  cache_tests();
-    //  sorted_vector_tests();
-    //  sorted_series_tests();
-    //  order_by_tests();
-    //  set_tests();
-    //  fifo_tests();
-    //  lifo_tests();
-    //  priority_queue_tests();
-    //  enumerable_methods_tests();
-    //  modifiers_tests();
-    //  data_structures_tests();
-    //  remaining_components_tests();
+    where_tests();
+    select_tests();
+    select_many_tests();
+    tracker_tests();
+    parallel_tests();
+    first_tests();
+    byte_composition_tests();
+    sort_tests();
+    vector_tests();
+    series_tests();
+    array_tests();
+    promotion_tests();
+    numbers_test();
+    dictionary_tests();
+    catalogue_tests();
+    property_mapper_tests();
+    cache_tests();
+    sorted_vector_tests();
+    sorted_series_tests();
+    order_by_tests();
+    set_tests();
+    fifo_tests();
+    lifo_tests();
+    priority_queue_tests();
+    enumerable_methods_tests();
+    modifiers_tests();
+    data_structures_tests();
+    remaining_components_tests();
     expression_tests();
-    //  nullable_tests();
-    //  native_element_tests();
+    nullable_tests();
+    native_element_tests();
 
     var result = Test.run();