Instituto Tecnológico de Estudios Superiores de Los

Cabos

Ingeniería en sistemas computacionales.

“Investigación conceptos previos”

Asignatura: Lenguaje y autómatas I

Docente: M.C. José Ismael Ojeda Campaña

Grupo: 6IS - 01V

Estudiante: Angela Guadalupe Castellanos Carrasco

Número de control: 19381078

Los Cabos, B.C.S., 12 de marzo de 2022

Índice

// Borra comentarios código .............................. 2

// ESTADISTICAS2............................................... 8

// Validadores .................................................... 16
 // Borra comentarios código

package com.company;
import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Esta clase lee un archivo de código Java, le quita los
comentarios y
* escribe el resultado en otro archivo del mismo tipo, aunque
tiene un *pequeño detalle, borra una pequeña parte de nuestro
código al *momento de eliminar los comentarios.
*/
public class BorraComentarios {
String nomArchivoEntrada;
String nomArchivoSalida;
/**
* Este constructor inicializa los atributos de la clase e invoca a
los
* metodos que abren el archivo fuente, borran los comentarios
y
* escriben el resultado en otro archivo.
*/
public BorraComentarios(String nomArchivoEntrada,
String nomArchivoSalida) {
String fuenteCC, fuenteSC; this.nomArchivoEntrada =
nomArchivoEntrada;
this.nomArchivoSalida = nomArchivoSalida;
// Lee el archivo con el codigo fuente
fuenteCC = leeArchivo();
// Borra los comentarios
fuenteSC = borraComentarios(fuenteCC);
// Escribe los resultados en un archivo texto
escribeArchivo(fuenteSC);
}
/**
* Este metodo abre el archivo con el codigo fuente, lo lee linea
por
* linea, las guarda en una cadena de tipo String.
* regresa una cadena con el contenido del archivo de entrada
*/
public String leeArchivo() {
FileReader fileReader;
BufferedReader bufferedReader;
String linea;
StringBuffer fuente = new StringBuffer();

// Abre el archivo con el codigo fuente

try {
fileReader = new FileReader(nomArchivoEntrada);
} catch (FileNotFoundException fnfe) {
System.out.println("Error: No existe el archivo "
+ nomArchivoEntrada);
 return null;
}
// Se envuelve el archivo con el codigo fuente con un archivo
// del tipo BufferedReader para eficientar su acceso
bufferedReader = new BufferedReader(fileReader);
try {
while (true) {
// Obten la siguiente linea del archivo con el codigo fuente
linea = bufferedReader.readLine();
// Si ya no hay lineas, termina el ciclo
if (linea == null) {
break;
}
// Agrega la línea al Stringbuffer
fuente.append(linea);
// Agrega un salto de línea al Stringbuffer
fuente.append("\n");
}
bufferedReader.close();
fileReader.close(); return fuente.toString();
} catch (IOException ioe) {
System.out.println("Error al procesar el archivo"
+ nomArchivoEntrada);
return null;
}
 }
/**
* Este metodo escribe en un archivo texto, el contenido del
archivo
* fuente de Java de entrada sin los comentarios
* @param fuenteSC Archivo fuente de Java de entrada sin los
* comentarios
*/
public void escribeArchivo(String fuenteSC) {
FileWriter fileWriter;
BufferedWriter bufferedWriter;
// Abre el archivo donde se escribiran los resultados
try {
fileWriter = new FileWriter(nomArchivoSalida);
} catch (IOException ioe) {
System.out.println("Error, no se pudo crear el archivo"
+ nomArchivoSalida);
return;

}
// Se envuelve el archivo donde se escribiran los resultados con
un
// archivo del tipo BufferedWriter para eficientar su acceso
bufferedWriter = new BufferedWriter(
(OutputStreamWriter) (fileWriter));
 try {
bufferedWriter.write(fuenteSC); bufferedWriter.close();
fileWriter.close();
} catch (IOException ioe) {
System.out.println("Error al escribir al archivo"
+ nomArchivoSalida);
}
}
/**
* Este metodo borra los comentarios de línea, multilínea y de
* documentación de archivos con código Java.
* Falla si una cadena literal contiene dos diagonales seguidas
*/
public String borraComentarios(String fuenteCC) {
// Crea una expresión regular que elimine los comentarios
String exReg = "(?:/\\*(?:[^*]|(?:\\*+[^*/]))*\\*+/)|(?://.*$)"; //
Compila la expression regular en un patron
Pattern p = Pattern.compile(exReg, Pattern.MULTILINE);
// Crea un ajustador para el texto del archivo
Matcher m = p.matcher(fuenteCC); // Reemplaza los
comentarios por una cadena vacia
return m.replaceAll("");
}
}
// ESTADISTICAS2

package com.company;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Estadistica2 {

String nomArchivoEntrada;
String nomArchivoSalida;

public Estadistica2(String nomArchivoEntrada, String

nomArchivoSalida, String[] palabras) {
this.nomArchivoEntrada = nomArchivoEntrada;
this.nomArchivoSalida = nomArchivoSalida;
 String fuente = this.leeArchivo();
Map<String, Integer> cuentaPalabras =
this.procesaArchivo(fuente, palabras);
this.escribeResultados(cuentaPalabras);
}

public String leeArchivo() {

StringBuffer fuente = new StringBuffer();

FileReader fileReader;
try {
fileReader = new FileReader(this.nomArchivoEntrada);
} catch (FileNotFoundException var5) {
System.out.println("Error: No existe el archivo " +
this.nomArchivoEntrada);
return null;
}

BufferedReader bufferedReader = new

BufferedReader(fileReader);

try {
while(true) {
String linea = bufferedReader.readLine();
if (linea == null) {
bufferedReader.close();
 fileReader.close();
return fuente.toString();
}

fuente.append(linea);
fuente.append("\n");
}
} catch (IOException var6) {
System.out.println("Error al procesar el archivo" +
this.nomArchivoEntrada);
return null;
}
}

public void escribeResultados(Map<String, Integer>

cuentaPalabras) {
FileWriter fileWriter = null;

try {
fileWriter = new FileWriter(this.nomArchivoSalida);
} catch (IOException var6) {
System.out.println("Error, no se pudo crear el archivo" +
this.nomArchivoSalida);
return;
}
 BufferedWriter bufferedWriter = new
BufferedWriter(fileWriter);

try {
bufferedWriter.write("Frecuencia de las palabras
reservadas");
bufferedWriter.newLine();
bufferedWriter.write("en la clase: " +
this.nomArchivoEntrada);
bufferedWriter.newLine();
bufferedWriter.newLine();
Iterator var4 = cuentaPalabras.entrySet().iterator();

while(var4.hasNext()) {
Entry<String, Integer> palabra = (Entry)var4.next();
String var10001 = (String)palabra.getKey();
bufferedWriter.write(var10001 + ": " +
palabra.getValue());
bufferedWriter.newLine();
}

bufferedWriter.close();
fileWriter.close();
} catch (IOException var7) {
System.out.println("Error al cerrar el archivo" +
this.nomArchivoSalida);
}
 }

public Map<String, Integer> procesaArchivo(String fuente,

String[] palabras) {
Map<String, Integer> cuentaPalabras = new TreeMap();
StringBuffer exReg = new StringBuffer();

for(int i = 0; i < palabras.length; ++i) {

exReg.append("(?:");
exReg.append("\\b");
exReg.append(palabras[i]);
exReg.append("\\b");
exReg.append(")");
if (i < palabras.length - 1) {
exReg.append("|");
}
}

Pattern p = Pattern.compile(exReg.toString(), 8);

Matcher m = p.matcher(fuente);

while(m.find()) {
String palabra = m.group();
if (!cuentaPalabras.containsKey(palabra)) {
cuentaPalabras.put(palabra, 1);
 } else {
int n = (Integer)cuentaPalabras.get(palabra);
cuentaPalabras.put(palabra, n + 1);
}
}

return cuentaPalabras;
}
}
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.company;

public class Main {

public Main() {
}

public static void main(String[] args) {

new Main();
String[] palabrasReservadas = new String[]{"if", "switch",
"while", "for", "do"};
new Estadistica2("src\\com\\company\\Estadistica2.java",
"estadisticas.txt", palabrasReservadas);
}
}
// Validadores

package com.company;
/*
* ValidadoresTest.java
*/

import org.junit.AfterClass;
import static org.junit.Assert.*;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* Esta es la clase de prueba de la clase Validadores.java
*
*
*/
public class ValidadoresTest {

public static void main(String[] args){

ValidadoresTest validadoresTest = new ValidadoresTest();
validadoresTest.testValidaCadena();
}

public ValidadoresTest() {
 }
@BeforeClass
public static void setUpClass() throws Exception {
}
@AfterClass
public static void tearDownClass() throws Exception {
}
/**
* Prueba unitaria del metodo cadenaVacia de la clase
Validadores.
*/
@Test
public void testCadenaVacia() {
Validadores instance = new Validadores();
boolean result;

String s;

System.out.println("Prueba unitaria del metodo

cadenaVacia");
// Prueba si acepta una cadena vacia
s = "";
result = instance.cadenaVacia(s);
assertTrue(result);

// Prueba si acepta una cadena con espacios

 s = " ";
result = instance.cadenaVacia(s);
assertTrue(result);

// Prueba si acepta una cadena con caracter tabulador

s = " \t";
result = instance.cadenaVacia(s);
assertTrue(result);
// Prueba si acepta una cadena con caracter tabulador
s = " \n";
result = instance.cadenaVacia(s);
assertTrue(result);

// Prueba si rechaza una cadena no vacia

s = "no\nno";
result = instance.cadenaVacia(s);
assertFalse(result);
}
/**
* Prueba unitaria del metodo validaCadena de la clase
Validadores.
*/
@Test
public void testValidaCadena() {
Validadores instance = new Validadores();
boolean result;
 String s;
int longMax;

System.out.println("Prueba unitaria del metodo

validaCadena");
// Prueba si acepta una cadena de longitud igual a longMax
longMax = 5;
s = "12345";
result = instance.validaCadena(longMax, s);
assertTrue(result);
System.out.println("resulado1:"+result);

// Prueba si acepta una cadena de longitud menor a longMax

longMax = 5;
s = "123";
result = instance.validaCadena(longMax, s);
assertTrue(result);
System.out.println("resulado2:"+result);

// Prueba si rechaza una cadena de longitud mayor a longMax

longMax = 5;
s = "1234567";

result = instance.validaCadena(longMax, s);

assertFalse(result);
 // Prueba si rechaza una cadena vacia
longMax = 5;
s = "";
result = instance.validaCadena(longMax, s);
assertFalse(result);
}
/**
* Prueba unitaria del metodo validaClave de la clase
Validadores.
*/
@Test
public void testValidaClave() {
Validadores instance = new Validadores();
boolean result;
String s;
System.out.println("Prueba unitaria del metodo
validaClave");
// Prueba si acepta una clave valida
s = "ABC0123";
result = instance.validaClave(s);
assertTrue(result);
// Prueba si rechaza una clave con minusculas
s = "abc0123";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con otros caracteres
 s = "AB+;0123";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave vacia
s = "";
result = instance.validaClave(s);
assertFalse(result);

// Prueba si rechaza una clave con espacios

s = " ";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con solo caracteres
s = "ABC";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con solo digitos
s = "0123";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con mas caracteres

s = "ABCD0123";
 result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con menos caracteres
s = "AB0123";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con mas digitos
s = "ABC01234";
result = instance.validaClave(s);
assertFalse(result);
// Prueba si rechaza una clave con menos digitos
s = "ABC012";
result = instance.validaClave(s);
assertFalse(result);
}
/**
* Prueba unitaria del metodo validaEntero de la clase
Validadores.
*/
@Test
public void testValidaEntero() {
Validadores instance = new Validadores();
boolean result;
String s;
System.out.println("Prueba unitaria del metodo
validaEntero");
 // Prueba si acepta un entero valido
s = "1234";
result = instance.validaEntero(s);
assertTrue(result);

// Prueba si rechaza una cadena con letras

s = "12a3";
result = instance.validaEntero(s);
assertFalse(result);

// Prueba si rechaza una cadena con otros caracteres

s = "A12+;0";
result = instance.validaEntero(s);
assertFalse(result);
// Prueba si rechaza una cadena vacia
s = "";
result = instance.validaEntero(s);
assertFalse(result);
// Prueba si rechaza una cadena con espaciosa
s = " ";
result = instance.validaEntero(s);
assertFalse(result);
}
 /**
* Prueba unitaria del metodo validaEnteroMaxDigitos de la
clase
Validadores.
*/
@Test
public void testValidaEnteroMaxDigitos() {
Validadores instance = new Validadores();
boolean result;
String s;
int numDigitos;
System.out.println(
"Prueba unitaria del metodo validaEnteroMaxDigitos");

// Prueba si acepta un entero valido

numDigitos = 1;
s = "1";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertTrue(result);

// Prueba si acepta un entero valido

numDigitos = 5;
s = "12345";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertTrue(result);
// Prueba si acepta un entero valido
numDigitos = 5;
s = "1234";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertTrue(result);

// Prueba si rechaza un entero muy largo

numDigitos = 5;
s = "124567";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertFalse(result);
// Prueba si rechaza un entero con letras
numDigitos = 5;
s = "12a3";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertFalse(result);
// Prueba si rechaza una cadena con otros caracteres
numDigitos = 5;
s = "A12+;0";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertFalse(result);
// Prueba si rechaza una cadena vacia
numDigitos = 5;
s = "";
 result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertFalse(result);

// Prueba si rechaza una cadena con espaciosa

numDigitos = 5;
s = " ";
result = instance.validaEnteroMaxDigitos(numDigitos, s);
assertFalse(result);
}
/**
* Prueba unitaria del metodo validaEnteroRango de la clase
* Validadores.
*/
@Test
public void testValidaEnteroRango() {
Validadores instance = new Validadores();
boolean result;
String s;
int min, max;
System.out.println("Prueba unitaria del metodo
validaEnteroRango");

min = 10;
max = 100;
 // Prueba si acepta un entero con rango valido
s = "50";
result = instance.validaEnteroRango(min, max, s);
assertTrue(result);

// Prueba si acepta un entero con rango valido

s = "10";
result = instance.validaEnteroRango(min, max, s);
assertTrue(result);

// Prueba si acepta un entero con rango valido

s = "100";
result = instance.validaEnteroRango(min, max, s);
assertTrue(result);

// Prueba si rechaza un entero con por debajo del rango

s = "5";
result = instance.validaEnteroRango(min, max, s);
assertFalse(result);

// Prueba si rechaza un entero con por encima del rango

s = "500";
result = instance.validaEnteroRango(min, max, s);
assertFalse(result);
}
 /**
* Prueba unitaria del metodo validaFecha de la clase
Validadores.
*/
@Test
public void testValidaFecha() {
Validadores instance = new Validadores();
boolean result;
String s;

System.out.println("Prueba unitaria del metodo

validaFecha");

// Prueba si acepta una fecha valida

s = "1/1/2001";
result = instance.validaFecha(s);
assertTrue(result);

// Prueba si acepta una fecha valida

s = "01/01/2010";
result = instance.validaFecha(s);
assertTrue(result);

// Prueba si acepta una fecha valida

s = "15/12/2001";
result = instance.validaFecha(s);
assertTrue(result);

// Prueba si acepta una fecha valida

s = "21/08/2000";
result = instance.validaFecha(s);
assertTrue(result);

// Prueba si acepta una fecha valida

s = "31/1/2001";
result = instance.validaFecha(s);
assertTrue(result);

// Prueba si rechaza una fecha invalida

s = "11/2001";
result = instance.validaFecha(s);
assertFalse(result);

// Prueba si rechaza una fecha invalida

s = "51/13/2001";
result = instance.validaFecha(s);
assertFalse(result);

// Prueba si rechaza una fecha valida

s = "0/0/201";
 result = instance.validaFecha(s);
assertFalse(result);

// Prueba si rechaza una fecha valida

s = "12/ago/2001";
result = instance.validaFecha(s);
assertFalse(result);
}
}