Welp, just musing, but the general question of generating random inputs that match a regex sounds doable to me for a sufficiently relaxed definition of random and a sufficiently tight definition of regex. I’m thinking of the classical formal definition, which allows only ()|* and alphabet characters.
Regular expressions can be mapped to formal machines called finite automata. Such a machine is a directed graph with a particular node called the final state, a node called the initial state, and a letter from the alphabet on each edge. A word is accepted by the regex if it’s possible to start at the initial state and traverse one edge labeled with each character through the graph and end at the final state.
One could build the graph, then start at the final state and traverse random edges backwards, keeping track of the path. In a standard construction, every node in the graph is reachable from the initial state, so you do not need to worry about making irrecoverable mistakes and needing to backtrack. If you reach the initial state, stop, and read off the path going forward. That’s your match for the regex.
There’s no particular guarantee about when or if you’ll reach the initial state, though. One would have to figure out in what sense the generated strings are ‘random’, and in what sense you are hoping for a random element from the language in the first place.
Maybe that’s a starting point for thinking about the problem, though!
Now that I’ve written that out, it seems to me that it might be simpler to repeatedly resolve choices to simplify the regex pattern until you’re left with a simple string. Find the first non-alphabet character in the pattern. If it’s a *, replicate the preceding item some number of times and remove the *. If it’s a |, choose which of the OR’d items to preserve and remove the rest. For a left paren, do the same, but looking at the character following the matching right paren. This is probably easier if you parse the regex into a tree representation first that makes the paren grouping structure easier to work with.
To the person who worried that deciding if a regex actually matches anything is equivalent to the halting problem: Nope, regular languages are quite well behaved. You can tell if any two regexes describe the same set of accepted strings. You basically make the machine above, then follow an algorithm to produce a canonical minimal equivalent machine. Do that for two regexes, then check if the resulting minimal machines are equivalent, which is straightforward.