Función `isEmpty` y pruebas con JUnit en Java

Clase 11 de 24 • Curso Básico de Testing en Java

En una aplicación que estamos construyendo, nos hemos dado cuenta de que comprobamos muchas veces si un string está vacío o no. Por ello, vamos a implementar una función que realice esta tarea.

Crearemos una clase StringUtil y dentro pondremos la función isEmpty:

public class StringUtil {

    public static boolean isEmpty(String str) {
    ...
    }
}

Implementa esta función, y crea una clase StringUtilTest añadiendo tests que prueben varios escenarios: Probar que un string cualquiera no es vacío Probar que "" es un string vacío Probar que null también es un string vacío Extra: un string con espacios " " también lo queremos considerar como vacío (pista: puedes usar la función trim)

Comparte tu solución en el panel de discusiones.

Marcos Sebastián Imfeld

student•

Antonio Madrid

student•

Acabo de aprender el uso del método trim() Gracias

 public static boolean isEmpty(String str) {
       return str == null || str.trim().length() <= 0;
    }

@Test
    public void word_is_not_empty() {
        assertFalse(StringUtil.isEmpty("Palabra"));
    }

    @Test
    public void quotationMarks_is_Empty() {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void space_is_Empty() {
        String str = new String(" ");
        assertTrue(StringUtil.isEmpty(str));
    }

    @Test
    public void null_is_empty() {
        assertTrue(StringUtil.isEmpty(null));
    }

juan carlos reyes granciano

student•

Gracias acabo de entender el metodo trim()

Gaiserick Jhonatan Ortiz Ramírez

student•

Les dejo mi aporte con JUnit5

Método:

    public static boolean isEmpty(String string) {
        return string == null || string.trim().length() == 0;
    }

Tests:

class StringUtilsTest {

    @Nested
    @DisplayName("isEmpty method")
    class IsEmpty {

        @Test
        @DisplayName("when string is null")
        void trueWhenNull() {
            assertTrue(StringUtils.isEmpty(null));
        }

        @Test
        @DisplayName("when string just has spaces")
        void trueWhenEmptySpace() {
            assertTrue(StringUtils.isEmpty("  "));
        }

        @Test
        @DisplayName("when string is empty")
        void trueWhenEmpty() {
            assertTrue(StringUtils.isEmpty(""));
        }

        @Test
        @DisplayName("when has chars")
        void falseWhenHasChars() {
            assertFalse(StringUtils.isEmpty("hello"));
        }

    }
}

Gonzalo Muñoz

student•

StringUtil.java

public static boolean isEmpty(final String str) {
	return str == null || str.trim().isEmpty();
}

StringUtilTest.java

	@Test
	public void string_is_not_empty() {
		assertFalse(StringUtil.isEmpty("hola"));
	}
	
	@Test
	public void string_is_empty() {
		assertTrue(StringUtil.isEmpty(""));
	}
	
	@Test
	public void string_null_is_empty() {
		assertTrue(StringUtil.isEmpty(null));
	}

Anibal Fernando Ortega Piedrahita

student•

Excelente reto para empezar en el mundo de pruebas unitarias. Consideren crear un nuevo curso con Junit 5. Saludos

David Gallego

student•

// Class
public class StringUtil {

	public static boolean isEmpty(String str) {
		return str == null || str.trim().equals("");
	}
}

// Test class
public class StringUtilTest {
	@Test public void testNotEmptyString() {
		assertFalse(StringUtil.isEmpty("abcde"));
	}

	@Test public void testEmptyString() {
		assertTrue(StringUtil.isEmpty(""));
	}

	@Test public void testNullString() {
		assertTrue(StringUtil.isEmpty(null));
	}

	@Test public void testSpacesString() {
		assertTrue(StringUtil.isEmpty("    "));
	}
}

Jhon James Solis Sánchez

student•

Metodo

   public static boolean isEmpty(String str){

        if(str== null || str.trim().equals("")){

            return true;

        } else{

            return false;
        }

    }


  //Probar que un string cualquiera no es vacío
  @Test
  public void when_string_is_not_empty() {

    String str= "test";
    assertFalse(strUtil.isEmpty(str));

  }

  //Probar que “” es un string vacío
  @Test
  public void when_string_is_empty() {

    String str= "";
    assertTrue(strUtil.isEmpty(str));

  }


  //Probar que null también es un string vacío
  @Test
  public void when_string_is_null() {

    String str = null;
    assertTrue(strUtil.isEmpty(str));

  }


  //Extra: un string con espacios " " también lo queremos considerar como vacío (usar la función trim)
  @Test
  public void wher_string_has_spaces() {

    String str= "  ";
    assertTrue(strUtil.isEmpty(str));

  }

Oscar Fernando Diaz Anchay

student•

Esta es mi Solucion:

StringUtil.java

        if( str==null || str.isBlank()){
            return true;
        }
        return false;

StringUtilTest.java

public class StringUtilTest {
    @Test
    public void verifyStrNotEmpty() {
        Assert.assertFalse(StringUtil.isEmpty("Oscar"));
    }
    @Test
    public void verifyStrisEmpty() {
        Assert.assertTrue(StringUtil.isEmpty(""));
    }
    @Test
    public void verifyStrisNull() {
        Assert.assertTrue(StringUtil.isEmpty(null));
    }
    @Test
    public void verifyStrWithSpaces() {
        Assert.assertTrue(StringUtil.isEmpty("  "));
    }
}

Aaron Felipe Isaacs

student•

En mi caso consideré también que "null" es vacío, esto porque en algunos lugares he visto que para realizar un cast a String suelen utilizar + "".

public static boolean isEmpty(String str) {
     return str == null || str.trim().replace("null", "").isEmpty();
}

Aquí los test

    @Test
    public void string_is_null() {
        assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void string_is_empty() {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void string_is_empty_with_spaces() {
        assertTrue(StringUtil.isEmpty("   "));
    }

    @Test
    public void string_is_not_empty() {
        assertFalse(StringUtil.isEmpty("   hola"));
    }

    @Test
    public void string_is_differente_from_null_text() {
        assertTrue(StringUtil.isEmpty("null"));
    }

Usuario anónimo

user•

public static boolean isEmpty(String str) {
 return str == null || str.trim().length() <= 0;			 }

@Test
public void string_quotation_marks_is_empty() {
	assertTrue(StringUtil.isEmpty(""));
}

@Test
public void string_space_is_empty() {
	assertTrue(StringUtil.isEmpty(" "));
}

@Test
public void string_null_is_empty() {
	assertTrue(StringUtil.isEmpty(null));
}

Lina Marcela Patiño Pineda

student•

public static boolean isEmpty(String str) { return str == null || str.trim().length() <= 0; }

@Test public void string_is_not_empty() { assertFalse(StringUtil.isEmpty("hola")); }

@Test
public void string_quotation_marks_is_empty() {
	assertTrue(StringUtil.isEmpty(""));
}

@Test
public void string_space_is_empty() {
	assertTrue(StringUtil.isEmpty(" "));
}

@Test
public void string_null_is_empty() {
	assertTrue(StringUtil.isEmpty(null));
}

Edwin Donato Dominguez Oliva

student•

StringUtil.java

public static boolean isEmpty(String string) {

        return string == null || string.equals("") || string.trim().length() == 0;
    }

StringUtilTest.java

@Test
    public void stringIsNotEmpty() {
        boolean response = StringUtil.isEmpty("abcd");
        Assert.assertFalse(response);
    }

    @Test
    public void stringIsEmpty() {
        boolean response = StringUtil.isEmpty("");
        Assert.assertTrue(response);
    }

    @Test
    public void stringIsNull() {
        boolean response = StringUtil.isEmpty(null);
        Assert.assertTrue(response);
    }

    @Test
    public void stringWithSpaces() {
        boolean response = StringUtil.isEmpty("      ");
        Assert.assertTrue(response);
    }

Juan Francisco Esquivel Correa

student•

public class StringUtil {

    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty(); //return true if str is null or empty
    }
}

public class StringUtilTest {    @Test    public void is_empty() {        assertTrue(StringUtil.isEmpty(""));    }    @Test    public void is_not_empty() {        assertFalse(StringUtil.isEmpty("abc"));    }    @Test    public void is_null() {        assertTrue(StringUtil.isEmpty(null));    }    @Test    public void espaces() {        assertFalse(StringUtil.isEmpty("   "));    }}

Andrey David Cepeda Barbosa

student•

public class StringUtil {

    public static boolean isEmpty(String str) {
         return str.trim().isEmpty() || str==null;
    }
}

Oswaldo Gutiérrez

student•

Hola, primero debes preguntar por la posibilidad de null, si preguntas al final y la cadena viene en null tu primera condición va a dar error porque null no tiene el metodo trim entonces null.trim = ERROR

Oriol Comas Lluria

student•

Tu función tiene un error. El str==null deberia estar antes del str.trim().isEmpty();

Se puede comprobar con el siguiente test:

        @Test
        public void empty_string_null()
        {
            String nullStr = null;
            boolean result = StringsUtils.isEmpty(nullStr);
            assertTrue(result); 
        }

JOSE ADRIAN TEZOYOTL MORALES

student•

muy bien definidos los criterios de aceptación de la función, pero como sabriamos cuales son los criterios, porque puede que no se hayan contemplado algunas situaciones en alguna función que hayamos implementado.

Cesar David Ramírez Dimaté

student•

En el mundo real, los product owners definen los criterios de aceptación de la funcionalidad que se va a implementar. Aún así, uno como desarrollador se le pueden pasar algunas casuísticas. Gracias a las pruebas con los QA y demás, se identifican casos no contemplados.

Josef Andres Ramos Lopez

student•

package com.platzi.javatests.Empty;

import org.junit.Test;

import static junit.framework.TestCase.assertFalse; import static junit.framework.TestCase.assertTrue;

public class StringUtil {

public static boolean isEmpty(String str){
    return str == null || str.trim().length() <= 0;
}


@Test
public void string_is_not_empty(){
    String str = "Josef Ramos";
    StringUtil stringUtil = new StringUtil();

    assertFalse(stringUtil.isEmpty(str));
}

@Test
public void string_is_empty(){
    String str = "";
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

@Test
public void string_is_blanc(){
    String str = " ";
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

@Test
public void string_is_null(){
    String str = null;
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

}

Joshua Antonio López Domínguez

student•

public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    @Test
    public void correcta() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertFalse(StringUtil2.isEmpty("PALABRA"));
    }

    @Test
    public void isEmpty() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty(""));
    }

    @Test
    public void isNull() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty(null));
    }

    @Test
    public void con_espacios() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty("   "));
    }

Sergio

student•

public class StringUtil {

    public static boolean isEmpty(String str){
        return str == null  || str.trim().equals("");
    }
}

public class StringUtilTest {

    StringUtil stringUtil;

    @Before
    public void setup(){
         stringUtil = new StringUtil();
    }


    @Test
    public void when_not_empty_string_it_will_return_false(){
        //arrange
        String anyNotEmptyString = "not_empty_string";
        //act
        boolean isEmptyString = stringUtil.isEmpty(anyNotEmptyString);
        //assert
        assertFalse(isEmptyString);
    }

    @Test
    public void when_empty_string_it_will_return_true(){
        //arrange
        String emptyString = "";
        //act
        boolean isEmptyString = stringUtil.isEmpty(emptyString);
        //assert
        assertTrue(isEmptyString);
    }

    @Test
    public void when_null_string_it_will_return_true(){
        //arrange
        String nullString = null;
        //act
        boolean isEmptyString = stringUtil.isEmpty(nullString);
        //assert
        assertTrue(isEmptyString);
    }

    @Test
    public void when_string_with_space_it_will_return_true(){
        //arrange
        String spaceString = " ";
        //act
        boolean isEmptyString = stringUtil.isEmpty(spaceString);
        //assert
        assertTrue(isEmptyString);
    }
}

Antonio Jose Dos Ramos Lugo

student•

Completado! =D

Irma Davila

student•

String Util

    public static boolean isEmpty(String str){
        if (str == null){ return true;}
        return str.trim().equals("");
    }

StringUtilTest

/* RETO: 26/02/2019 */
    @Test
    public void test_string_not_empty(){
        Assert.assertFalse(StringUtil.isEmpty("any string"));
    }

    @Test
    public void test_string_empty(){
        Assert.assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void test_string_empty_also_null(){
        Assert.assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void test_string_empty_with_spaces(){
        Assert.assertTrue(StringUtil.isEmpty("  "));
    }

Marcos Salazar

student•

public class StringUtil {
    public static boolean isEmpty(String string){
        return string == null || string.trim().equals("");
    }
}

public class StringUtilTest {

    @Test
    public void is_invalid_when_string_is_empty(){
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void is_invalid_when_string_is_null() {
        assertTrue(StringUtil.isEmpty(null));
    }
    @Test
    public void is_invalid_when_string_have_spaces() {
        assertTrue(StringUtil.isEmpty("  "));
    }

    @Test
    public void is_string_valid() {
        assertFalse(StringUtil.isEmpty("hello world"));
    }
}

Leidy Ruiz

student•

public class StringUtil
{
    public static boolean isEmpty(String str)
    {
        if (str == null || str.trim().length() == 0)
        {
            return true;
        }
        return false;
    }
}

import org.junit.Test;
import static org.junit.Assert.*;

public class StringUtilTest
{
    @Test
    public void when_is_only_double_quotes()
    {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void when_is_quotes_and_spaces()
    {
        assertTrue(StringUtil.isEmpty("   "));
    }

    @Test
    public void when_is_null()
    {
        assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void when_is_string()
    {
        assertFalse(StringUtil.isEmpty("junit"));
    }
}

 public static boolean isEmpty(String str) {
       return str == null || str.trim().length() <= 0;
    }

@Test
    public void word_is_not_empty() {
        assertFalse(StringUtil.isEmpty("Palabra"));
    }

    @Test
    public void quotationMarks_is_Empty() {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void space_is_Empty() {
        String str = new String(" ");
        assertTrue(StringUtil.isEmpty(str));
    }

    @Test
    public void null_is_empty() {
        assertTrue(StringUtil.isEmpty(null));
    }

class StringUtilsTest {

    @Nested
    @DisplayName("isEmpty method")
    class IsEmpty {

        @Test
        @DisplayName("when string is null")
        void trueWhenNull() {
            assertTrue(StringUtils.isEmpty(null));
        }

        @Test
        @DisplayName("when string just has spaces")
        void trueWhenEmptySpace() {
            assertTrue(StringUtils.isEmpty("  "));
        }

        @Test
        @DisplayName("when string is empty")
        void trueWhenEmpty() {
            assertTrue(StringUtils.isEmpty(""));
        }

        @Test
        @DisplayName("when has chars")
        void falseWhenHasChars() {
            assertFalse(StringUtils.isEmpty("hello"));
        }

    }
}

	@Test
	public void string_is_not_empty() {
		assertFalse(StringUtil.isEmpty("hola"));
	}
	
	@Test
	public void string_is_empty() {
		assertTrue(StringUtil.isEmpty(""));
	}
	
	@Test
	public void string_null_is_empty() {
		assertTrue(StringUtil.isEmpty(null));
	}

// Class
public class StringUtil {

	public static boolean isEmpty(String str) {
		return str == null || str.trim().equals("");
	}
}

// Test class
public class StringUtilTest {
	@Test public void testNotEmptyString() {
		assertFalse(StringUtil.isEmpty("abcde"));
	}

	@Test public void testEmptyString() {
		assertTrue(StringUtil.isEmpty(""));
	}

	@Test public void testNullString() {
		assertTrue(StringUtil.isEmpty(null));
	}

	@Test public void testSpacesString() {
		assertTrue(StringUtil.isEmpty("    "));
	}
}

  //Probar que un string cualquiera no es vacío
  @Test
  public void when_string_is_not_empty() {

    String str= "test";
    assertFalse(strUtil.isEmpty(str));

  }

  //Probar que “” es un string vacío
  @Test
  public void when_string_is_empty() {

    String str= "";
    assertTrue(strUtil.isEmpty(str));

  }


  //Probar que null también es un string vacío
  @Test
  public void when_string_is_null() {

    String str = null;
    assertTrue(strUtil.isEmpty(str));

  }


  //Extra: un string con espacios " " también lo queremos considerar como vacío (usar la función trim)
  @Test
  public void wher_string_has_spaces() {

    String str= "  ";
    assertTrue(strUtil.isEmpty(str));

  }

public class StringUtilTest {
    @Test
    public void verifyStrNotEmpty() {
        Assert.assertFalse(StringUtil.isEmpty("Oscar"));
    }
    @Test
    public void verifyStrisEmpty() {
        Assert.assertTrue(StringUtil.isEmpty(""));
    }
    @Test
    public void verifyStrisNull() {
        Assert.assertTrue(StringUtil.isEmpty(null));
    }
    @Test
    public void verifyStrWithSpaces() {
        Assert.assertTrue(StringUtil.isEmpty("  "));
    }
}

    @Test
    public void string_is_null() {
        assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void string_is_empty() {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void string_is_empty_with_spaces() {
        assertTrue(StringUtil.isEmpty("   "));
    }

    @Test
    public void string_is_not_empty() {
        assertFalse(StringUtil.isEmpty("   hola"));
    }

    @Test
    public void string_is_differente_from_null_text() {
        assertTrue(StringUtil.isEmpty("null"));
    }

public static boolean isEmpty(String str) {
 return str == null || str.trim().length() <= 0;			 }

@Test
public void string_quotation_marks_is_empty() {
	assertTrue(StringUtil.isEmpty(""));
}

@Test
public void string_space_is_empty() {
	assertTrue(StringUtil.isEmpty(" "));
}

@Test
public void string_null_is_empty() {
	assertTrue(StringUtil.isEmpty(null));
}

@Test
public void string_quotation_marks_is_empty() {
	assertTrue(StringUtil.isEmpty(""));
}

@Test
public void string_space_is_empty() {
	assertTrue(StringUtil.isEmpty(" "));
}

@Test
public void string_null_is_empty() {
	assertTrue(StringUtil.isEmpty(null));
}

@Test
    public void stringIsNotEmpty() {
        boolean response = StringUtil.isEmpty("abcd");
        Assert.assertFalse(response);
    }

    @Test
    public void stringIsEmpty() {
        boolean response = StringUtil.isEmpty("");
        Assert.assertTrue(response);
    }

    @Test
    public void stringIsNull() {
        boolean response = StringUtil.isEmpty(null);
        Assert.assertTrue(response);
    }

    @Test
    public void stringWithSpaces() {
        boolean response = StringUtil.isEmpty("      ");
        Assert.assertTrue(response);
    }

public class StringUtil {

    public static boolean isEmpty(String str) {
        return str == null || str.isEmpty(); //return true if str is null or empty
    }
}

public class StringUtilTest {    @Test    public void is_empty() {        assertTrue(StringUtil.isEmpty(""));    }    @Test    public void is_not_empty() {        assertFalse(StringUtil.isEmpty("abc"));    }    @Test    public void is_null() {        assertTrue(StringUtil.isEmpty(null));    }    @Test    public void espaces() {        assertFalse(StringUtil.isEmpty("   "));    }}

        @Test
        public void empty_string_null()
        {
            String nullStr = null;
            boolean result = StringsUtils.isEmpty(nullStr);
            assertTrue(result); 
        }         

public static boolean isEmpty(String str){
    return str == null || str.trim().length() <= 0;
}


@Test
public void string_is_not_empty(){
    String str = "Josef Ramos";
    StringUtil stringUtil = new StringUtil();

    assertFalse(stringUtil.isEmpty(str));
}

@Test
public void string_is_empty(){
    String str = "";
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

@Test
public void string_is_blanc(){
    String str = " ";
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

@Test
public void string_is_null(){
    String str = null;
    StringUtil stringUtil = new StringUtil();

    assertTrue(stringUtil.isEmpty(str));
}

public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    @Test
    public void correcta() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertFalse(StringUtil2.isEmpty("PALABRA"));
    }

    @Test
    public void isEmpty() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty(""));
    }

    @Test
    public void isNull() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty(null));
    }

    @Test
    public void con_espacios() {
        //COMPROBACIÓN DE QUE EL DATO SEA EL ESPERADO
        assertTrue(StringUtil2.isEmpty("   "));
    }

public class StringUtilTest {

    StringUtil stringUtil;

    @Before
    public void setup(){
         stringUtil = new StringUtil();
    }


    @Test
    public void when_not_empty_string_it_will_return_false(){
        //arrange
        String anyNotEmptyString = "not_empty_string";
        //act
        boolean isEmptyString = stringUtil.isEmpty(anyNotEmptyString);
        //assert
        assertFalse(isEmptyString);
    }

    @Test
    public void when_empty_string_it_will_return_true(){
        //arrange
        String emptyString = "";
        //act
        boolean isEmptyString = stringUtil.isEmpty(emptyString);
        //assert
        assertTrue(isEmptyString);
    }

    @Test
    public void when_null_string_it_will_return_true(){
        //arrange
        String nullString = null;
        //act
        boolean isEmptyString = stringUtil.isEmpty(nullString);
        //assert
        assertTrue(isEmptyString);
    }

    @Test
    public void when_string_with_space_it_will_return_true(){
        //arrange
        String spaceString = " ";
        //act
        boolean isEmptyString = stringUtil.isEmpty(spaceString);
        //assert
        assertTrue(isEmptyString);
    }
}

/* RETO: 26/02/2019 */
    @Test
    public void test_string_not_empty(){
        Assert.assertFalse(StringUtil.isEmpty("any string"));
    }

    @Test
    public void test_string_empty(){
        Assert.assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void test_string_empty_also_null(){
        Assert.assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void test_string_empty_with_spaces(){
        Assert.assertTrue(StringUtil.isEmpty("  "));
    }

public class StringUtilTest {

    @Test
    public void is_invalid_when_string_is_empty(){
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void is_invalid_when_string_is_null() {
        assertTrue(StringUtil.isEmpty(null));
    }
    @Test
    public void is_invalid_when_string_have_spaces() {
        assertTrue(StringUtil.isEmpty("  "));
    }

    @Test
    public void is_string_valid() {
        assertFalse(StringUtil.isEmpty("hello world"));
    }
}

public class StringUtil
{
    public static boolean isEmpty(String str)
    {
        if (str == null || str.trim().length() == 0)
        {
            return true;
        }
        return false;
    }
}

import org.junit.Test;
import static org.junit.Assert.*;

public class StringUtilTest
{
    @Test
    public void when_is_only_double_quotes()
    {
        assertTrue(StringUtil.isEmpty(""));
    }

    @Test
    public void when_is_quotes_and_spaces()
    {
        assertTrue(StringUtil.isEmpty("   "));
    }

    @Test
    public void when_is_null()
    {
        assertTrue(StringUtil.isEmpty(null));
    }

    @Test
    public void when_is_string()
    {
        assertFalse(StringUtil.isEmpty("junit"));
    }
}

Función `isEmpty` y pruebas con JUnit en Java

Bienvenida e Introducción

Testing en Java: JUnit, Mockito y TDD

Introducción a tests en software

Beneficios y tipos de tests automáticos y manuales en software

Preparación del IDE, proyecto y librerías

Uso de IntelliJ IDEA para Escribir y Probar Código Java

Creación de Tests Unitarios y Excepciones en Java

Escribir Tests en Java con JUnit: Instalación y Uso Básico

Organización de Tests en Funciones Separadas

Testing en Java con JUnit para Verificar Contraseñas

Simulación de Clases en Java con Moquito

Simulación de Pasarelas de Pago con Mockito

Organización y Mejora de Tests en jUnit

Función `isEmpty` y pruebas con JUnit en Java

TDD

Desarrollo Guiado por Pruebas (TDD): Conceptos y Ciclo Red-Green-Refactor

TDD para calcular años bisiestos en Java

Cálculo de Descuentos con Pruebas Unitarias en Java

Programación con TDD: Ejercicios FizzBuzz y Números Romanos

Tests en una aplicación

Organización de Aplicaciones en Capas: Interfaz, Negocio y Datos

Tests de Aplicación de Películas: Filtrado por Género y Duración

Pruebas de Búsqueda de Películas por Duración en Java

Implementación de MovieRepository con JDBC en Java

Tests de JDBC: Búsqueda e Inserción de Películas por ID

Búsqueda de Películas por Nombre y Director en App

Requerimientos y tests

Escritura de Tests a partir de Requerimientos Específicos

Búsqueda de Películas por Atributos en Java

Conclusiones

Recomendaciones para Escribir Tests Efectivos en Programación