diff --git a/src/parser/lex.rs b/src/parser/lex.rs
index 620bbd7cd2..caa07fc87a 100644
--- a/src/parser/lex.rs
+++ b/src/parser/lex.rs
@@ -41,6 +41,9 @@ pub enum Error {
     #[error("invalid escape character: \\{}", .ch.unwrap_or_default())]
     EscapeChar { start: usize, ch: Option<char> },
 
+    #[error("invalid unicode escape sequence")]
+    UnicodeEscape { start: usize, end: usize },
+
     #[error("unexpected parse error")]
     UnexpectedParseError(String),
 }
@@ -49,7 +52,7 @@ impl DiagnosticMessage for Error {
     fn code(&self) -> usize {
         use Error::{
             EscapeChar, Literal, NumericLiteral, ParseError, ReservedKeyword, StringLiteral,
-            UnexpectedParseError,
+            UnexpectedParseError, UnicodeEscape,
         };
 
         match self {
@@ -66,13 +69,14 @@ impl DiagnosticMessage for Error {
             Literal { .. } => 208,
             EscapeChar { .. } => 209,
             UnexpectedParseError(..) => 210,
+            UnicodeEscape { .. } => 211,
         }
     }
 
     fn labels(&self) -> Vec<Label> {
         use Error::{
             EscapeChar, Literal, NumericLiteral, ParseError, ReservedKeyword, StringLiteral,
-            UnexpectedParseError,
+            UnexpectedParseError, UnicodeEscape,
         };
 
         fn update_expected(expected: Vec<String>) -> Vec<String> {
@@ -190,6 +194,11 @@ impl DiagnosticMessage for Error {
             )],
 
             UnexpectedParseError(string) => vec![Label::primary(string, Span::default())],
+
+            UnicodeEscape { start, end } => vec![Label::primary(
+                "invalid unicode escape sequence",
+                Span::new(*start, *end),
+            )],
         }
     }
 }
@@ -1224,6 +1233,7 @@ impl<'input> Lexer<'input> {
     fn escape_code(&mut self, start: usize) -> Result<(), Error> {
         match self.bump() {
             Some((_, '\n' | '\'' | '"' | '\\' | 'n' | 'r' | 't' | '{' | '}' | '0')) => Ok(()),
+            Some((_, 'u')) => self.unicode_escape(start),
             Some((start, ch)) => Err(Error::EscapeChar {
                 start,
                 ch: Some(ch),
@@ -1231,6 +1241,54 @@ impl<'input> Lexer<'input> {
             None => Err(Error::EscapeChar { start, ch: None }),
         }
     }
+
+    /// Validates a `\u{HEX}` Unicode escape sequence after the `u` has been consumed.
+    ///
+    /// `start` is the byte position of the leading `\`. All `UnicodeEscape` errors
+    /// span from `start` to the current position so the entire `\u{...}` sequence
+    /// is highlighted in diagnostics.
+    fn unicode_escape(&mut self, start: usize) -> Result<(), Error> {
+        match self.bump() {
+            Some((_, '{')) => {}
+            Some((s, ch)) => {
+                return Err(Error::EscapeChar {
+                    start: s,
+                    ch: Some(ch),
+                });
+            }
+            None => return Err(Error::EscapeChar { start, ch: None }),
+        }
+        let hex_start = self.next_index();
+        let mut count = 0usize;
+        loop {
+            match self.peek() {
+                Some((_, '}')) => {
+                    let hex_end = self.next_index();
+                    self.bump();
+                    let end = self.next_index();
+                    if count == 0 {
+                        return Err(Error::UnicodeEscape { start, end });
+                    }
+                    let hex = &self.input[hex_start..hex_end];
+                    let codepoint = u32::from_str_radix(hex, 16)
+                        .map_err(|_| Error::UnicodeEscape { start, end })?;
+                    char::from_u32(codepoint).ok_or(Error::UnicodeEscape { start, end })?;
+                    return Ok(());
+                }
+                Some((_, ch)) if ch.is_ascii_hexdigit() => {
+                    self.bump();
+                    count += 1;
+                }
+                Some((pos, ch)) => {
+                    return Err(Error::EscapeChar {
+                        start: pos,
+                        ch: Some(ch),
+                    });
+                }
+                None => return Err(Error::EscapeChar { start, ch: None }),
+            }
+        }
+    }
 }
 
 // -----------------------------------------------------------------------------
@@ -1269,7 +1327,14 @@ pub(crate) fn is_operator(ch: char) -> bool {
 fn unescape_string_literal(mut s: &str) -> String {
     let mut string = String::with_capacity(s.len());
     while let Some(i) = s.bytes().position(|b| b == b'\\') {
-        let next = s.as_bytes()[i + 1];
+        // The lexer never emits a literal ending in a lone backslash (it would
+        // have escaped the closing quote), so there is always an escape
+        // character here. Treat a trailing backslash as literal text rather
+        // than indexing out of bounds if that ever stops holding.
+        let Some(&next) = s.as_bytes().get(i + 1) else {
+            debug_assert!(false, "string literal ended with a lone backslash");
+            break;
+        };
         if next == b'\n' {
             // Remove the \n and any ensuing spaces or tabs
             string.push_str(&s[..i]);
@@ -1280,22 +1345,59 @@ fn unescape_string_literal(mut s: &str) -> String {
                 .map(char::len_utf8)
                 .sum();
             s = &s[i + whitespace + 2..];
+        } else if next == b'u' {
+            // `\u{HEX}`: the lexer has already validated the syntax and that the
+            // codepoint is a legal `char`, so every step below is expected to
+            // succeed. It is nonetheless written to degrade gracefully rather
+            // than abort the process, because `template()` rewrites literal
+            // content before it reaches this function — the invariant spans two
+            // distant pieces of code, and a future edit there must not become a
+            // crash here.
+            let decoded = s.get(i + 3..).and_then(|rest| {
+                // skipped past `\u{`
+                let close = rest.find('}')?;
+                let codepoint = u32::from_str_radix(&rest[..close], 16).ok()?;
+                let ch = char::from_u32(codepoint)?;
+                Some((ch, &rest[close + 1..]))
+            });
+
+            if let Some((ch, remainder)) = decoded {
+                string.push_str(&s[..i]);
+                string.push(ch);
+                s = remainder;
+            } else {
+                debug_assert!(false, "lexer should have validated this \\u{{..}} escape");
+                // Keep the backslash as literal text and resume just after it,
+                // so the loop always makes progress.
+                string.push_str(&s[..=i]);
+                s = &s[i + 1..];
+            }
         } else {
-            let c = match next {
-                b'\'' => '\'',
-                b'"' => '"',
-                b'\\' => '\\',
-                b'n' => '\n',
-                b'r' => '\r',
-                b't' => '\t',
-                b'0' => '\0',
-                b'{' => '{',
-                _ => unimplemented!("invalid escape"),
+            let unescaped = match next {
+                b'\'' => Some('\''),
+                b'"' => Some('"'),
+                b'\\' => Some('\\'),
+                b'n' => Some('\n'),
+                b'r' => Some('\r'),
+                b't' => Some('\t'),
+                b'0' => Some('\0'),
+                b'{' => Some('{'),
+                b'}' => Some('}'),
+                _ => None,
             };
 
-            string.push_str(&s[..i]);
-            string.push(c);
-            s = &s[i + 2..];
+            if let Some(c) = unescaped {
+                string.push_str(&s[..i]);
+                string.push(c);
+                s = &s[i + 2..];
+            } else {
+                debug_assert!(false, "lexer should have rejected this escape");
+                // Unknown escape. Emit the backslash literally and resume after
+                // it rather than guessing at the intended character (`next` may
+                // be one byte of a multi-byte character).
+                string.push_str(&s[..=i]);
+                s = &s[i + 1..];
+            }
         }
     }
 
@@ -2146,6 +2248,112 @@ mod test {
         );
     }
 
+    // OBE-10734: \} must unescape to } rather than hitting unimplemented!()
+    #[test]
+    fn escaped_close_brace_unescapes_cleanly() {
+        let token = StringLiteralToken("\\}");
+        assert_eq!(token.unescape(), "}");
+    }
+
+    #[test]
+    fn escaped_close_brace_in_string_literal() {
+        let token = StringLiteralToken("hello\\}world");
+        assert_eq!(token.unescape(), "hello}world");
+    }
+
+    // OBE-10734 (upstream sync): \u{HEX} unicode escape support
+    #[test]
+    fn unicode_escape_basic() {
+        let token = StringLiteralToken("\\u{41}");
+        assert_eq!(token.unescape(), "A");
+    }
+
+    #[test]
+    fn unicode_escape_multibyte() {
+        // U+1F600 GRINNING FACE
+        let token = StringLiteralToken("\\u{1F600}");
+        assert_eq!(token.unescape(), "\u{1F600}");
+    }
+
+    #[test]
+    fn unicode_escape_in_string() {
+        let token = StringLiteralToken("hello\\u{20}world");
+        assert_eq!(token.unescape(), "hello world");
+    }
+
+    #[test]
+    fn unicode_escape_null() {
+        let token = StringLiteralToken("\\u{0}");
+        assert_eq!(token.unescape(), "\0");
+    }
+
+    #[test]
+    fn unicode_escape_invalid_codepoint_rejected_by_lexer() {
+        // D800 is a surrogate — escape_code/unicode_escape returns Err so the
+        // string never reaches unescape_string_literal. Verify via tokenization.
+        let src = r#""hello\u{D800}world""#;
+        let mut lexer = Lexer::new(src);
+        let tokens: Vec<_> = lexer.by_ref().collect();
+        assert!(
+            tokens.iter().any(|t| t.is_err()),
+            "expected a lex error for surrogate codepoint"
+        );
+    }
+
+    #[test]
+    fn unicode_escape_empty_braces_rejected_by_lexer() {
+        let src = r#""\u{}""#;
+        let mut lexer = Lexer::new(src);
+        let tokens: Vec<_> = lexer.by_ref().collect();
+        assert!(
+            tokens.iter().any(|t| t.is_err()),
+            "expected a lex error for empty unicode escape"
+        );
+    }
+
+    #[test]
+    fn unicode_escape_missing_open_brace_rejected_by_lexer() {
+        let src = r#""\u41""#;
+        let mut lexer = Lexer::new(src);
+        let tokens: Vec<_> = lexer.by_ref().collect();
+        assert!(
+            tokens.iter().any(|t| t.is_err()),
+            "expected a lex error for missing open brace in unicode escape"
+        );
+    }
+
+    // The other positive `\u{..}` tests construct a `StringLiteralToken` by hand,
+    // which skips the lexer. `unescape_string_literal` assumes the lexer already
+    // validated the escape, so lock in that the two really do agree by driving a
+    // literal through tokenization and *then* unescaping the resulting token.
+    #[test]
+    fn unicode_escape_tokenizes_and_unescapes_end_to_end() {
+        for (src, want) in [
+            (r#""\u{41}""#, "A"),
+            (r#""\u{1F600}""#, "\u{1F600}"),
+            (r#""a\u{20}b\u{9}c""#, "a b\tc"),
+            (r#""\u{10FFFF}""#, "\u{10FFFF}"), // highest legal codepoint
+            (r#""\u{000041}""#, "A"),          // leading zeros
+        ] {
+            let tokens: Vec<_> = Lexer::new(src).collect();
+            assert!(
+                tokens.iter().all(|t| t.is_ok()),
+                "{src} should tokenize cleanly, got {tokens:?}"
+            );
+
+            let literal = tokens
+                .into_iter()
+                .filter_map(|t| match t {
+                    Ok((_, Token::StringLiteral(literal), _)) => Some(literal),
+                    _ => None,
+                })
+                .next()
+                .unwrap_or_else(|| panic!("{src} should produce a string literal token"));
+
+            assert_eq!(literal.unescape(), want, "unescaping {src}");
+        }
+    }
+
     #[test]
     fn function_closure_no_arg() {
         test(
diff --git a/src/parsing/xml.rs b/src/parsing/xml.rs
index 1bbfd1dc15..4c93888e56 100644
--- a/src/parsing/xml.rs
+++ b/src/parsing/xml.rs
@@ -175,9 +175,14 @@ fn process_node(node: Node, config: &ParseXmlConfig) -> Value {
                             );
 
                             Value::Object(map)
-                        } else {
-                            // Otherwise, 'flatten' the object by continuing processing.
+                        } else if node.is_text() {
+                            // 'Flatten' the object by continuing processing.
                             process_node(node, config)
+                        } else {
+                            // Comment or PI as the sole child — return empty object
+                            // rather than forwarding into process_node where it would
+                            // hit an unreachable arm.
+                            Value::Object(BTreeMap::new())
                         }
                     }
                     // For 2+ nodes, expand.
@@ -186,7 +191,9 @@ fn process_node(node: Node, config: &ParseXmlConfig) -> Value {
             }
         }
         NodeType::Text => process_text(node.text().expect("expected XML text node"), config),
-        _ => unreachable!("shouldn't be other XML nodes"),
+        // Comment and PI nodes are skipped by the multi-child filter; reaching here
+        // means a caller forwarded one directly. Return empty object rather than panic.
+        NodeType::Comment | NodeType::PI => Value::Object(BTreeMap::new()),
     }
 }
 
diff --git a/src/stdlib/decrypt.rs b/src/stdlib/decrypt.rs
index 19d696e5d7..82adbe100c 100644
--- a/src/stdlib/decrypt.rs
+++ b/src/stdlib/decrypt.rs
@@ -59,7 +59,7 @@ macro_rules! decrypt_stream {
     ($algorithm:ty, $plaintext:expr, $key:expr, $iv:expr) => {{
         <$algorithm>::new(&GenericArray::from(get_key_bytes($key)?))
             .decrypt(&GenericArray::from(get_iv_bytes($iv)?), $plaintext.as_ref())
-            .expect("key/iv sizes were already checked")
+            .map_err(|_| "decryption failed (authentication tag mismatch)")?
     }};
 }
 
@@ -383,5 +383,36 @@ mod tests {
             want: Ok(value!("morethan1blockofdata")),
             tdef: TypeDef::bytes().fallible(),
         }
+
+        // OBE-10720: bad AEAD ciphertext must return a VRL error, not panic
+        chacha20_poly1305_bad_tag {
+            args: func_args![ciphertext: value!(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), algorithm: "CHACHA20-POLY1305", key: "32_bytes_xxxxxxxxxxxxxxxxxxxxxxx", iv: "12_bytes_xxx"],
+            want: Err("decryption failed (authentication tag mismatch)"),
+            tdef: TypeDef::bytes().fallible(),
+        }
+
+        xchacha20_poly1305_bad_tag {
+            args: func_args![ciphertext: value!(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), algorithm: "XCHACHA20-POLY1305", key: "32_bytes_xxxxxxxxxxxxxxxxxxxxxxx", iv: "24_bytes_xxxxxxxxxxxxxxx"],
+            want: Err("decryption failed (authentication tag mismatch)"),
+            tdef: TypeDef::bytes().fallible(),
+        }
+
+        xsalsa20_poly1305_bad_tag {
+            args: func_args![ciphertext: value!(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), algorithm: "XSALSA20-POLY1305", key: "32_bytes_xxxxxxxxxxxxxxxxxxxxxxx", iv: "24_bytes_xxxxxxxxxxxxxxx"],
+            want: Err("decryption failed (authentication tag mismatch)"),
+            tdef: TypeDef::bytes().fallible(),
+        }
+
+        aes_128_siv_bad_tag {
+            args: func_args![ciphertext: value!(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), algorithm: "AES-128-SIV", key: "32_bytes_xxxxxxxxxxxxxxxxxxxxxxx", iv: "16_bytes_xxxxxxx"],
+            want: Err("decryption failed (authentication tag mismatch)"),
+            tdef: TypeDef::bytes().fallible(),
+        }
+
+        aes_256_siv_bad_tag {
+            args: func_args![ciphertext: value!(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), algorithm: "AES-256-SIV", key: "64_bytes_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", iv: "16_bytes_xxxxxxx"],
+            want: Err("decryption failed (authentication tag mismatch)"),
+            tdef: TypeDef::bytes().fallible(),
+        }
     ];
 }
diff --git a/src/stdlib/match_any.rs b/src/stdlib/match_any.rs
index 4dbb76cd62..d83081166c 100644
--- a/src/stdlib/match_any.rs
+++ b/src/stdlib/match_any.rs
@@ -68,7 +68,10 @@ impl Function for MatchAny {
             re_strings.push(re.to_string());
         }
 
-        let regex_set = RegexSet::new(re_strings).expect("regex were already valid");
+        let regex_set = RegexSet::new(re_strings).map_err(|e| {
+            Box::new(ExpressionError::from(format!("could not compile regex set: {e}")))
+                as Box<dyn DiagnosticMessage>
+        })?;
 
         Ok(MatchAnyFn { value, regex_set }.as_expr())
     }
@@ -122,4 +125,50 @@ mod tests {
             tdef: TypeDef::boolean().infallible(),
         }
     ];
+
+    // OBE-10725: `RegexSet::new` fails when the *combined* compiled size of the
+    // patterns exceeds the regex crate's size limit. That used to be an
+    // `expect`, aborting the process at compile time; it must now surface as a
+    // recoverable compilation error.
+    //
+    // Each pattern below compiles fine on its own — only the union is over the
+    // limit — so this exercises exactly the path that no other test reaches.
+    #[test]
+    fn oversized_regex_set_fails_to_compile_without_panicking() {
+        let pattern_a = "x0(?:[a-z]{100000})";
+        let pattern_b = "x1(?:[a-z]{100000})";
+
+        // Precondition: individually valid. If a future regex version changes its
+        // limits this asserts loudly rather than silently voiding the test.
+        let regex_a = Regex::new(pattern_a).expect("pattern A must compile alone");
+        let regex_b = Regex::new(pattern_b).expect("pattern B must compile alone");
+        assert!(
+            regex::bytes::RegexSet::new([pattern_a, pattern_b]).is_err(),
+            "precondition: the combined set must exceed the regex size limit"
+        );
+
+        let state = state::TypeState::default();
+        let mut ctx = FunctionCompileContext::new(
+            crate::diagnostic::Span::new(0, 0),
+            crate::compiler::CompileConfig::default(),
+        );
+        let args = func_args![
+            value: "irrelevant",
+            patterns: Value::Array(vec![
+                Value::Regex(regex_a.into()),
+                Value::Regex(regex_b.into()),
+            ])
+        ];
+
+        let error = MatchAny
+            .compile(&state, &mut ctx, args.into())
+            .err()
+            .expect("an oversized regex set must fail to compile");
+
+        let message = error.message();
+        assert!(
+            message.contains("could not compile regex set"),
+            "expected a regex-set compilation error, got: {message}"
+        );
+    }
 }
diff --git a/src/stdlib/parse_xml.rs b/src/stdlib/parse_xml.rs
index 4fac4980ff..dbf0a2278a 100644
--- a/src/stdlib/parse_xml.rs
+++ b/src/stdlib/parse_xml.rs
@@ -479,6 +479,27 @@ mod tests {
             want: Ok(value!({ "root": { "a": { "a1": "test" }, "b" : "test2" } })),
             tdef: type_def(),
         }
+
+        // OBE-10731: element whose sole child is a Comment must not panic
+        comment_only_child {
+            args: func_args![value: "<a><!--x--></a>"],
+            want: Ok(value!({ "a": {} })),
+            tdef: type_def(),
+        }
+
+        // OBE-10731: element whose sole child is a PI must not panic
+        pi_only_child {
+            args: func_args![value: "<a><?pi?></a>"],
+            want: Ok(value!({ "a": {} })),
+            tdef: type_def(),
+        }
+
+        // OBE-10731: nested element whose sole child is a comment must not panic
+        nested_comment_only_child {
+            args: func_args![value: "<r><inner><!--boom--></inner></r>"],
+            want: Ok(value!({ "r": { "inner": {} } })),
+            tdef: type_def(),
+        }
     ];
 
     #[test]
diff --git a/src/stdlib/random_float.rs b/src/stdlib/random_float.rs
index 3b80ec1279..27ee9eb0e7 100644
--- a/src/stdlib/random_float.rs
+++ b/src/stdlib/random_float.rs
@@ -8,22 +8,34 @@ fn random_float(min: Value, max: Value) -> Resolved {
     let min = min.try_float()?;
     let max = max.try_float()?;
 
+    if !min.is_finite() || !max.is_finite() {
+        return Err("min and max must be finite".into());
+    }
     if max <= min {
         return Err("max must be greater than min".into());
     }
+    if !(max - min).is_finite() {
+        return Err("range max - min overflows".into());
+    }
 
     let f: f64 = thread_rng().gen_range(min..max);
 
-    Ok(Value::Float(NotNan::new(f).expect("always a number")))
+    Ok(Value::from_f64_or_zero(f))
 }
 
 fn get_range(min: Value, max: Value) -> std::result::Result<Range<f64>, &'static str> {
     let min = min.try_float().expect("min must be a float");
     let max = max.try_float().expect("max must be a float");
 
+    if !min.is_finite() || !max.is_finite() {
+        return Err("min and max must be finite");
+    }
     if max <= min {
         return Err(INVALID_RANGE_ERR);
     }
+    if !(max - min).is_finite() {
+        return Err("range max - min overflows");
+    }
 
     Ok(min..max)
 }
@@ -130,5 +142,60 @@ mod tests {
             want: Err("invalid argument"),
             tdef: TypeDef::float().fallible(),
         }
+
+        // OBE-10730: constant infinite bounds must now be caught at compile time (type_def fallible).
+        infinite_max_compile_time {
+            args: func_args![min: value!(0.0), max: Value::Float(NotNan::new(f64::INFINITY).unwrap())],
+            want: Err("invalid argument"),
+            tdef: TypeDef::float().fallible(),
+        }
+
+        overflow_range_compile_time {
+            args: func_args![min: Value::Float(NotNan::new(-1.0e308).unwrap()), max: Value::Float(NotNan::new(1.0e308).unwrap())],
+            want: Err("invalid argument"),
+            tdef: TypeDef::float().fallible(),
+        }
     ];
+
+    // Positive: valid finite bounds succeed and produce a value in [min, max).
+    #[test]
+    fn valid_finite_range_returns_ok_in_range() {
+        let min = Value::Float(NotNan::new(0.0).unwrap());
+        let max = Value::Float(NotNan::new(10.0).unwrap());
+        let result = random_float(min, max).expect("should succeed");
+        let f = match result {
+            Value::Float(v) => *v,
+            _ => panic!("expected float"),
+        };
+        assert!(f >= 0.0 && f < 10.0, "result {f} out of [0, 10)");
+    }
+
+    // OBE-10730: non-finite bounds and range-overflow must return errors, not panic.
+    #[test]
+    fn non_finite_min_returns_error() {
+        let min = Value::Float(NotNan::new(f64::INFINITY).unwrap());
+        let max = Value::Float(NotNan::new(1.0).unwrap());
+        assert!(random_float(min, max).is_err());
+    }
+
+    #[test]
+    fn non_finite_max_returns_error() {
+        let min = Value::Float(NotNan::new(0.0).unwrap());
+        let max = Value::Float(NotNan::new(f64::INFINITY).unwrap());
+        assert!(random_float(min, max).is_err());
+    }
+
+    #[test]
+    fn negative_infinity_returns_error() {
+        let min = Value::Float(NotNan::new(f64::NEG_INFINITY).unwrap());
+        let max = Value::Float(NotNan::new(0.0).unwrap());
+        assert!(random_float(min, max).is_err());
+    }
+
+    #[test]
+    fn range_overflow_returns_error() {
+        let min = Value::Float(NotNan::new(-1.0e308).unwrap());
+        let max = Value::Float(NotNan::new(1.0e308).unwrap());
+        assert!(random_float(min, max).is_err());
+    }
 }