java - utilizar - Usar Regex para generar cadenas en lugar de combinarlas

expresiones regulares java

Question

Estoy escribiendo una utilidad Java que me ayuda a generar gran cantidad de datos para las pruebas de rendimiento. Sería genial poder especificar una expresión regular para cadenas para que mi generador escupe cosas que coincidan con esto. ¿Hay algo allí ya horneado que pueda usar para hacer esto? ¿O hay una biblioteca que me lleva la mayor parte del camino hasta allí?

Gracias

Answer 1

En stackoverflow podcast 11:

Spolsky: Sí. También hay un nuevo producto, si no quieres usar el Team System, nuestros amigos de Redgate tienen un producto llamado SQL Data Generator [ http://www.red-gate.com/products/sql_data_generator/index.htm] . Son $ 295, y solo genera algunos datos de prueba realistas. Y hace cosas como generar realmente ciudades reales en la columna de la ciudad que realmente existen, y luego, cuando las genera, hará que el estado sea correcto, en lugar de equivocar al estado, o colocar estados en ciudades alemanas y cosas como ... ya sabes, genera datos de aspecto bastante realista. No estoy seguro de cuáles son todas las características.

Probablemente no sea lo que está buscando, pero podría ser un buen punto de partida, en lugar de crear uno propio.

Parece que no puedo encontrar nada en google, por lo que sugiero abordar el problema mediante el análisis de una expresión regular dada en las unidades de trabajo más pequeñas (/ w, [xx], / d, etc.) y escribir algunos métodos básicos para apoyar esas frases de expresiones regulares.

Entonces, para / w tendría un método getRandomLetter () que devuelve cualquier letra al azar, y también tendría getRandomLetter (char startLetter, char endLetter) que le da una letra aleatoria entre los dos valores.

Answer 2

Es demasiado tarde para ayudar al póster original, pero podría ayudar a un recién llegado. Generex es una biblioteca de Java útil que proporciona muchas funciones para usar expresiones regulares para generar cadenas (generación aleatoria, generación de una cadena basada en su índice, generación de todas las cadenas ...).

Ejemplo:

Generex generex = new Generex("[0-3]([a-c]|[e-g]{1,2})");

// generate the second String in lexicographical order that matches the given Regex.
String secondString = generex.getMatchedString(2);
System.out.println(secondString);// it print ''0b''

// Generate all String that matches the given Regex.
List<String> matchedStrs = generex.getAllMatchedStrings();

// Using Generex iterator
Iterator iterator = generex.iterator();
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}
// it prints 0a 0b 0c 0e 0ee 0e 0e 0f 0fe 0f 0f 0g 0ge 0g 0g 1a 1b 1c 1e
// 1ee 1e 1e 1f 1fe 1f 1f 1g 1ge 1g 1g 2a 2b 2c 2e 2ee 2e 2e 2f 2fe 2f 2f 2g
// 2ge 2g 2g 3a 3b 3c 3e 3ee 3e 3e 3f 3fe 3f 3f 3g 3ge 3g 3g 1ee

// Generate random String
String randomStr = generex.random();
System.out.println(randomStr);// a random value from the previous String list

Answer 3

Está lejos de soportar una expresión regular PCRE completa, pero escribí el siguiente método de Ruby para tomar una cadena tipo expresión regular y producir una variación en ella. (Para CAPTCHA basado en lenguaje.)

# q = "(How (much|many)|What) is (the (value|result) of)? :num1 :op :num2?"
# values = { :num1=>42, :op=>"plus", :num2=>17 }
# 4.times{ puts q.variation( values ) }
# => What is 42 plus 17?
# => How many is the result of 42 plus 17?
# => What is the result of 42 plus 17?
# => How much is the value of 42 plus 17?
class String
  def variation( values={} )
    out = self.dup
    while out.gsub!( //(([^())?]+)/)(/?)?/ ){
      ( $2 && ( rand > 0.5 ) ) ? '''' : $1.split( ''|'' ).random
    }; end
    out.gsub!( /:(#{values.keys.join(''|'')})/b/ ){ values[$1.intern] }
    out.gsub!( //s{2,}/, '' '' )
    out
  end
end

class Array
  def random
    self[ rand( self.length ) ]
  end
end

Answer 4

Esta pregunta es muy antigua, pero me topé con ella en mi propia búsqueda, por lo que incluiré un par de enlaces para otras personas que podrían estar buscando la misma funcionalidad en otros idiomas.

• Hay una biblioteca Node.js aquí: https://github.com/fent/randexp.js
• Hay una biblioteca PHP aquí: https://github.com/icomefromthenet/ReverseRegex
• El paquete PHP faker incluye un método de "regexificar" que logra esto: https://packagist.org/packages/fzaninotto/faker

Answer 5

Estoy en vuelo y acabo de ver la pregunta: he escrito la solución más fácil pero ineficiente e incompleta. Espero que te ayude a comenzar a escribir tu propio analizador:

public static void main(String[] args) {

    String line = "[A-Z0-9]{16}";
    String[] tokens = line.split(line);
    char[] pattern = new char[100];
    int i = 0;
    int len = tokens.length;
    String sep1 = "[{";
    StringTokenizer st = new StringTokenizer(line, sep1);

    while (st.hasMoreTokens()) {
        String token = st.nextToken();
        System.out.println(token);

        if (token.contains("]")) {
            char[] endStr = null;

            if (!token.endsWith("]")) {
                String[] subTokens = token.split("]");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            if (token.startsWith("^")) {
                String subStr = token.substring(1, token.length() - 1);
                char[] subChar = subStr.toCharArray();
                Set set = new HashSet<Character>();

                for (int p = 0; p < subChar.length; p++) {
                    set.add(subChar[p]);
                }

                int asci = 1;

                while (true) {
                    char newChar = (char) (subChar[0] + (asci++));

                    if (!set.contains(newChar)) {
                        pattern[i++] = newChar;
                        break;
                    }
                }
                if (endStr != null) {
                    for (int r = 0; r < endStr.length; r++) {
                        pattern[i++] = endStr[r];
                    }
                }

            } else {
                pattern[i++] = token.charAt(0);
            }
        } else if (token.contains("}")) {
            char[] endStr = null;

            if (!token.endsWith("}")) {
                String[] subTokens = token.split("}");
                token = subTokens[0];

                if (!subTokens[1].equalsIgnoreCase("*")) {
                    endStr = subTokens[1].toCharArray();
                }
            }

            int length = Integer.parseInt((new StringTokenizer(token, (",}"))).nextToken());
            char element = pattern[i - 1];

            for (int j = 0; j < length - 1; j++) {
                pattern[i++] = element;
            }

            if (endStr != null) {
                for (int r = 0; r < endStr.length; r++) {
                    pattern[i++] = endStr[r];
                }
            }
        } else {
            char[] temp = token.toCharArray();

            for (int q = 0; q < temp.length; q++) {
                pattern[i++] = temp[q];
            }
        }
    }

    String result = "";

    for (int j = 0; j < i; j++) {
        result += pattern[j];
    }

    System.out.print(result);
}

Answer 6

He ido a la raíz de rodar mi own biblioteca para eso (In c # pero debería ser fácil de entender para un desarrollador de Java).

Rxrdg comenzó como una solución a un problema de creación de datos de prueba para un proyecto de la vida real. La idea básica es aprovechar los patrones de validación existentes (expresiones regulares) para crear datos aleatorios que se ajusten a dichos patrones. De esta manera, se crean datos aleatorios válidos.

No es tan difícil escribir un analizador sintáctico para patrones de expresiones regulares simples. Usar un árbol de sintaxis abstracta para generar cadenas debería ser aún más fácil.

Answer 7

Sé que ya hay una respuesta aceptada, pero he estado utilizando el generador de datos de RedGate (el mencionado en la respuesta de Craig) y funciona REALMENTE bien para todo lo que le he echado. Es rápido y eso me deja con ganas de usar la misma expresión regular para generar datos reales para cosas como códigos de registro que esta cosa escupe.

Se necesita una expresión regular como:

[A-Z0-9]{3,3}-[A-Z0-9]{3,3}

y genera toneladas de códigos únicos como:

LLK-32U

¿Es este un gran algoritmo secreto que RedGate descubrió y todos estamos sin suerte o es algo que los simples mortales en realidad podríamos hacer?

Answer 8

Si desea generar cadenas "críticas", es posible que desee considerar:

EGRET http://elarson.pythonanywhere.com/ que genera cadenas "malvadas" que cubren sus expresiones regulares

MUTREX http://cs.unibg.it/mutrex/ que genera cadenas de detección de fallas mediante mutación regex

Ambas son herramientas académicas (soy uno de los autores de este último) y funcionan razonablemente bien.

Answer 9

Tendrás que escribir tu propio analizador, como lo hizo el autor de String :: Random (Perl). De hecho, él no usa expresiones regulares en ningún lado en ese módulo, es justo a lo que los perl-codificadores están acostumbrados.

Por otro lado, tal vez puedas echar un vistazo a la fuente para obtener algunos consejos.

EDITAR: Maldición, Blair me ganó el golpe por 15 segundos.

Answer 10

Visual Studio Team System incluye algo como esto. Echale un vistazo

Sin embargo, no es mucha ayuda para Java, lo siento mucho.

Answer 11

Xeger (Java) es capaz de hacerlo también:

String regex = "[ab]{4,6}c";
Xeger generator = new Xeger(regex);
String result = generator.generate();
assert result.matches(regex);

Answer 12

Editar:

Como se mencionó en los comentarios, hay una biblioteca disponible en Google Code para lograr esto: http://code.google.com/p/xeger

Ver también https://github.com/mifmif/Generex como lo sugiere Mifmif

Mensaje original:

En primer lugar, con una expresión regular lo suficientemente compleja, creo que esto puede ser imposible. Pero deberías ser capaz de armar algo para expresiones regulares simples.

Si echas un vistazo al código fuente de la clase java.util.regex.Pattern, verás que usa una representación interna de las instancias de Node. Cada uno de los diferentes componentes del patrón tiene su propia implementación de una subclase Nodo. Estos Nodos están organizados en un árbol.

Al producir un visitante que atraviesa este árbol, debería poder invocar un método de generador sobrecargado o algún tipo de Constructor que sirva para algo.