Cursos Empresas Blog Live Conf Eventos Precios

0:0013:56

Recursos

Resumen

Descripción: Los años bisiestos son años con 366 días en vez de 365 y suceden cada 4 años.

Para determinar si un año es bisiesto o no, debemos seguir las siguientes reglas:

Todos los años divisibles por 400 son bisiestos (1600, 2000, 2400)
Todos los años divisibles por 100 pero NO por 400 NO son bisiestos (1700, 1800, 1900)
Todos los años divisibles por 4 son bisiestos (1996, 2004, 2012)
Todos los años que NO son divisibles por 4 NO son bisiestos (2017, 2018, 2019)

Algunas clases de pruebas terminan con la palabra Should en lugar de Test porque podemos entenderlas como frases cuando se leen en conjunto con los nombres de los métodos.

Por ejemplo, la clase DateUtilLeapYearShould con su método return_true_when_year_is_divisible_by_400 pueden leerse como "Date utils leap year should return true when year is divisible by 400" o "Los utils para calcular el año bisiesto deben devuelven true cuando el año es divisible por 400".

TDD para calcular años bisiestos en Java

Curso Básico de Testing en Java

Clase 13 de 24

Clase 13 / 24

César David Ramírez Dimaté

Hace 7 años

DateUtil.java

package com.platzi.javatests.util;

public class DateUtil {

  public static boolean isLeapYear(int year) {
    return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
  }
}

DateUtilLeapYearShould.java

package com.platzi.javatests.util;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

public class DateUtilLeapYearShould {
  /**
   * All years divisible by 400 ARE leap years (1600, 2000, 2400).
   * All years divisible by 100 but not by 400 are NOT leap years (1700, 1800, 1900).
   * All years divisible by 4 but not by 100 ARE leap years (1996, 2004, 2008).
   * All years are not divisible by 4 are NOT leap years (2017, 2018, 2019).
   */

  @Test
  public void returnTrue_whenYearIsDivisibleBy400() {
    assertThat(DateUtil.isLeapYear(1600), is(true));
    assertThat(DateUtil.isLeapYear(2000), is(true));
    assertThat(DateUtil.isLeapYear(2400), is(true));
  }

  @Test
  public void returnFalse_whenYearIsDivisibleBy100ButNotBy400() {
    assertThat(DateUtil.isLeapYear(1700), is(false));
    assertThat(DateUtil.isLeapYear(1800), is(false));
    assertThat(DateUtil.isLeapYear(1900), is(false));
  }

  @Test
  public void returnTrue_whenYearIsDivisibleBy4ButNotBy100() {
    assertThat(DateUtil.isLeapYear(1996), is(true));
    assertThat(DateUtil.isLeapYear(2004), is(true));
    assertThat(DateUtil.isLeapYear(2008), is(true));
  }

  @Test
  public void returnFalse_whenYearIsNotDivisibleBy4() {
    assertThat(DateUtil.isLeapYear(2017), is(false));
    assertThat(DateUtil.isLeapYear(2018), is(false));
    assertThat(DateUtil.isLeapYear(2019), is(false));
  }
}

Comentarios (44)44 comentarios

Irma Davila

Hace 8 años

Dejo aqui las notas:

All years divisible by 400 ARE Leap years (1600, 2000, 2400) All years divisible by 100 but not by 400 are NOT leap years (1700, 1880, 1900), All years divisible by 4 but not by 100 ARE 1eap years (1996, 2004, 2008), All years not divisible by 4 are NOT Leap years (2017, 2018, 2019)

Julián Yepes

En la segunda condición no es 1880 sino 1800

Wilson Hernande Neira Mija

Hace 5 años

Tener en cuenta que al dia de hoy la funccion assertThat esta marcado como deprecated en junit4

Omar Villada

Por cual se debe reemplazar?

Elkin Fernandez

Juan José Calderón

Me surgió una duda al ver este nuevo AssertThat. Ya que sentía que podría hacer lo mismo con un assertTrue o assertFalse. Busqué en internet, y encontré que el MOTIVO por el que se usa assertThat sobre estos otros es por: FACILIDAD DE LECTURA (Redability). Siento que lo explican MUY bien en esta página, asi que aquí os la dejo :D. Espero os sirva

Rahiber Paradas

Hace 4 años

Gracias por tu aporte

Milton Castañeda

REFACTORING:

public static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400) == 0;
    }

Manuel Salv. Lemos Foncubierta

Hace 6 años

En TDD NUNCA se pasan los test a verde "por casualidad". Lo que pasa es que el profesor no ha seguido correctamente el proceso del TDD.

Escribimos los Test.
Desarrollamos el codigo.
Refactorizamo si es necesario .

David Galicia Gomez

Pues que no eso fue lo que sucedio en el video? O que paso se salto o no hizo y en que momento?

José Luis García Peceros

para los que usan la versión 5 de junit para usar el assertThat y el is

<dependency>
     <groupId>org.hamcrest</groupId>
     <artifactId>hamcrest-all</artifactId>
     <version>1.3</version>
     <scope>test</scope>
</dependency>

Diego Luis Giraldo Castillo

Una observación para los que esten viendo este curso sobre la metodologia de TDD, literal en la anterior clase se explicó que los pasos son ROJO(falla), VERDE(pasa) y AZUL(refactor). En ese orden, debió haberse escrito el Test antes que el código, probar que fallará y luego si escribir el código que hiciera que pasará el test. Pero acá no se siguió ese orden, y comenzamos con VERDE, para luego pasar a ROJO.

Si se hace como dicta TDD, sería algo asi:

Escribir el test
Error (ROJO), la clase no existe (DateUtil)
Se crea la clase, se corre el Test
Error (ROJO), la clase no tiene el metodo (isLeapYear)
Se crea el metodo para que retorne falso siempre.
Se corre el Test, error (ROJO), se espera true, se obtiene falso
Se modifica el codigo para los casos multiplos de 400.
Se corre el Test, pasa (VERDE).
Se crea el nuevo Test, se corre, no pasa (ROJO)
Se modifica el codigo, etc

Parece tedioso, pero asi es el flujo y en aras de la pedagogia hubiera sido bueno hacerlo asi.

Stiven Castro Arias

por favor evitar usa los importes con *, así sea en casos prácticos, es mala práctica y si lo haces aprendiendo también lo haces en el trabajo saludos

Ramiro Carbonell

Para quien esté viendo el video en 2022 o posterior y utiliza junit5

        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest</artifactId>
            <version>2.2</version>
            <scope>test</scope>
        </dependency>

Imports

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

Gonzalo Muñoz

Me gusta la idea del TDD, tienes tú, o quizás otro compañero alguna guía para implementarla en aplicaciones más del mundo real? No sé bien como podría implementar TDD al hacer un microservicio, o al hacer una API, Hay alguna guía para hacerlo? He intentado buscar por internet, pero no he dado con nada convincente.

Este libro puede ayudar.

Este otro link, está muy interesante también.

Arturo Mauricio Terceros Beltrán

assertThat() esta obsoleto???

Marco Bottino Poittevin

Hola. Según lo que he investigado, es método bastante reciente que se introdujo para resolver algunos problemas creados por otros métodos como assertEquals. Te dejo algunos links que amplian esta información.

https://github.com/junit-team/junit4/wiki/Matchers-and-assertthat

https://dzone.com/articles/the-benefit-of-using-assertthat-over-other-assert

https://stackoverflow.com/questions/33274030/why-is-assertequalsdouble-double-deprecated-in-junit/33274179#33274179

Saludos.

Hola, corrijo un error que tuve en el comentario anterior. Al parecer, sí está obsoleto en las nuevas versiones.

Dejo un comentario en el que hablan de ello y brindan documentación: https://platzi.com/comentario/994622/

Saludos y disculpa por el error.

Roberto Shirásago Domínguez

Hace 2 años

Muy buena clase

Carlos Lizcano

Hace 3 años

public class DateUtils {
    
    public static boolean isLeapYear(int year) {
        // Utilizando la clase Year de Java 8 para verificar si un año es bisiesto
        return Year.of(year).isLeap();
    }
}

Francisco Ruiz Lezcano

public static boolean isLeapYear(int year){
        return (year % 400 == 0 || year % 100 == 0 || year % 4 == 0);
    }

Luis Boivar

El código lo vi cómo un poco más entendible de está manera:

public static boolean isLeapYear(int year){
        boolean divisibleBy4ByNotBy100 = (year % 4 == 0 && year % 100 != 0);
        boolean isJustDivisibleBy400 = (year % 400 == 0);
        boolean isDivisibleBy100ByNotBy400 = !(year % 100 == 0 && year % 400 != 0);
        return (isJustDivisibleBy400 || divisibleBy4ByNotBy100) && isDivisibleBy100ByNotBy400;
    }```

Moises Hernandez

Sorprendente el Ide, ayuda mucho a detectar, implementar y refactorizar.

Usuario anónimo

User

Buena clase gracias :)

Nelson Alexander Ortega Abarca

esta muy bueno este curso

Luis Fernando Chacha Montenegro

Hace 6 meses

O es opcional el ciclo TDD ?

La idea no era comenzar con la prueba que falle?

Recursos

Resumen

TDD para calcular años bisiestos en Java

Progreso del curso

Bienvenida e Introducción

Introducción a tests en software

Preparación del IDE, proyecto y librerías

TDD

Tests en una aplicación

Requerimientos y tests

Conclusiones