Проверять Данные

блокировали и я не знаю, как продвигаться.

У меня есть следующие данные:

String Equiv1="";
    String Equiv2="";
    String equivalencia1="";

public int probarEquiv1 (){
    Equiv1 =ConversorNou.PrimeraDivisaTXT.getText();
    Equiv2 = ConversorNou.SegundaDivisaTXT.getText();
    equivalencia1 = ConversorNou.EquivalenciaTXT.getText();

И я они должен проверять один в один.

А именно:

1-Проверять, что Equiv1 был "Долларом", "Евро", "вес", если правильно, что перешел в следующую проверку.

2-Проверять Equiv2: Будьте "долларом", Евро, Вес, но что не повторился с Equiv1 (а именно, если Equiv1 - Доллар тогда Equiv2, только это сможет быть Песо или Евро), Если он правилен, перейдет к тому, чтобы проверять следующее.

3-Verificar, что является Эквивалентностью, которая должна быть: Большее число 0, и смоги соглашаться десятичные.

Какова моя проблема, что я умею проверять все вместе, но не по отдельности.

В конце концов, если проверка всего правильна, они должны уходить в RETURN 1, если он неправильный в RETURN 2 (но если выходит выбор return 2, который неправильный, я должен знать, что он исходит из проверки, она неправильная)

Проблема, которая у меня есть, состоит в том, что я не знаю, как одна делать проверки одной и способствовать тому, чтобы return показал, который является ошибочной информацией.

Если он дает любую ошибку 3 проверок, я должен знать 100 %, который их и показывать ее с setFocus ()

Часть return эта:

Button botonDadesEntrades = new Button(Conversor_de_divises, SWT.BORDER);
        botonDadesEntrades.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
            if (data.probarEquiv1()==1){
                JOptionPane.showMessageDialog(null, "Datos Correctos");


            }else{
                 PrimeraDivisaTXT.setFocus(); // asigno el foco al textfield 
                 PrimeraDivisaTXT.selectAll(); // luego selecciono todo el texto 

                JOptionPane.showMessageDialog(null, "Error has puesto un dato incorrecto "

            }

            }
        });

Я нуждаюсь в том, чтобы знать, как изменять часть return 2 для того, чтобы он показал, который является неправильной информацией.

спасибо предвосхищенный! Говорится о том, чтобы использовать setfocus () setall (), чтобы выбирать неправильного. Но я блокирована. T_T

спасибо!

Изданный:

Часть тестировать Equiv1, который я сделал:

if(Equiv1.equalsIgnoreCase("Euro")&& Equiv2.equalsIgnoreCase("Dolar")&& DatosUser.esDecimal1(equivalencia1)){
        return 1;
    }
    else if ( Equiv1.equalsIgnoreCase("Dolar")&& Equiv2.equalsIgnoreCase("Euro")&& DatosUser.isNumeric(equivalencia1)){
    return 1;               
    }
    else if ( Equiv1.equalsIgnoreCase("Euro")&& Equiv2.equalsIgnoreCase("Dolar")&& DatosUser.isNumeric(equivalencia1)){
        return 1;
    }
    else if (Equiv1.equalsIgnoreCase("Dolar")&& Equiv2.equalsIgnoreCase("Euro")&& DatosUser.esDecimal1(equivalencia1)){
        return 1;
    }
    else{
        return 0;
    }

}

     private static boolean isNumeric(String cadena){
            try {
                Integer.parseInt(cadena);
                return true;
            } catch (NumberFormatException nfe){
                return false;
            }}


     public static boolean esDecimal1(String cad)
     {
     boolean hayPunto=false;
     StringBuffer parteEntera = new StringBuffer();
     StringBuffer parteDecimal = new StringBuffer();
     int i=0, posicionDelPunto;

     for( i=0;i<cad.length(); i++ )
     if ( cad.charAt(i) == '.')                          //Detectar si hay un punto decimal en la cadena
     hayPunto=true;
     if(hayPunto)                                            //Si hay punto guardar la posicion donde se encuentra el carater punto
     posicionDelPunto=cad.indexOf('.');                  //(si la cadena tiene varios puntos, detecta donde esta el primero).
     else
     return false;                                       //Si no hay punto; no es decimal

     if( posicionDelPunto == cad.length()-1 || posicionDelPunto== 0)    //Si el punto esta al final o al principio no es un decimal
     return false;

     for( i=0;i<posicionDelPunto; i++ )
     parteEntera.append(cad.charAt(i)) ;                 //Guardar la parte entera en una variable

     for(i = 0; i<parteEntera.length(); i++)
     if( ! Character.isDigit(parteEntera.charAt(i)) )    //Si alguno de los caracteres de la parte entera no son digitos no es decimal
     return false;

     for( i=posicionDelPunto+1;i<cad.length(); i++ )
     parteDecimal.append(cad.charAt(i));                 //Guardar la parte decimal en una variable

     for(i = 0; i<parteDecimal.length(); i++)
     if( ! Character.isDigit(parteDecimal.charAt(i)) )   //Si alguno de los caracteres de la parte decimal no es un digito no es decimal
     return false;                                   //Incluye el caso en el que la cadena tenga dos o mas puntos

     return true;                                            //Si paso todas las pruebas anteriores, la cadena es un Numero decimal
     }


     public boolean esDecimal(String cad)
     {
     try
     {
       Double.parseDouble(cad);
       return true;
     }
     catch(NumberFormatException nfe)
     {
       return false;
     }




    }
}
1
задан 10.04.2016, 16:16
2 ответа

Также я присоединяю тебя aquГ - другой способ видеть тему, ты реализуешь утверждение всех признаков, которые ты хочешь, и производишь список ошибок, а именно она validaciГіn он делается всегда во все признаки и потом производится список ошибок и состояние утверждения, которое только будет OK , если нет никакой ошибки, я происхожу с тобой cГіdigo:

public class Validador {
  private static final String EURO = "Euro";
  private static final String DOLAR = "Dolar";
  private static final String PESO = "Peso";

  public Resultado procesa(String tipoMoneda1, String tipoMoneda2,
        String equivalencia) {
    Resultado resultado = new Resultado();
    if (!validaTipoMoneda(tipoMoneda1)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 1 no valida");
    }
    if (!validaTipoMoneda(tipoMoneda2)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 2 no valida");
    }
    if (sonMismoTipoMoneda(tipoMoneda1, tipoMoneda2)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 1 y tipo de moneda 2 son iguales");
    }
    try {
        double equivalenciaConvertida = convierteEquivalencia(equivalencia);
    } catch (NumberFormatException e2) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("Equivalencia no es convertible a valor numerico");
        return resultado;
    }
    return resultado;
  }

  private boolean validaTipoMoneda(String tipoMoneda) {
    return tipoMoneda.equalsIgnoreCase(EURO)
            || tipoMoneda.equalsIgnoreCase(DOLAR)
            || tipoMoneda.equalsIgnoreCase(PESO) ? true : false;
  }

  private boolean sonMismoTipoMoneda(String tipoMoneda1, String tipoMoneda2) {
    return tipoMoneda1.equalsIgnoreCase(tipoMoneda2) ? true : false;
  }

  private double convierteEquivalencia(String equivalencia) {
    return Double.valueOf(equivalencia);
  }

  class Resultado {
    public static final boolean OK=true;
    public static final boolean KO=false;
    private boolean estado;
    private List<String> errores;

    public Resultado() {
        this.estado=OK;
        this.errores=new ArrayList<String>();
    }

    public boolean isEstado() {
        return estado;
    }

    public void setEstado(boolean estado) {
        this.estado = estado;
    }

    public List<String> getErrores() {
        return errores;
    }

    public void setErrores(List<String> errores) {
        this.errores = errores;
    }

    public void addError(String error) {
        errores.add(error);
    }

  }

}

Ваш тест, чтобы проверять правильное поведение:

public class ValidadorTest {

  @Test
  public void testValida_moneda1_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Dolar", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 no valida")));
  }

  @Test
  public void testValida_moneda2_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Rupia", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 2 no valida")));
  }

  @Test
  public void testValida_monedas_son_iguales() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Dolar", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
  }

  @Test
  public void testValida_equivalencia_no_convertible() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "23#2");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

  @Test
  public void testValida_ok() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "1.17");
    assertThat(res.isEstado(), is(equalTo(Resultado.OK)));
    assertThat(res.getErrores().size(),is(0));
  }

  @Test
  public void testValida_listaErrores() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Rupia", "23#4");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(4));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 no valida")));
    assertThat(res.getErrores().get(1),is(equalTo("tipo de moneda 2 no valida")));
    assertThat(res.getErrores().get(2),is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
    assertThat(res.getErrores().get(3),is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

}
2
ответ дан 24.11.2019, 14:36
  • 1
    не conoc и # 237; в assertThat Спасибо на самом деле! – Montse Mkd 11.04.2016, 15:12

Я присоединяю тебя код, чтобы решать твою проблему, утверждения находятся в частных методах и чтобы формировать тех, кого ты называешь RETURN, я создал класс, Оказанный, что хранит их результат утверждения, ты можешь изменять ее в твой вкус:

public class Validador {
  private static final String EURO = "Euro";
  private static final String DOLAR = "Dolar";
  private static final String PESO = "Peso";

  public Resultado procesa(String tipoMoneda1, String tipoMoneda2, String equivalencia) {
    Resultado resultado = new Resultado();
    if (validaTipoMoneda(tipoMoneda1)) {
        if (validaTipoMoneda(tipoMoneda2)) {
            if (!sonMismoTipoMoneda(tipoMoneda1, tipoMoneda2)) {
                try {
                    double equivalenciaConvertida = convierteEquivalencia(equivalencia);
                    resultado.setTipoReturn("RETURN1");
                    resultado.setErrorValidacion("no existen errores");
                } catch (NumberFormatException e2) {
                    resultado.setTipoReturn("RETURN2");
                    resultado.setErrorValidacion("Equivalencia no es convertible a valor numerico");
                    return resultado;
                }
            } else {
                resultado.setTipoReturn("RETURN2");
                resultado.setErrorValidacion("tipo de moneda 1 y tipo de moneda 2 son iguales");
            }
        } else {
            resultado.setTipoReturn("RETURN2");
            resultado.setErrorValidacion("tipo de moneda 2 no valida");
        }
    } else {
        resultado.setTipoReturn("RETURN2");
        resultado.setErrorValidacion("tipo de moneda 1 no valida");
    }
    return resultado;
  }

  private boolean validaTipoMoneda(String tipoMoneda) {
    return tipoMoneda.equalsIgnoreCase(EURO) || tipoMoneda.equalsIgnoreCase(DOLAR)
            || tipoMoneda.equalsIgnoreCase(PESO) ? true : false;
  }

  private boolean sonMismoTipoMoneda(String tipoMoneda1, String tipoMoneda2) {
    return tipoMoneda1.equalsIgnoreCase(tipoMoneda2) ? true : false;
  }

  private double convierteEquivalencia(String equivalencia) {
    return Double.valueOf(equivalencia);
  }

  class Resultado {
    private String tipoReturn;
    private String errorValidacion;

    public String getTipoReturn() {
        return tipoReturn;
    }

    public void setTipoReturn(String tipoReturn) {
        this.tipoReturn = tipoReturn;
    }

    public String getErrorValidacion() {
        return errorValidacion;
    }

    public void setErrorValidacion(String errorValidacion) {
        this.errorValidacion = errorValidacion;
    }

  }

}

Ваш тест, чтобы проверять ожидаемое поведение:

public class ValidadorTest {

  @Test
  public void testValida_moneda1_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Dolar", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 1 no valida")));
  }

  @Test
  public void testValida_moneda2_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Rupia", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 2 no valida")));
  }

  @Test
  public void testValida_monedas_son_iguales() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Dolar", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
  }

  @Test
  public void testValida_equivalencia_no_convertible() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "23#2");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

  @Test
  public void testValida_ok() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "1.17");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN1")));
    assertThat(res.getErrorValidacion(), is(equalTo("no existen errores")));
  }

}

Я надеюсь, что он помогает тебе ;)

2
ответ дан 24.11.2019, 14:36