Datasets:

feedback-to-code

/

mozzarella

like 1

Follow

Feedback-2-Code 7

iluwatar/java-design-patterns/2333_2461

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2333

iluwatar/java-design-patterns/2461

08682962b5f941caebbae863ab309a69779c0dc7

0eb976394bab5d58acb2d246160adad4d072f314

Broken linkage on Chinese localization document

Broken linkage [Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg) on the following Chinese localization README file. https://github.com/iluwatar/java-design-patterns/blob/master/localization/zh/README.md

diff --git a/localization/zh/README.md b/localization/zh/README.md index dcf8571b5764..6b810cd48e9a 100644 --- a/localization/zh/README.md +++ b/localization/zh/README.md @@ -4,7 +4,7 @@ # 设计模式Java版 - [](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md) [](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) + [](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md) [](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) # 介绍

test

test

limingho456

train

iluwatar/java-design-patterns/2459_2467

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2459

iluwatar/java-design-patterns/2467

c741814b367f004787ef2f87665cc00b5f07b35e

4e8cdc7c960ce991fce94cfb0143466e9526a6a6

Why are we using synchronized twice in com.iluwatar.singleton.ThreadSafeLazyLoadedIvoryTower?

`/** * The instance doesn't get created until the method is called for the first time. */ public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() { if (instance == null) { synchronized (ThreadSafeLazyLoadedIvoryTower.class) { if (instance == null) { instance = new ThreadSafeLazyLoadedIvoryTower(); } } } return instance; }` Shouldn't we remove synchronized from method signature? I didn't find any explaination for this. Usually for lazy initialization we have synchronized only inside the method right? What pros/cons are there for using synchronized in method signature? [Code reference](https://github.com/iluwatar/java-design-patterns/blob/master/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java#L46)

diff --git a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java index 58d6e53b9729..fcafba3611c5 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java +++ b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java @@ -44,13 +44,9 @@ private ThreadSafeLazyLoadedIvoryTower() { * The instance doesn't get created until the method is called for the first time. */ public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() { - if (instance == null) { - synchronized (ThreadSafeLazyLoadedIvoryTower.class) { - if (instance == null) { + if (instance == null) { instance = new ThreadSafeLazyLoadedIvoryTower(); - } } - } return instance; } }

train

test

hmittal657

train

iluwatar/java-design-patterns/1965_2470

iluwatar/java-design-patterns

iluwatar/java-design-patterns/1965

iluwatar/java-design-patterns/2470

c741814b367f004787ef2f87665cc00b5f07b35e

18b1d5195f5ced99a4dc9cb12157aac97b6e2ffc

Translation error


diff --git a/localization/zh/abstract-factory/README.md b/localization/zh/abstract-factory/README.md index 5241e31c7ba5..092d87624132 100644 --- a/localization/zh/abstract-factory/README.md +++ b/localization/zh/abstract-factory/README.md @@ -18,7 +18,7 @@ tag: 真实世界例子 -> 要创建一个王国，我们需要具有共同主题的对象。 精灵王国需要精灵王，精灵城堡和精灵军队，而兽人王国需要兽王，精灵城堡和兽人军队。 王国中的对象之间存在依赖性。 +> 要创建一个王国，我们需要具有共同主题的对象。精灵王国需要精灵国王、精灵城堡和精灵军队，而兽人王国需要兽人国王、兽人城堡和兽人军队。王国中的对象之间存在依赖关系。 通俗的说

train

test

liuyangyudaxia

train

iluwatar/java-design-patterns/2472_2474

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2472

iluwatar/java-design-patterns/2474

1fa80eb74cd9d69aae394c4e730db82bb1f2d904

188f35aafc99c40523e3f154f1fe04a558a679c0

Translate the api-gateway readme to Spanish.

Hello, I will continue with the spanish translations for readme files [here](https://github.com/iluwatar/java-design-patterns/issues/2277), next one is api-gateway, I will place it under localization.es.api-gateway

diff --git a/localization/es/api-gateway/README.md b/localization/es/api-gateway/README.md new file mode 100644 index 000000000000..b2336313fded --- /dev/null +++ b/localization/es/api-gateway/README.md @@ -0,0 +1,168 @@ +--- +title: API Gateway +category: Architectural +language: es +tag: + - Cloud distributed + - Decoupling + - Microservices +--- + +## Motivo + +Agregar llamadas a los microservicios en un mismo lugar, la puerta de enlace API (API Gateway). El usuario +hace un llamada simple al API Gateway, y la API Gateway hace la llamada a cada microservicio relevante. + +## Explicaición + +Con el patrón de microservicios, el cliente puede necesitar datos de múltiples microservicios. Si el +cliente llamara a cada microservicio de forma directe, podría ocasionar tiempos de carga largos, ya que +el cliente tendría que hacer una solicitud de red para cada microservicio llamado. Además, tener la +la llamada del cliente a cada microservicio vincula directamente al cliente con ese microservicio - si la +implementacion interna del cambio de microservicios (por ejemplo, si dos microservicios se combinan en +algún momento en el futuro) o si la ubicación (host y puerto) de un microservicio cambia, entonces cada +cliente que hace uso de esos microservicios debe ser actualizado. + +La intención del patrón API Gateway es aliviar algunos de estos problemas. En el patrón API Gateway, +se coloca una entidad adicional (la API Gateway) entre el cliente y los microservicios. +El trabajo de API Gateway es agregar las llamadas a los microservicios. En lugar de que el cliente +llame a cada microservicio individualmente, el cliente llama al API Gateway una sola vez. la API +Gateway luego llama a cada uno de los microservicios que necesita el cliente. + +Ejemplo real + +> Estamos implementando un sistema de microservicios y API Gateway para un sitio e-commerce. En este +> sistema API Gateway realiza llamadas a los microservicios Image y Price. (Imagen y Precio) + +En otras palabras + +> Para un sistema implementado utilizando una arquitectura de microservicios, API Gateway es el único +> punto de entrada que agrega las llamadas a los microservicios individuales. + +Wikipedia dice + +> API Gateway es un servidor que actúa como un front-end de API, recibe solicitudes de API, aplica la +> limitación y políticas de seguridad, pasa las solicitudes al servicio back-end y luego devuelve la +> respuesta al solicitante. Una puerta de enlace a menudo incluye un motor de transformación para +> orquestar y modificar las solicitudes y respuestas sobre la marcha. Una puerta de enlace también +> puede proporcionar funciones como recopilar análisis de datos y almacenamiento en caché. La puerta +> de enlace puede proporcionar funcionalidad para soportar autenticación, autorización, seguridad, +> auditoría y cumplimiento normativo. + +**Código de ejemplo** + +Esta implementación muestra cómo podría verse el patrón API Gateway para un sitio de e-commerce. El +`ApiGateway` hace llamadas a los microservicios Image y Price usando `ImageClientImpl` y`PriceClientImpl` +respectivamente. Los clientes que ven el sitio en un dispositivo de escritorio pueden ver la información +de precio y una imagen de un producto, entonces `ApiGateway` llama a los microservicios y +agrega los datos en el modelo `DesktopProduct`. Sin embargo, los usuarios de dispositivos móviles solo +ven información de precios, no ven una imagen del producto. Para usuarios móviles, `ApiGateway` solo +recupera el precio información, que utiliza para completar el `MobileProduct`. + +Aquí está la implementación del microservicio de imagen (Image). + +```java +public interface ImageClient { + String getImagePath(); +} + +public class ImageClientImpl implements ImageClient { + @Override + public String getImagePath() { + var httpClient = HttpClient.newHttpClient(); + var httpGet = HttpRequest.newBuilder() + .GET() + .uri(URI.create("http://localhost:50005/image-path")) + .build(); + + try { + var httpResponse = httpClient.send(httpGet, BodyHandlers.ofString()); + return httpResponse.body(); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + } + + return null; + } +} +``` + +Aquí está la implementación del microservicio de precio (Price). + +```java +public interface PriceClient { + String getPrice(); +} + +public class PriceClientImpl implements PriceClient { + + @Override + public String getPrice() { + var httpClient = HttpClient.newHttpClient(); + var httpGet = HttpRequest.newBuilder() + .GET() + .uri(URI.create("http://localhost:50006/price")) + .build(); + + try { + var httpResponse = httpClient.send(httpGet, BodyHandlers.ofString()); + return httpResponse.body(); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + } + + return null; + } +} +``` + +Aquí podemos ver cómo API Gateway asigna las solicitudes a los microservicios. + +```java +public class ApiGateway { + + @Resource + private ImageClient imageClient; + + @Resource + private PriceClient priceClient; + + @RequestMapping(path = "/desktop", method = RequestMethod.GET) + public DesktopProduct getProductDesktop() { + var desktopProduct = new DesktopProduct(); + desktopProduct.setImagePath(imageClient.getImagePath()); + desktopProduct.setPrice(priceClient.getPrice()); + return desktopProduct; + } + + @RequestMapping(path = "/mobile", method = RequestMethod.GET) + public MobileProduct getProductMobile() { + var mobileProduct = new MobileProduct(); + mobileProduct.setPrice(priceClient.getPrice()); + return mobileProduct; + } +} +``` + +## Diagrama de clase + + + +## Aplicaciones + +Usa el patrón de API Gateway cuando + +* Estés usando una arquitectura de microservicios y necesites un único punto de agregación para las llamadas de microservicios. + +## Tutoriales + +* [Exploring the New Spring Cloud Gateway](https://www.baeldung.com/spring-cloud-gateway) +* [Spring Cloud - Gateway](https://www.tutorialspoint.com/spring_cloud/spring_cloud_gateway.htm) +* [Getting Started With Spring Cloud Gateway](https://dzone.com/articles/getting-started-with-spring-cloud-gateway) + +## Créditos + +* [microservices.io - API Gateway](http://microservices.io/patterns/apigateway.html) +* [NGINX - Building Microservices: Using an API Gateway](https://www.nginx.com/blog/building-microservices-using-an-api-gateway/) +* [Microservices Patterns: With examples in Java](https://www.amazon.com/gp/product/1617294543/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617294543&linkId=ac7b6a57f866ac006a309d9086e8cfbd) +* [Building Microservices: Designing Fine-Grained Systems](https://www.amazon.com/gp/product/1491950358/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1491950358&linkId=4c95ca9831e05e3f0dadb08841d77bf1)

train

test

TheClerici

train

iluwatar/java-design-patterns/2476_2477

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2476

iluwatar/java-design-patterns/2477

c34ad292e3de91e2aa3ede878a9d929e3a6b7477

207cf60bc6b7e4b2e912c51ea564e4eaf3f851cd

Typo in README in Russian

ускорить процесс разработк`у` -> ускорить процесс разработк`и`

diff --git a/localization/ru/README.md b/localization/ru/README.md index a52020200830..89e4ddffc317 100644 --- a/localization/ru/README.md +++ b/localization/ru/README.md @@ -17,7 +17,7 @@ Шаблоны проектирования - лучший метод для решения проблем, возникающих во время разработки приложения или системы. -Шаблоны проектирования могут ускорить процесс разработку путем предоставления +Шаблоны проектирования могут ускорить процесс разработки путем предоставления проверенных моделей/парадигм. Использование шаблонов повторно поможет избежать частых проблем, из-за которых

train

test

ramilS

train

iluwatar/java-design-patterns/2479_2480

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2479

iluwatar/java-design-patterns/2480

91321c83778adfa40f449ad18008c33c5e6237ca

84f7ab8006f4ba0f193e02362297ff8ba2701542

Translate arrange-act-assert to spanish (Task of issue #2277)

Translation of [arrange-act-assert/README.md](https://github.com/iluwatar/java-design-patterns/blob/master/arrange-act-assert/README.md) to [java-design-patterns/localization/es/arrange-act-assert/](https://github.com/iluwatar/java-design-patterns/tree/master/localization/es/) folder Task of issue #2277

diff --git a/localization/es/arrange-act-assert/README.md b/localization/es/arrange-act-assert/README.md new file mode 100644 index 000000000000..d5411e63b7ad --- /dev/null +++ b/localization/es/arrange-act-assert/README.md @@ -0,0 +1,140 @@ +--- +title: Arrange/Act/Assert +category: Idiom +language: es +tag: + - Testing +--- + +## También conocido como + +Dado/Cuando/Entonces + +## Intención + +Arrange/Act/Assert (AAA) es un patrón para organizar UnitTests. +Divide las UnitTests en tres pasos claros y diferenciados: + +1. Arrange(Organizar): Realiza la configuración y la inicialización necesarias para el test. +2. Act(Actuar): Toma las medidas necesarias para el test. +3. Assert(Afirmar): Verifica los resultados del test. + +## Explicacación + +Este patrón tiene varios beneficios significativos. Crea una clara separación entre la configuración, operaciones y resultados de un test. Esta estructura hace que el código sea más fácil de leer y comprender. Si +colocas los pasos en orden y formateas su código para separarlos, puedes escanear un test y +comprender rápidamente lo que hace. + +También impone un cierto grado de disciplina cuando escribes tus UnitTests. Tienes que visualizar +claramente los tres pasos que tu test realizará. Esto hace que los tests sean más intuitivos de escribir a la vez que tienes presente un esquema. + +Ejemplo cotidiano + +> Necesitamos escribir un conjunto de UnitTests completo y claro para una clase. + +En otras palabras + +> Arrange/Act/Assert es un patrón de testeo que organiza las pruebas en tres pasos claros para facilitar su +> mantenimiento. + +WikiWikiWeb dice + +> Arrange/Act/Assert es un patrón para organizar y dar formato al código en los métodos UnitTest. + +**Código de ejemplo** + +Veamos primero nuestra clase `Cash` para que sea testeada. + +```java +public class Cash { + + private int amount; + + Cash(int amount) { + this.amount = amount; + } + + void plus(int addend) { + amount += addend; + } + + boolean minus(int subtrahend) { + if (amount >= subtrahend) { + amount -= subtrahend; + return true; + } else { + return false; + } + } + + int count() { + return amount; + } +} +``` + +Luego escribimos nuestras UnitTests en función del patrón Arrange/Act/Assert. Note claramente la separación de los pasos para cada UnitTest. + +```java +class CashAAATest { + + @Test + void testPlus() { + //Arrange + var cash = new Cash(3); + //Act + cash.plus(4); + //Assert + assertEquals(7, cash.count()); + } + + @Test + void testMinus() { + //Arrange + var cash = new Cash(8); + //Act + var result = cash.minus(5); + //Assert + assertTrue(result); + assertEquals(3, cash.count()); + } + + @Test + void testInsufficientMinus() { + //Arrange + var cash = new Cash(1); + //Act + var result = cash.minus(6); + //Assert + assertFalse(result); + assertEquals(1, cash.count()); + } + + @Test + void testUpdate() { + //Arrange + var cash = new Cash(5); + //Act + cash.plus(6); + var result = cash.minus(3); + //Assert + assertTrue(result); + assertEquals(8, cash.count()); + } +} +``` + +## Aplicabilidad + +Utilice el patrón Arrange/Act/Asert cuando + +* Necesites estructurar tus UnitTests para que sean más fáciles de leer, mantener y mejorar. + +## Créditos + +* [Arrange, Act, Assert: ¿Qué son las pruebas AAA?](https://blog.ncrunch.net/post/arrange-act-assert-aaa-testing.aspx) +* [Bill Wake: 3A – Arrange, Act, Assert](https://xp123.com/articles/3a-arrange-act-assert/) +* [Martin Fowler: DadoCuandoEntonces](https://martinfowler.com/bliki/GivenWhenThen.html) +* [Patrones de prueba xUnit: Refactorizando Código de prueba](https://www.amazon.com/gp/product/0131495054/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0131495054&linkId=99701e8f4af2f63d0bcf50) +* [Principios, prácticas y patrones UnitTesting](https://www.amazon.com/gp/product/1617296279/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617296279&linkId=74c75cfae3a5a)accae3a5a) +* [Desarrollo basado en pruebas: Ejemplo](https://www.amazon.com/gp/product/0321146530/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321146530&linkId=5c63a93d8c1175b47caef50875) diff --git a/localization/es/async-method-invocation/README.md b/localization/es/async-method-invocation/README.md new file mode 100644 index 000000000000..756f686767f6 --- /dev/null +++ b/localization/es/async-method-invocation/README.md @@ -0,0 +1,168 @@ +--- +title: Async Method Invocation +category: Concurrency +language: es +tag: + - Reactive +--- + +## Propósito + +Asynchronous method invocation (invocación de método asincrónico) es un patrón con el que el hilo o subproceso de llamada +no se bloquea mientras espera resultados. El patrón proporciona pocesamiento en paralelo de múltiples tareas independientes y recupera los resultados a través de +devoluciones de llamada (callbacks) o esperando hasta que termine el procedimiento. + +## Explicación + +Ejemplo cotidiano + +> Lanzar cohetes espaciales es un negocio apasionante. El comandante de la misión da la orden de lanzamiento y +> después de un tiempo indeterminado, el cohete se lanza con éxito o falla miserablemente. + +En otras palabras + +> La invocación del método asíncrono inicia el procedimiento y vuelve inmediatamente antes de que la tarea termine +> Los resultados del procedimiento se devuelven a la llamada posteriormente (callback). + +Según Wikipedia + +> En la programación multiproceso, la invocación de método asíncrono (AMI), también conocida como +> llamadas de método asíncrono o el patrón asíncrono es un patrón de diseño en el que el lugar de la llamada +> no se bloquea mientras espera que termine el código llamado. En cambio, el hilo de llamada es +> notificado cuando llega la respuesta. Sondear para obtener una respuesta es una opción no deseada. + +**Ejemplo programático** + +En este ejemplo, estamos lanzando cohetes espaciales y desplegando vehículos lunares. + +La aplicación demuestra lo que hace el patrón de invocación del método asíncrono. Las partes clave del patrón son +`AsyncResult` que es un contenedor intermedio para un valor evaluado de forma asíncrona, +`AsyncCallback` que se puede proporcionar para que se ejecute al finalizar la tarea y `AsyncExecutor` que +gestiona la ejecución de las tareas asíncronas. + +```java +public interface AsyncResult<T> { + boolean isCompleted(); + T getValue() throws ExecutionException; + void await() throws InterruptedException; +} +``` + +```java +public interface AsyncCallback<T> { + void onComplete(T value, Optional<Exception> ex); +} +``` + +```java +public interface AsyncExecutor { + <T> AsyncResult<T> startProcess(Callable<T> task); + <T> AsyncResult<T> startProcess(Callable<T> task, AsyncCallback<T> callback); + <T> T endProcess(AsyncResult<T> asyncResult) throws ExecutionException, InterruptedException; +} +``` + +`ThreadAsyncExecutor` es una implementación de `AsyncExecutor`. Se destacan algunas de sus partes clave a continuación. + +```java +public class ThreadAsyncExecutor implements AsyncExecutor { + + @Override + public <T> AsyncResult<T> startProcess(Callable<T> task) { + return startProcess(task, null); + } + + @Override + public <T> AsyncResult<T> startProcess(Callable<T> task, AsyncCallback<T> callback) { + var result = new CompletableResult<>(callback); + new Thread( + () -> { + try { + result.setValue(task.call()); + } catch (Exception ex) { + result.setException(ex); + } + }, + "executor-" + idx.incrementAndGet()) + .start(); + return result; + } + + @Override + public <T> T endProcess(AsyncResult<T> asyncResult) + throws ExecutionException, InterruptedException { + if (!asyncResult.isCompleted()) { + asyncResult.await(); + } + return asyncResult.getValue(); + } +} +``` + +Ahora está todo preparado para lanzar algunos cohetes y así poder ver cómo funciona todo. + +```java +public static void main(String[] args) throws Exception { + // construye un nuevo objeto executor que ejecutará tareas asíncronas + var executor = new ThreadAsyncExecutor(); + + // inicia algunas tareas asíncronas con diferentes tiempos de procesamiento, las dos últimas con controladores de devolución de llamada + final var asyncResult1 = executor.startProcess(lazyval(10, 500)); + final var asyncResult2 = executor.startProcess(lazyval("test", 300)); + final var asyncResult3 = executor.startProcess(lazyval(50L, 700)); + final var asyncResult4 = executor.startProcess(lazyval(20, 400), callback("Desplegando el rover lunar")); + final var asyncResult5 = + executor.startProcess(lazyval("devolución de llamada callback", 600), callback("Desplegando el rover lunar")); + + // emula el procesamiento en el hilo o subproceso actual mientras las tareas asíncronas se ejecutan en sus propios hilos o subprocesos + Subproceso.dormir(350); // Oye, estamos trabajando duro aquí + log("El comandante de la misión está bebiendo café"); + + // espera a que se completen las tareas + final var result1 = executor.endProcess(asyncResult1); + final var result2 = executor.endProcess(asyncResult2); + final var result3 = executor.endProcess(asyncResult3); + asyncResult4.await(); + asyncResult5.await(); + + // registra los resultados de las tareas, las devoluciones de las llamadas se registran inmediatamente cuando se completan + log("Cohete espacial <" + resultado1 + "> ha completado su lanzamiento"); + log("Cohete espacial <" + resultado2 + "> ha completado su lanzamiento"); + log("Cohete espacial <" + result3 + "> ha completado su lanzamiento"); +} +``` + +Aquí está la salida de la consola del programa. + +```java +21:47:08.227 [executor-2] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <prueba> lanzado con éxito +21:47:08.269 [main] INFO com.iluwatar.async.method.invocation.App - El comandante de la misión está bebiendo café +21:47:08.318 [executor-4] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <20> lanzado con éxito +21:47:08.335 [executor-4] INFO com.iluwatar.async.method.invocation.App Desplegando el rover lunar <20> +21:47:08.414 [executor-1] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <10> lanzado con éxito +21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <devolución de llamada callback> lanzado con éxito +21:47:08.519 [executor-5] INFO com.iluwatar.async.method.invocation.App - Implementando el vehículo lunar <devolución de llamada callback> +21:47:08.616 [executor-3] INFO com.iluwatar.async.method.invocation.App - Cohete espacial <50> lanzado con éxito +21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <10> completado +21:47:08.617 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento de cohete espacial <prueba> completado +21:47:08.618 [main] INFO com.iluwatar.async.method.invocation.App - Lanzamiento del cohete espacial <50> completado +``` + +# Diagrama de clase + + + +## Aplicabilidad + +Utiliza el patrón de invocación del método asíncrono cuando + +* Tienes múltiples tareas independientes que pueden ejecutarse en paralelo +* Necesitas mejorar el desempeño de un grupo de tareas secuenciales +* Tienes una cantidad limitada de capacidad de procesamiento o tareas de ejecución prolongada y la llamada no debe esperar a que las tareas estén listas + +## Ejemplos cotidianos + +* [FutureTask](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/FutureTask.html) +* [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html) +* [ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html) +* [Patrón asíncrono basado en tareas](https://msdn.microsoft.com/en-us/library/hh873175.aspx) \ No newline at end of file

train

test

KarmaTashiCat

train

iluwatar/java-design-patterns/2462_2484

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2462

iluwatar/java-design-patterns/2484

4bea173e642ce550d84075af0e43efa7f61be359

b0cc0943f986af20fd7632423d8786fb82ad6dfb

Wrong generic type for deques in command README

Hi, inside the README.md for the command pattern the Wizard class presents these two instance variables: ```java private final Deque<Command> undoStack = new LinkedList<>(); private final Deque<Command> redoStack = new LinkedList<>(); ``` The generic type for these deques should be ```Runnable``` as it is in the Wizard class under src directory

diff --git a/command/README.md b/command/README.md index 476edc47af39..a3b863b78cbe 100644 --- a/command/README.md +++ b/command/README.md @@ -40,8 +40,8 @@ Here's the sample code with wizard and goblin. Let's start from the `Wizard` cla @Slf4j public class Wizard { - private final Deque<Command> undoStack = new LinkedList<>(); - private final Deque<Command> redoStack = new LinkedList<>(); + private final Deque<Runnable> undoStack = new LinkedList<>(); + private final Deque<Runnable> redoStack = new LinkedList<>(); public Wizard() {} diff --git a/localization/zh/command/README.md b/localization/zh/command/README.md index a36bddfa9db1..9c34bca0e08e 100644 --- a/localization/zh/command/README.md +++ b/localization/zh/command/README.md @@ -34,8 +34,8 @@ public class Wizard { private static final Logger LOGGER = LoggerFactory.getLogger(Wizard.class); - private final Deque<Command> undoStack = new LinkedList<>(); - private final Deque<Command> redoStack = new LinkedList<>(); + private final Deque<Runnable> undoStack = new LinkedList<>(); + private final Deque<Runnable> redoStack = new LinkedList<>(); public Wizard() {}

train

test

AddeusExMachina

train

iluwatar/java-design-patterns/2445_2518

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2445

iluwatar/java-design-patterns/2518

cf64d6ae9a2196b0b9f190922c68e789484592eb

4808865c0bb91c5f6a8842e77551a244945d66c3

Refactor event sourcing

I'll refactor some codes of event sourcing pattern. The specific tasks I suggest are listed below. - [ ] remove the use of deprecated `JsonParser` - [ ] use jackson `ObjectMapper` instead of `Gson` - [ ] fix some warnings checked by sonarlint

diff --git a/event-sourcing/pom.xml b/event-sourcing/pom.xml index ae609d67e76b..569a5fceebd8 100644 --- a/event-sourcing/pom.xml +++ b/event-sourcing/pom.xml @@ -40,8 +40,8 @@ <scope>test</scope> </dependency> <dependency> - <groupId>com.google.code.gson</groupId> - <artifactId>gson</artifactId> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-databind</artifactId> </dependency> </dependencies> <build> diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/app/App.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/app/App.java index d356a8b99f8a..4b90c6ae0bdb 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/app/App.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/app/App.java @@ -28,6 +28,7 @@ import com.iluwatar.event.sourcing.event.MoneyDepositEvent; import com.iluwatar.event.sourcing.event.MoneyTransferEvent; import com.iluwatar.event.sourcing.processor.DomainEventProcessor; +import com.iluwatar.event.sourcing.processor.JsonFileJournal; import com.iluwatar.event.sourcing.state.AccountAggregate; import java.math.BigDecimal; import java.util.Date; @@ -42,16 +43,18 @@ * transactional data, and maintain full audit trails and history that can enable compensating * actions. * - * <p>This App class is an example usage of an Event Sourcing pattern. As an example, two bank accounts - * are created, then some money deposit and transfer actions are taken, so a new state of accounts is - * created. At that point, state is cleared in order to represent a system shut-down. After the shut-down, - * system state is recovered by re-creating the past events from event journals. Then state is - * printed so a user can view the last state is same with the state before a system shut-down. + * <p>This App class is an example usage of an Event Sourcing pattern. As an example, two bank + * accounts are created, then some money deposit and transfer actions are taken, so a new state of + * accounts is created. At that point, state is cleared in order to represent a system shut-down. + * After the shut-down, system state is recovered by re-creating the past events from event + * journals. Then state is printed so a user can view the last state is same with the state before a + * system shut-down. * * <p>Created by Serdar Hamzaogullari on 06.08.2017. */ @Slf4j public class App { + /** * The constant ACCOUNT OF DAENERYS. */ @@ -68,8 +71,7 @@ public class App { */ public static void main(String[] args) { - var eventProcessor = new DomainEventProcessor(); - + var eventProcessor = new DomainEventProcessor(new JsonFileJournal()); LOGGER.info("Running the system first time............"); eventProcessor.reset(); @@ -103,7 +105,7 @@ public static void main(String[] args) { LOGGER.info("Recover the system by the events in journal file............"); - eventProcessor = new DomainEventProcessor(); + eventProcessor = new DomainEventProcessor(new JsonFileJournal()); eventProcessor.recover(); LOGGER.info("...............Recovered State:............"); diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/AccountCreateEvent.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/AccountCreateEvent.java index 9e6b40e62ee0..f3f4e78e6ab3 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/AccountCreateEvent.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/AccountCreateEvent.java @@ -24,14 +24,15 @@ */ package com.iluwatar.event.sourcing.event; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; import com.iluwatar.event.sourcing.domain.Account; import com.iluwatar.event.sourcing.state.AccountAggregate; import lombok.Getter; /** - * This is the class that implements account created event. - * Holds the necessary info for an account created event. - * Implements the process function that finds the event-related domain objects and + * This is the class that implements account created event. Holds the necessary info for an account + * created event. Implements the process function that finds the event-related domain objects and * calls the related domain object's handle event functions * * <p>Created by Serdar Hamzaogullari on 06.08.2017. @@ -50,7 +51,10 @@ public class AccountCreateEvent extends DomainEvent { * @param accountNo the account no * @param owner the owner */ - public AccountCreateEvent(long sequenceId, long createdTime, int accountNo, String owner) { + @JsonCreator + public AccountCreateEvent(@JsonProperty("sequenceId") long sequenceId, + @JsonProperty("createdTime") long createdTime, + @JsonProperty("accountNo") int accountNo, @JsonProperty("owner") String owner) { super(sequenceId, createdTime, "AccountCreateEvent"); this.accountNo = accountNo; this.owner = owner; diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyDepositEvent.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyDepositEvent.java index 96afd4640012..07e88bc0ea28 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyDepositEvent.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyDepositEvent.java @@ -24,6 +24,8 @@ */ package com.iluwatar.event.sourcing.event; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; import com.iluwatar.event.sourcing.state.AccountAggregate; import java.math.BigDecimal; import java.util.Optional; @@ -50,7 +52,10 @@ public class MoneyDepositEvent extends DomainEvent { * @param accountNo the account no * @param money the money */ - public MoneyDepositEvent(long sequenceId, long createdTime, int accountNo, BigDecimal money) { + @JsonCreator + public MoneyDepositEvent(@JsonProperty("sequenceId") long sequenceId, + @JsonProperty("createdTime") long createdTime, + @JsonProperty("accountNo") int accountNo, @JsonProperty("money") BigDecimal money) { super(sequenceId, createdTime, "MoneyDepositEvent"); this.money = money; this.accountNo = accountNo; diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyTransferEvent.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyTransferEvent.java index 18d98cded008..3b4fa1ed1bb0 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyTransferEvent.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/event/MoneyTransferEvent.java @@ -24,6 +24,8 @@ */ package com.iluwatar.event.sourcing.event; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; import com.iluwatar.event.sourcing.state.AccountAggregate; import java.math.BigDecimal; import java.util.Optional; @@ -52,8 +54,11 @@ public class MoneyTransferEvent extends DomainEvent { * @param accountNoFrom the account no from * @param accountNoTo the account no to */ - public MoneyTransferEvent(long sequenceId, long createdTime, BigDecimal money, int accountNoFrom, - int accountNoTo) { + @JsonCreator + public MoneyTransferEvent(@JsonProperty("sequenceId") long sequenceId, + @JsonProperty("createdTime") long createdTime, + @JsonProperty("money") BigDecimal money, @JsonProperty("accountNoFrom") int accountNoFrom, + @JsonProperty("accountNoTo") int accountNoTo) { super(sequenceId, createdTime, "MoneyTransferEvent"); this.money = money; this.accountNoFrom = accountNoFrom; diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/DomainEventProcessor.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/DomainEventProcessor.java index e1f11eebec6b..cdfe44e336b2 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/DomainEventProcessor.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/DomainEventProcessor.java @@ -28,13 +28,17 @@ /** * This is the implementation of event processor. All events are processed by this class. This - * processor uses processorJournal to persist and recover events. + * processor uses eventJournal to persist and recover events. * * <p>Created by Serdar Hamzaogullari on 06.08.2017. */ public class DomainEventProcessor { - private final JsonFileJournal processorJournal = new JsonFileJournal(); + private final EventJournal eventJournal; + + public DomainEventProcessor(EventJournal eventJournal) { + this.eventJournal = eventJournal; + } /** * Process. @@ -43,14 +47,14 @@ public class DomainEventProcessor { */ public void process(DomainEvent domainEvent) { domainEvent.process(); - processorJournal.write(domainEvent); + eventJournal.write(domainEvent); } /** * Reset. */ public void reset() { - processorJournal.reset(); + eventJournal.reset(); } /** @@ -58,7 +62,7 @@ public void reset() { */ public void recover() { DomainEvent domainEvent; - while ((domainEvent = processorJournal.readNext()) != null) { + while ((domainEvent = eventJournal.readNext()) != null) { domainEvent.process(); } } diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/EventJournal.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/EventJournal.java new file mode 100644 index 000000000000..49bc89582a13 --- /dev/null +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/EventJournal.java @@ -0,0 +1,37 @@ +package com.iluwatar.event.sourcing.processor; + +import com.iluwatar.event.sourcing.event.DomainEvent; +import java.io.File; +import lombok.extern.slf4j.Slf4j; + +/** + * Base class for Journaling implementations. + */ +@Slf4j +public abstract class EventJournal { + + File file; + + /** + * Write. + * + * @param domainEvent the domain event. + */ + abstract void write(DomainEvent domainEvent); + + /** + * Reset. + */ + void reset() { + if (file.delete()) { + LOGGER.info("File cleared successfully............"); + } + } + + /** + * Read domain event. + * + * @return the domain event. + */ + abstract DomainEvent readNext(); +} diff --git a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/JsonFileJournal.java b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/JsonFileJournal.java index 048e270e2eaa..cfde566dc2fb 100644 --- a/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/JsonFileJournal.java +++ b/event-sourcing/src/main/java/com/iluwatar/event/sourcing/processor/JsonFileJournal.java @@ -24,9 +24,8 @@ */ package com.iluwatar.event.sourcing.processor; -import com.google.gson.Gson; -import com.google.gson.JsonElement; -import com.google.gson.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; import com.iluwatar.event.sourcing.event.AccountCreateEvent; import com.iluwatar.event.sourcing.event.DomainEvent; import com.iluwatar.event.sourcing.event.MoneyDepositEvent; @@ -49,9 +48,8 @@ * * <p>Created by Serdar Hamzaogullari on 06.08.2017. */ -public class JsonFileJournal { +public class JsonFileJournal extends EventJournal { - private final File file; private final List<String> events = new ArrayList<>(); private int index = 0; @@ -81,22 +79,12 @@ public JsonFileJournal() { * * @param domainEvent the domain event */ + @Override public void write(DomainEvent domainEvent) { - var gson = new Gson(); - JsonElement jsonElement; - if (domainEvent instanceof AccountCreateEvent) { - jsonElement = gson.toJsonTree(domainEvent, AccountCreateEvent.class); - } else if (domainEvent instanceof MoneyDepositEvent) { - jsonElement = gson.toJsonTree(domainEvent, MoneyDepositEvent.class); - } else if (domainEvent instanceof MoneyTransferEvent) { - jsonElement = gson.toJsonTree(domainEvent, MoneyTransferEvent.class); - } else { - throw new RuntimeException("Journal Event not recognized"); - } - + var mapper = new ObjectMapper(); try (var output = new BufferedWriter( new OutputStreamWriter(new FileOutputStream(file, true), StandardCharsets.UTF_8))) { - var eventString = jsonElement.toString(); + var eventString = mapper.writeValueAsString(domainEvent); output.write(eventString + "\r\n"); } catch (IOException e) { throw new RuntimeException(e); @@ -104,14 +92,6 @@ public void write(DomainEvent domainEvent) { } - /** - * Reset. - */ - public void reset() { - file.delete(); - } - - /** * Read the next domain event. * @@ -124,19 +104,19 @@ public DomainEvent readNext() { var event = events.get(index); index++; - var parser = new JsonParser(); - var jsonElement = parser.parse(event); - var eventClassName = jsonElement.getAsJsonObject().get("eventClassName").getAsString(); - var gson = new Gson(); + var mapper = new ObjectMapper(); DomainEvent domainEvent; - if (eventClassName.equals("AccountCreateEvent")) { - domainEvent = gson.fromJson(jsonElement, AccountCreateEvent.class); - } else if (eventClassName.equals("MoneyDepositEvent")) { - domainEvent = gson.fromJson(jsonElement, MoneyDepositEvent.class); - } else if (eventClassName.equals("MoneyTransferEvent")) { - domainEvent = gson.fromJson(jsonElement, MoneyTransferEvent.class); - } else { - throw new RuntimeException("Journal Event not recegnized"); + try { + var jsonElement = mapper.readTree(event); + var eventClassName = jsonElement.get("eventClassName").asText(); + domainEvent = switch (eventClassName) { + case "AccountCreateEvent" -> mapper.treeToValue(jsonElement, AccountCreateEvent.class); + case "MoneyDepositEvent" -> mapper.treeToValue(jsonElement, MoneyDepositEvent.class); + case "MoneyTransferEvent" -> mapper.treeToValue(jsonElement, MoneyTransferEvent.class); + default -> throw new RuntimeException("Journal Event not recognized"); + }; + } catch (JsonProcessingException jsonProcessingException) { + throw new RuntimeException("Failed to convert JSON"); } domainEvent.setRealTime(false);

diff --git a/event-sourcing/src/test/java/IntegrationTest.java b/event-sourcing/src/test/java/IntegrationTest.java index 9e15a2163bcc..c737bd0da43d 100644 --- a/event-sourcing/src/test/java/IntegrationTest.java +++ b/event-sourcing/src/test/java/IntegrationTest.java @@ -22,6 +22,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ + import static com.iluwatar.event.sourcing.app.App.ACCOUNT_OF_DAENERYS; import static com.iluwatar.event.sourcing.app.App.ACCOUNT_OF_JON; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -30,6 +31,7 @@ import com.iluwatar.event.sourcing.event.MoneyDepositEvent; import com.iluwatar.event.sourcing.event.MoneyTransferEvent; import com.iluwatar.event.sourcing.processor.DomainEventProcessor; +import com.iluwatar.event.sourcing.processor.JsonFileJournal; import com.iluwatar.event.sourcing.state.AccountAggregate; import java.math.BigDecimal; import java.util.Date; @@ -53,7 +55,7 @@ class IntegrationTest { */ @BeforeEach void initialize() { - eventProcessor = new DomainEventProcessor(); + eventProcessor = new DomainEventProcessor(new JsonFileJournal()); } /** @@ -84,7 +86,7 @@ void testStateRecovery() { AccountAggregate.resetState(); - eventProcessor = new DomainEventProcessor(); + eventProcessor = new DomainEventProcessor(new JsonFileJournal()); eventProcessor.recover(); var accountOfDaenerysAfterShotDown = AccountAggregate.getAccount(ACCOUNT_OF_DAENERYS);

test

test

hwan33

train

iluwatar/java-design-patterns/2286_2533

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2286

iluwatar/java-design-patterns/2533

cf64d6ae9a2196b0b9f190922c68e789484592eb

376cd215274d7f9ecb8bc90b1d35e36d567b1654

Translation to Russian

This task tracks the translation of the patterns. More information about the translation process is available at https://github.com/iluwatar/java-design-patterns/wiki/15.-Support-for-multiple-languages Acceptance criteria - The patterns have been translated - The patterns can be browsed in Github and on the website https://java-design-patterns.com

diff --git a/localization/ru/abstract-factory/README.md b/localization/ru/abstract-factory/README.md new file mode 100644 index 000000000000..044e03c53c5c --- /dev/null +++ b/localization/ru/abstract-factory/README.md @@ -0,0 +1,237 @@ +--- +title: Abstract Factory +category: Creational +language: ru +tag: + - Gang of Four +--- + +## Альтернативные названия +Kit + +## Цель +Предоставление интерфейса для создания семейств взаимосвязанных или взаимозависимых объектов без указания их конкретных классов. + +## Объяснение +Пример из реального мира: +> Представьте, что вы хотите создать королевство с замком, королём и армией. Эльфийскому королевству понадобится эльфийский замок, эльфийский король и эльфийская армия, в то время как оркскому королевству понадобится оркский замок, оркский король и оркская армия. Между объектами королевства существует взаимозависимость. + +Простыми словами: +> Фабрика фабрик; фабрика, которая объединяет отдельные, но взаимозависимые/взаимозаменяемые фабрики без указания их конкретных классов. + +Википедия пишет: +> Порождающий шаблон проектирования, предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов, не специфицируя их конкретных классов. + +**Программный пример**\ +Основываясь на примере королевства выше, во-первых, нам понадобятся интерфейсы и реализации для объектов в королевстве. + +```java +public interface Castle { + String getDescription(); +} + +public interface King { + String getDescription(); +} + +public interface Army { + String getDescription(); +} + +// Эльфийская реализация +public class ElfCastle implements Castle { + static final String DESCRIPTION = "Это эльфийский замок!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class ElfKing implements King { + static final String DESCRIPTION = "Это эльфийский король!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class ElfArmy implements Army { + static final String DESCRIPTION = "Это эльфийская армия!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} + +// Оркская реализация +public class OrcCastle implements Castle { + static final String DESCRIPTION = "Это оркский замок!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class OrcKing implements King { + static final String DESCRIPTION = "Это оркский король!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class OrcArmy implements Army { + static final String DESCRIPTION = "Это оркская армия!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +``` + +Во-вторых, нам понадобятся абстракция фабрики королевства, а также реализации этой абстракции: + +```java +public interface KingdomFactory { + Castle createCastle(); + King createKing(); + Army createArmy(); +} + +public class ElfKingdomFactory implements KingdomFactory { + + @Override + public Castle createCastle() { + return new ElfCastle(); + } + + @Override + public King createKing() { + return new ElfKing(); + } + + @Override + public Army createArmy() { + return new ElfArmy(); + } +} + +public class OrcKingdomFactory implements KingdomFactory { + + @Override + public Castle createCastle() { + return new OrcCastle(); + } + + @Override + public King createKing() { + return new OrcKing(); + } + + @Override + public Army createArmy() { + return new OrcArmy(); + } +} +``` + +На данный момент, у нас есть абстрактная фабрика, которая позволяет создавать семейство взаимосвязанных объектов, то есть фабрика эльфийского королевства создаёт эльфийский замок, эльфийского короля, эльфийскую армию и так далее: + +```java +var factory = new ElfKingdomFactory(); +var castle = factory.createCastle(); +var king = factory.createKing(); +var army = factory.createArmy(); + +castle.getDescription(); +king.getDescription(); +army.getDescription(); +``` + +Вывод программы: + +``` +Это эльфийский замок! +Это эльфийский король! +Это эльфийская армия! +``` + +Можно спроектировать фабрику для наших различных фабрик королевств. В следующем примере, мы создали `FactoryMaker`, который ответственен за создание экземпляра `ElfKingdomFactory`, либо `OrcKingdomFactory`. + +Клиент может использовать класс `FactoryMaker`, чтобы создать желаемую конкретную фабрику, которая в свою очередь будет производить разные конкретные объекты, унаследованные от `Castle`, `King`, `Army`. + +В этом примере использовано перечисление, чтобы параметризовать то, какую фабрику королевства запрашивает клиент: + +```java +public static class FactoryMaker { + public enum KingdomType { + ELF, ORC + } + + public static KingdomFactory makeFactory(KingdomType type) { + return switch (type) { + case ELF -> new ElfKingdomFactory(); + case ORC -> new OrcKingdomFactory(); + default -> throe new IllegalArgumentException("Данный тип королества не поддерживается.") + } + } +} + + public static void main(String[] args) { + var app = new App(); + + LOGGER.info("Эльфийское королевство"); + app.createKingdom(FactoryMaker.makeFactory(KingdomType.ELF)); + LOGGER.indo(app.getCastle().getDescription()); + LOGGER.indo(app.getKinv().getDescription()); + LOGGER.indo(app.getArmy().getDescription()); + + LOGGER.info("Оркское королевство"); + + app.createKingdom(FactoryMaker.makeFactory(KingdomType.ORC)); + LOGGER.indo(app.getCastle().getDescription()); + LOGGER.indo(app.getKinv().getDescription()); + LOGGER.indo(app.getArmy().getDescription()); + } + +``` + +## Диаграмма классов + + +## Применимость +Используйте шаблон проектирования абстрактная фабрика, когда: + +- Система должна быть независимой от того, как создаются, составляются и представляются её продукты; +- Система должна быть сконфигурирована одним из нескольких семейств продуктов; +- Семейство связанных продуктов спроектировано для совместного использования и вам необходимо обеспечить соблюдение данного ограничения; +- Вы хотите предоставить библиотеку классов, но готовы раскрыть только их интерфейсы, но не реализацию; +- Время жизни зависимости концептуально короче, чем время жизни потребителя; +- Вам требуется значение времени исполнения, чтобы создать требуемую зависимость; +- Вы хотите решить какие продукты из семейства вам нужны во время исполнения; +- Вам нужно предоставить один или несколько параметров, которые известны только во время исполнения прежде, чем вы сможете решить зависимость; +- В случае, когда требуется последовательность среди продуктов; +- Вы не хотите менять существующий код, когда добавляются новые продукты или семейство продуктов в программе. + +Примеры сценариев использования: + +- Выбор необходимой реализации FileSystemAcmeService или DataBaseAcmeSerivce или NetworkAcmeService во времени выполнения; +- Написание модульных тестов становится намного легче; +- Элементы графического пользовательского интерфейса для различных операционных систем. + +## Следствия +- Внедрение зависимости в Java скрывает зависимости класса, приводящие к ошибкам времени выполнения, которые могли-бы быть обнаружены во времени компиляции; +- Данный паттерн проектирования отлично справляется с задачей создания уже определённых объектов, но добавление новых может быть трудоёмким; +- Код становится сложнее, чем ему следует из-за появления большого количества новых интерфейсов и классов, которые появляются вместе с этим паттерном проектирования. + +## Руководства +* [Abstract Factory Pattern Tutorial](https://www.journaldev.com/1418/abstract-factory-design-pattern-in-java) + +## Известные применения +* [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html) +* [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--) +* [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--) + +## Родственные паттерны проектирования +* [Factory Method](https://java-design-patterns.com/patterns/factory-method/) +* [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/) + +## Благодарности +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)

train

test

iluwatar

train

iluwatar/java-design-patterns/187_2538

iluwatar/java-design-patterns

iluwatar/java-design-patterns/187

iluwatar/java-design-patterns/2538

72f7fcab0ea5677e39a8cc064e1c69527a0c309c

1894fcf175a227028cdff4f359e2dbabe0ec36ff

More Singleton wisdom

Analyze the following article from Oracle: https://community.oracle.com/docs/DOC-918906 Improve Singleton examples and their documentation where necessary.

diff --git a/singleton/src/main/java/com/iluwatar/singleton/App.java b/singleton/src/main/java/com/iluwatar/singleton/App.java index af09a7ec6828..8d7946cae95d 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/App.java +++ b/singleton/src/main/java/com/iluwatar/singleton/App.java @@ -100,5 +100,11 @@ public static void main(String[] args) { LOGGER.info(demandHolderIdiom.toString()); var demandHolderIdiom2 = InitializingOnDemandHolderIdiom.getInstance(); LOGGER.info(demandHolderIdiom2.toString()); + + // initialize singleton using Bill Pugh's implementation + var billPughSingleton = BillPughImplementation.getInstance(); + LOGGER.info(billPughSingleton.toString()); + var billPughSingleton2 = BillPughImplementation.getInstance(); + LOGGER.info(billPughSingleton2.toString()); } } diff --git a/singleton/src/main/java/com/iluwatar/singleton/BillPughImplementation.java b/singleton/src/main/java/com/iluwatar/singleton/BillPughImplementation.java new file mode 100644 index 000000000000..ba66386181df --- /dev/null +++ b/singleton/src/main/java/com/iluwatar/singleton/BillPughImplementation.java @@ -0,0 +1,73 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar.singleton; + +/** + * <p>Bill Pugh Singleton Implementation.</p> + * + * <p>This implementation of the singleton design pattern takes advantage of the + * Java memory model's guarantees about class initialization. Each class is + * initialized only once, when it is first used. If the class hasn't been used + * yet, it won't be loaded into memory, and no memory will be allocated for + * a static instance. This makes the singleton instance lazy-loaded and thread-safe.</p> + * + * @author owen.leung2@gmail.com + */ +public final class BillPughImplementation { + + /** + * Private constructor to prevent instantiation from outside the class. + */ + private BillPughImplementation() { + // private constructor + } + + /** + * The InstanceHolder is a static inner class and it holds the Singleton instance. + * It is not loaded into memory until the getInstance() method is called. + */ + private static class InstanceHolder { + /** + * Singleton instance of the class. + */ + private static BillPughImplementation instance = new BillPughImplementation(); + } + + /** + * Public accessor for the singleton instance. + * + * <p> + * When this method is called, the InstanceHolder is loaded into memory + * and creates the Singleton instance. This method provides a global access point + * for the singleton instance. + * </p> + * + * @return an instance of the class. + */ + // global access point + public static BillPughImplementation getInstance() { + return InstanceHolder.instance; + } +} diff --git a/singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java b/singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java index c98157997f90..8130dc55dd70 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java +++ b/singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java @@ -32,6 +32,9 @@ */ public enum EnumIvoryTower { + /** + * The singleton instance of the class, created by the Java enum singleton pattern. + */ INSTANCE; @Override diff --git a/singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java b/singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java index 013d01722796..6cff5b561a92 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java +++ b/singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java @@ -58,6 +58,10 @@ public static InitializingOnDemandHolderIdiom getInstance() { * Provides the lazy-loaded Singleton instance. */ private static class HelperHolder { + + /** + * Singleton instance of the class. + */ private static final InitializingOnDemandHolderIdiom INSTANCE = new InitializingOnDemandHolderIdiom(); } diff --git a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java index 47c01c030334..e409432a1945 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java +++ b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java @@ -34,7 +34,9 @@ * @author mortezaadi@gmail.com */ public final class ThreadSafeDoubleCheckLocking { - + /** + * Singleton instance of the class, declared as volatile to ensure atomic access by multiple threads. + */ private static volatile ThreadSafeDoubleCheckLocking instance; /** @@ -73,7 +75,8 @@ public static ThreadSafeDoubleCheckLocking getInstance() { // The instance is still not initialized so we can safely // (no other thread can enter this zone) // create an instance and make it our singleton instance. - instance = result = new ThreadSafeDoubleCheckLocking(); + result = new ThreadSafeDoubleCheckLocking(); + instance = result; } } } diff --git a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java index 559363a6c998..4d1c25739673 100644 --- a/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java +++ b/singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java @@ -31,8 +31,14 @@ */ public final class ThreadSafeLazyLoadedIvoryTower { + /** + * Singleton instance of the class, declared as volatile to ensure atomic access by multiple threads. + */ private static volatile ThreadSafeLazyLoadedIvoryTower instance; + /** + * Private constructor to prevent instantiation from outside the class. + */ private ThreadSafeLazyLoadedIvoryTower() { // Protect against instantiation via reflection if (instance != null) { @@ -42,6 +48,8 @@ private ThreadSafeLazyLoadedIvoryTower() { /** * The instance doesn't get created until the method is called for the first time. + * + * @return an instance of the class. */ public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() { if (instance == null) { diff --git a/singleton/src/main/java/com/iluwatar/singleton/package-info.java b/singleton/src/main/java/com/iluwatar/singleton/package-info.java new file mode 100644 index 000000000000..bfcfbd77e344 --- /dev/null +++ b/singleton/src/main/java/com/iluwatar/singleton/package-info.java @@ -0,0 +1,25 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar.singleton;

diff --git a/singleton/src/test/java/com/iluwatar/singleton/BillPughImplementationTest.java b/singleton/src/test/java/com/iluwatar/singleton/BillPughImplementationTest.java new file mode 100644 index 000000000000..90a3424e412c --- /dev/null +++ b/singleton/src/test/java/com/iluwatar/singleton/BillPughImplementationTest.java @@ -0,0 +1,16 @@ +package com.iluwatar.singleton; + +/** + * Date: 06/18/23 - 16:29 PM. + * + * @author Owen Leung + */ +public class BillPughImplementationTest + extends SingletonTest<BillPughImplementation>{ + /** + * Create a new singleton test instance using the given 'getInstance' method. + */ + public BillPughImplementationTest() { + super(BillPughImplementation::getInstance); + } +}

val

test

iluwatar

train

iluwatar/java-design-patterns/2544_2545

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2544

iluwatar/java-design-patterns/2545

72f7fcab0ea5677e39a8cc064e1c69527a0c309c

2154e777b6a7d992058197cfea823e969bb64f9c

[Spatial Partition] Error when run App.java

When run [App.java](https://github.com/iluwatar/java-design-patterns/blob/5b147b00367a500e8dfeac882d4b0d6a0540c6b9/spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java), there are some problems: - `ConcurrentModificationException` happen: ``` Exception in thread "main" java.util.ConcurrentModificationException at java.base/java.util.HashMap$HashIterator.nextNode(HashMap.java:1597) at java.base/java.util.HashMap$ValueIterator.next(HashMap.java:1625) at com.iluwatar.spatialpartition.Bubble.handleCollision(Bubble.java:69) at com.iluwatar.spatialpartition.App.lambda$noSpatialPartition$0(App.java:75) at java.base/java.util.HashMap.forEach(HashMap.java:1421) at com.iluwatar.spatialpartition.App.noSpatialPartition(App.java:70) at com.iluwatar.spatialpartition.App.main(App.java:125) ``` - Some logs don't work, just log `"Bubble"` - Some logs don't use Slf4j formatting anchor _{}_.

diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java index 47dcd7eb7560..e7b14249a732 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java @@ -25,7 +25,8 @@ package com.iluwatar.spatialpartition; import java.security.SecureRandom; -import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; import lombok.extern.slf4j.Slf4j; /** @@ -59,9 +60,8 @@ @Slf4j public class App { - private static final String BUBBLE = "Bubble "; - static void noSpatialPartition(int numOfMovements, HashMap<Integer, Bubble> bubbles) { + static void noSpatialPartition(int numOfMovements, Map<Integer, Bubble> bubbles) { //all bubbles have to be checked for collision for all bubbles var bubblesToCheck = bubbles.values(); @@ -77,11 +77,11 @@ static void noSpatialPartition(int numOfMovements, HashMap<Integer, Bubble> bubb numOfMovements--; } //bubbles not popped - bubbles.keySet().stream().map(key -> BUBBLE + key + " not popped").forEach(LOGGER::info); + bubbles.keySet().forEach(key -> LOGGER.info("Bubble {} not popped", key)); } static void withSpatialPartition( - int height, int width, int numOfMovements, HashMap<Integer, Bubble> bubbles) { + int height, int width, int numOfMovements, Map<Integer, Bubble> bubbles) { //creating quadtree var rect = new Rect(width / 2D, height / 2D, width, height); var quadTree = new QuadTree(rect, 4); @@ -100,7 +100,7 @@ static void withSpatialPartition( numOfMovements--; } //bubbles not popped - bubbles.keySet().stream().map(key -> BUBBLE + key + " not popped").forEach(LOGGER::info); + bubbles.keySet().forEach(key -> LOGGER.info("Bubble {} not popped", key)); } /** @@ -110,15 +110,15 @@ static void withSpatialPartition( */ public static void main(String[] args) { - var bubbles1 = new HashMap<Integer, Bubble>(); - var bubbles2 = new HashMap<Integer, Bubble>(); + var bubbles1 = new ConcurrentHashMap<Integer, Bubble>(); + var bubbles2 = new ConcurrentHashMap<Integer, Bubble>(); var rand = new SecureRandom(); for (int i = 0; i < 10000; i++) { var b = new Bubble(rand.nextInt(300), rand.nextInt(300), i, rand.nextInt(2) + 1); bubbles1.put(i, b); bubbles2.put(i, b); - LOGGER.info(BUBBLE, i, " with radius ", b.radius, - " added at (", b.coordinateX, ",", b.coordinateY + ")"); + LOGGER.info("Bubble {} with radius {} added at ({},{})", + i, b.radius, b.coordinateX, b.coordinateY); } var start1 = System.currentTimeMillis(); @@ -127,8 +127,7 @@ public static void main(String[] args) { var start2 = System.currentTimeMillis(); App.withSpatialPartition(300, 300, 20, bubbles2); var end2 = System.currentTimeMillis(); - LOGGER.info("Without spatial partition takes ", (end1 - start1), "ms"); - LOGGER.info("With spatial partition takes ", (end2 - start2), "ms"); + LOGGER.info("Without spatial partition takes {} ms", (end1 - start1)); + LOGGER.info("With spatial partition takes {} ms", (end2 - start2)); } } - diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Bubble.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Bubble.java index f1f9fb61d03a..70f8cae48d65 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Bubble.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Bubble.java @@ -26,7 +26,7 @@ import java.security.SecureRandom; import java.util.Collection; -import java.util.HashMap; +import java.util.Map; import lombok.extern.slf4j.Slf4j; /** @@ -58,13 +58,12 @@ boolean touches(Bubble b) { <= (this.radius + b.radius) * (this.radius + b.radius); } - void pop(HashMap<Integer, Bubble> allBubbles) { - LOGGER.info("Bubble ", this.id, - " popped at (", this.coordinateX, ",", this.coordinateY, ")!"); + void pop(Map<Integer, Bubble> allBubbles) { + LOGGER.info("Bubble {} popped at ({},{})!", this.id, this.coordinateX, this.coordinateY); allBubbles.remove(this.id); } - void handleCollision(Collection<? extends Point> toCheck, HashMap<Integer, Bubble> allBubbles) { + void handleCollision(Collection<? extends Point> toCheck, Map<Integer, Bubble> allBubbles) { var toBePopped = false; //if any other bubble collides with it, made true for (var point : toCheck) { var otherId = point.id; diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Point.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Point.java index 81312185247c..1b24e70fa37e 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Point.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/Point.java @@ -25,7 +25,7 @@ package com.iluwatar.spatialpartition; import java.util.Collection; -import java.util.HashMap; +import java.util.Map; /** * The abstract Point class which will be extended by any object in the field whose location has to @@ -65,5 +65,5 @@ public abstract class Point<T> { * @param toCheck contains the objects which need to be checked * @param all contains hashtable of all points on field at this time */ - abstract void handleCollision(Collection<? extends Point> toCheck, HashMap<Integer, T> all); + abstract void handleCollision(Collection<? extends Point> toCheck, Map<Integer, T> all); } diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/QuadTree.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/QuadTree.java index 12a84f5a33e9..40c09a1d8f6e 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/QuadTree.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/QuadTree.java @@ -25,7 +25,8 @@ package com.iluwatar.spatialpartition; import java.util.Collection; -import java.util.Hashtable; +import java.util.HashMap; +import java.util.Map; /** * The quadtree data structure is being used to keep track of the objects' locations. It has the @@ -37,7 +38,7 @@ public class QuadTree { Rect boundary; int capacity; boolean divided; - Hashtable<Integer, Point> points; + Map<Integer, Point> points; QuadTree northwest; QuadTree northeast; QuadTree southwest; @@ -47,7 +48,7 @@ public class QuadTree { this.boundary = boundary; this.capacity = capacity; this.divided = false; - this.points = new Hashtable<>(); + this.points = new HashMap<>(); this.northwest = null; this.northeast = null; this.southwest = null; diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionBubbles.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionBubbles.java index 50d20caa32f7..3551f5ca3b9b 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionBubbles.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionBubbles.java @@ -25,7 +25,7 @@ package com.iluwatar.spatialpartition; import java.util.ArrayList; -import java.util.HashMap; +import java.util.Map; /** * This class extends the generic SpatialPartition abstract class and is used in our example to keep @@ -34,10 +34,10 @@ public class SpatialPartitionBubbles extends SpatialPartitionGeneric<Bubble> { - private final HashMap<Integer, Bubble> bubbles; + private final Map<Integer, Bubble> bubbles; private final QuadTree bubblesQuadTree; - SpatialPartitionBubbles(HashMap<Integer, Bubble> bubbles, QuadTree bubblesQuadTree) { + SpatialPartitionBubbles(Map<Integer, Bubble> bubbles, QuadTree bubblesQuadTree) { this.bubbles = bubbles; this.bubblesQuadTree = bubblesQuadTree; } diff --git a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionGeneric.java b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionGeneric.java index c1eb8d1f3600..7c03969a08e6 100644 --- a/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionGeneric.java +++ b/spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionGeneric.java @@ -24,7 +24,7 @@ */ package com.iluwatar.spatialpartition; -import java.util.Hashtable; +import java.util.Map; /** * This abstract class has 2 fields, one of which is a hashtable containing all objects that @@ -35,7 +35,7 @@ public abstract class SpatialPartitionGeneric<T> { - Hashtable<Integer, T> playerPositions; + Map<Integer, T> playerPositions; QuadTree quadTree; /**

test

test

tiennm99

train

iluwatar/java-design-patterns/1306_2551

iluwatar/java-design-patterns

iluwatar/java-design-patterns/1306

iluwatar/java-design-patterns/2551

e40923d938cc94c096e1f3c19bc83b0caa85245a

8b11e76f460667caf014e6731be9bc105031444d

Optimistic Offline Lock pattern

https://books.google.fi/books?id=vqTfNFDzzdIC&pg=PA416#v=onepage&q&f=false

diff --git a/optimistic-offline-lock/README.md b/optimistic-offline-lock/README.md new file mode 100644 index 000000000000..7447a30503c7 --- /dev/null +++ b/optimistic-offline-lock/README.md @@ -0,0 +1,147 @@ +--- +title: Optimistic Offline Lock +category: Concurrency +language: en +tag: +- Data access +--- + +## Intent + +Provide an ability to avoid concurrent changes of one record in relational databases. + +## Explanation + +Each transaction during object modifying checks equation of object's version before start of transaction +and before commit itself. + +**Real world example** +> Since people love money, the best (and most common) example is banking system: +> imagine you have 100$ on your e-wallet and two people are trying to send you 50$ both at a time. +> Without locking, your system will start **two different thread**, each of whose will read your current balance +> and just add 50$. The last thread won't re-read balance and will just rewrite it. +> So, instead 200$ you will have only 150$. + +**In plain words** +> Each transaction during object modifying will save object's last version and check it before saving. +> If it differs, the transaction will be rolled back. + +**Wikipedia says** +> Optimistic concurrency control (OCC), also known as optimistic locking, +> is a concurrency control method applied to transactional systems such as +> relational database management systems and software transactional memory. + +**Programmatic Example** +Let's simulate the case from *real world example*. Imagine we have next entity: + +```java +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Bank card entity. + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +public class Card { + + /** + * Primary key. + */ + private long id; + + /** + * Foreign key points to card's owner. + */ + private long personId; + + /** + * Sum of money. + */ + private float sum; + + /** + * Current version of object; + */ + private int version; +} +``` + +Then the correct modifying will be like this: + +```java + +import lombok.RequiredArgsConstructor; + +/** + * Service to update {@link Card} entity. + */ +@RequiredArgsConstructor +public class CardUpdateService implements UpdateService<Card> { + + private final JpaRepository<Card> cardJpaRepository; + + @Override + @Transactional(rollbackFor = ApplicationException.class) //will roll back transaction in case ApplicationException + public Card doUpdate(Card card, long cardId) { + float additionalSum = card.getSum(); + Card cardToUpdate = cardJpaRepository.findById(cardId); + int initialVersion = cardToUpdate.getVersion(); + float resultSum = cardToUpdate.getSum() + additionalSum; + cardToUpdate.setSum(resultSum); + //Maybe more complex business-logic e.g. HTTP-requests and so on + + if (initialVersion != cardJpaRepository.getEntityVersionById(cardId)) { + String exMessage = String.format("Entity with id %s were updated in another transaction", cardId); + throw new ApplicationException(exMessage); + } + + cardJpaRepository.update(cardToUpdate); + return cardToUpdate; + } +} +``` + +## Applicability + +Since optimistic locking can cause degradation of system's efficiency and reliability due to +many retries/rollbacks, it's important to use it safely. They are useful in case when transactions are not so long +and does not distributed among many microservices, when you need to reduce network/database overhead. + +Important to note that you should not choose this approach in case when modifying one object +in different threads is common situation. + +## Tutorials + +- [Offline Concurrency Control](https://www.baeldung.com/cs/offline-concurrency-control) +- [Optimistic lock in JPA](https://www.baeldung.com/jpa-optimistic-locking) + +## Known uses + +- [Hibernate ORM](https://docs.jboss.org/hibernate/orm/4.3/devguide/en-US/html/ch05.html) + +## Consequences + +**Advantages**: + +- Reduces network/database overhead +- Let to avoid database deadlock +- Improve the performance and scalability of the application + +**Disadvantages**: + +- Increases complexity of the application +- Requires mechanism of versioning +- Requires rollback/retry mechanisms + +## Related patterns + +- [Pessimistic Offline Lock](https://martinfowler.com/eaaCatalog/pessimisticOfflineLock.html) + +## Credits + +- [Source (Martin Fowler)](https://martinfowler.com/eaaCatalog/optimisticOfflineLock.html) +- [Advantages and disadvantages](https://www.linkedin.com/advice/0/what-benefits-drawbacks-using-optimistic) +- [Comparison of optimistic and pessimistic locks](https://www.linkedin.com/advice/0/what-advantages-disadvantages-using-optimistic) \ No newline at end of file diff --git a/optimistic-offline-lock/pom.xml b/optimistic-offline-lock/pom.xml new file mode 100644 index 000000000000..d32c46df4534 --- /dev/null +++ b/optimistic-offline-lock/pom.xml @@ -0,0 +1,52 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + + This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + + The MIT License + Copyright © 2014-2022 Ilkka Seppälä + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>com.iluwatar</groupId> + <artifactId>java-design-patterns</artifactId> + <version>1.26.0-SNAPSHOT</version> + </parent> + + <artifactId>optimistic-offline-lock</artifactId> + + <dependencies> + <dependency> + <groupId>org.junit.jupiter</groupId> + <artifactId>junit-jupiter-engine</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.mockito</groupId> + <artifactId>mockito-core</artifactId> + <scope>test</scope> + </dependency> + </dependencies> +</project> diff --git a/optimistic-offline-lock/src/main/java/com/iluwatar/api/UpdateService.java b/optimistic-offline-lock/src/main/java/com/iluwatar/api/UpdateService.java new file mode 100644 index 000000000000..b3c29d22f0b9 --- /dev/null +++ b/optimistic-offline-lock/src/main/java/com/iluwatar/api/UpdateService.java @@ -0,0 +1,18 @@ +package com.iluwatar.api; + +/** + * Service for entity update. + * + * @param <T> target entity + */ +public interface UpdateService<T> { + + /** + * Update entity. + * + * @param obj entity to update + * @param id primary key + * @return modified entity + */ + T doUpdate(T obj, long id); +} diff --git a/optimistic-offline-lock/src/main/java/com/iluwatar/exception/ApplicationException.java b/optimistic-offline-lock/src/main/java/com/iluwatar/exception/ApplicationException.java new file mode 100644 index 000000000000..7d12c3350e8b --- /dev/null +++ b/optimistic-offline-lock/src/main/java/com/iluwatar/exception/ApplicationException.java @@ -0,0 +1,16 @@ +package com.iluwatar.exception; + +/** + * Exception happens in application during business-logic execution. + */ +public class ApplicationException extends RuntimeException { + + /** + * Inherited constructor with exception message. + * + * @param message exception message + */ + public ApplicationException(String message) { + super(message); + } +} diff --git a/optimistic-offline-lock/src/main/java/com/iluwatar/model/Card.java b/optimistic-offline-lock/src/main/java/com/iluwatar/model/Card.java new file mode 100644 index 000000000000..b36c779d6ba4 --- /dev/null +++ b/optimistic-offline-lock/src/main/java/com/iluwatar/model/Card.java @@ -0,0 +1,37 @@ +package com.iluwatar.model; + + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Bank card entity. + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class Card { + + /** + * Primary key. + */ + private long id; + + /** + * Foreign key points to card's owner. + */ + private long personId; + + /** + * Sum of money. + */ + private float sum; + + /** + * Current version of object. + */ + private int version; +} diff --git a/optimistic-offline-lock/src/main/java/com/iluwatar/repository/JpaRepository.java b/optimistic-offline-lock/src/main/java/com/iluwatar/repository/JpaRepository.java new file mode 100644 index 000000000000..b1d3c240a0ce --- /dev/null +++ b/optimistic-offline-lock/src/main/java/com/iluwatar/repository/JpaRepository.java @@ -0,0 +1,33 @@ +package com.iluwatar.repository; + +/** + * Imitation of Spring's JpaRepository. + * + * @param <T> target database entity + */ +public interface JpaRepository<T> { + + /** + * Get object by it's PK. + * + * @param id primary key + * @return {@link T} + */ + T findById(long id); + + /** + * Get current object version. + * + * @param id primary key + * @return object's version + */ + int getEntityVersionById(long id); + + /** + * Update object. + * + * @param obj entity to update + * @return number of modified records + */ + int update(T obj); +} diff --git a/optimistic-offline-lock/src/main/java/com/iluwatar/service/CardUpdateService.java b/optimistic-offline-lock/src/main/java/com/iluwatar/service/CardUpdateService.java new file mode 100644 index 000000000000..0f67c1e5e85f --- /dev/null +++ b/optimistic-offline-lock/src/main/java/com/iluwatar/service/CardUpdateService.java @@ -0,0 +1,35 @@ +package com.iluwatar.service; + +import com.iluwatar.api.UpdateService; +import com.iluwatar.exception.ApplicationException; +import com.iluwatar.model.Card; +import com.iluwatar.repository.JpaRepository; +import lombok.RequiredArgsConstructor; + +/** + * Service to update {@link Card} entity. + */ +@RequiredArgsConstructor +public class CardUpdateService implements UpdateService<Card> { + + private final JpaRepository<Card> cardJpaRepository; + + @Override + public Card doUpdate(Card obj, long id) { + float additionalSum = obj.getSum(); + Card cardToUpdate = cardJpaRepository.findById(id); + int initialVersion = cardToUpdate.getVersion(); + float resultSum = cardToUpdate.getSum() + additionalSum; + cardToUpdate.setSum(resultSum); + //Maybe more complex business-logic e.g. HTTP-requests and so on + + if (initialVersion != cardJpaRepository.getEntityVersionById(id)) { + String exMessage = + String.format("Entity with id %s were updated in another transaction", id); + throw new ApplicationException(exMessage); + } + + cardJpaRepository.update(cardToUpdate); + return cardToUpdate; + } +} diff --git a/pom.xml b/pom.xml index 10348ef0466a..9e46d17f9cfc 100644 --- a/pom.xml +++ b/pom.xml @@ -206,6 +206,7 @@ <module>component</module> <module>context-object</module> <module>thread-local-storage</module> + <module>optimistic-offline-lock</module> </modules> <repositories> <repository>

diff --git a/optimistic-offline-lock/src/test/java/com/iluwatar/OptimisticLockTest.java b/optimistic-offline-lock/src/test/java/com/iluwatar/OptimisticLockTest.java new file mode 100644 index 000000000000..479b5807838e --- /dev/null +++ b/optimistic-offline-lock/src/test/java/com/iluwatar/OptimisticLockTest.java @@ -0,0 +1,60 @@ +package com.iluwatar; + +import com.iluwatar.exception.ApplicationException; +import com.iluwatar.model.Card; +import com.iluwatar.repository.JpaRepository; +import com.iluwatar.service.CardUpdateService; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.eq; + +@SuppressWarnings({"rawtypes", "unchecked"}) +public class OptimisticLockTest { + + private CardUpdateService cardUpdateService; + + private JpaRepository cardRepository; + + @BeforeEach + public void setUp() { + cardRepository = Mockito.mock(JpaRepository.class); + cardUpdateService = new CardUpdateService(cardRepository); + } + + @Test + public void shouldNotUpdateEntityOnDifferentVersion() { + int initialVersion = 1; + long cardId = 123L; + Card card = Card.builder() + .id(cardId) + .version(initialVersion) + .sum(123f) + .build(); + when(cardRepository.findById(eq(cardId))).thenReturn(card); + when(cardRepository.getEntityVersionById(Mockito.eq(cardId))).thenReturn(initialVersion + 1); + + Assertions.assertThrows(ApplicationException.class, + () -> cardUpdateService.doUpdate(card, cardId)); + } + + @Test + public void shouldUpdateOnSameVersion() { + int initialVersion = 1; + long cardId = 123L; + Card card = Card.builder() + .id(cardId) + .version(initialVersion) + .sum(123f) + .build(); + when(cardRepository.findById(eq(cardId))).thenReturn(card); + when(cardRepository.getEntityVersionById(Mockito.eq(cardId))).thenReturn(initialVersion); + + cardUpdateService.doUpdate(card, cardId); + + Mockito.verify(cardRepository).update(Mockito.any()); + } +}

test

test

iluwatar

train

iluwatar/java-design-patterns/2241_2583

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2241

iluwatar/java-design-patterns/2583

cb2d794cf85ed7bb4c251decf36fef0e0655d820

ae597f259622c3f6c646cf0099fd103089aa1327

Explanation for Master-Worker

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/master-worker-pattern/README.md b/master-worker-pattern/README.md index fc4e111ae412..32f239078517 100644 --- a/master-worker-pattern/README.md +++ b/master-worker-pattern/README.md @@ -17,6 +17,83 @@ tag: ## Class diagram  +## Explanation + +Real World Example +>Imagine you have a large stack of papers to grade as a teacher. You decide to hire several teaching assistants to help you. You, as the "master," distribute different papers to each teaching assistant, they grade them independently, and return the graded papers to you. Finally, you collect all the graded papers, review them, and calculate the final grades. This process of dividing work among assistants, parallel processing, and aggregating results is similar to the Master-Worker pattern. + +In Plain Words +>The Master-Worker pattern is like a boss (the master) assigning tasks to workers and then combining the results. It's a way to efficiently break down a big job into smaller pieces that can be done concurrently. + +Wikipedia Says +>According to [Wikipedia](https://en.wikipedia.org/wiki/Master/slave_(technology)), the Master-Worker pattern, also known as Master-Slave or Map-Reduce, is a design pattern used in software engineering for parallel processing. In this pattern, a "master" component divides a complex task into smaller subtasks and assigns them to multiple "worker" components. Each worker processes its assigned subtask independently, and the master collects and combines the results to produce the final output. + +Programmatic Example + +```java +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.*; + +// Define a task that workers (teaching assistants) will perform +class GradingWorkerTask implements Callable<Integer> { + private int paperNumber; + + public GradingWorkerTask(int paperNumber) { + this.paperNumber = paperNumber; + } + + @Override + public Integer call() throws Exception { + // Simulate grading a paper (e.g., assigning a score) + int score = (int) (Math.random() * 100); // Assign a random score + // Simulate some grading time + Thread.sleep((int) (Math.random() * 1000)); + System.out.println("Graded paper #" + paperNumber + " with a score of " + score); + return score; + } +} +``` + +```java +public class PaperGrading { + public static void main(String[] args) { + int totalPapersToGrade = 20; // Total number of papers to grade + int numberOfTeachingAssistants = 3; // Number of teaching assistants + + // Create a thread pool with a fixed number of teaching assistants (workers) + ExecutorService executor = Executors.newFixedThreadPool(numberOfTeachingAssistants); + + // Create and submit grading tasks to the executor for each paper + List<Future<Integer>> results = new ArrayList<>(); + for (int paperNumber = 1; paperNumber <= totalPapersToGrade; paperNumber++) { + results.add(executor.submit(new GradingWorkerTask(paperNumber))); + } + + // Shutdown the executor to prevent new tasks from being submitted + executor.shutdown(); + + // Collect and analyze the grading results + int totalScore = 0; + for (Future<Integer> result : results) { + try { + // Get the score of each graded paper and calculate the total score + totalScore += result.get(); + } catch (InterruptedException | ExecutionException e) { + e.printStackTrace(); + } + } + + double averageScore = (double) totalScore / totalPapersToGrade; + + System.out.println("Grading completed."); + System.out.println("Total papers graded: " + totalPapersToGrade); + System.out.println("Total score: " + totalScore); + System.out.println("Average score: " + averageScore); + } +} +``` + ## Applicability This pattern can be used when data can be divided into multiple parts, all of which need to go through the same computation to give a result, which need to be aggregated to get the final result.

train

test

iluwatar

train

iluwatar/java-design-patterns/2260_2586

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2260

iluwatar/java-design-patterns/2586

cb2d794cf85ed7bb4c251decf36fef0e0655d820

9561722bb5770d82d781536b359b65595791e4d7

Explanation for Servant

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/servant/README.md b/servant/README.md index bfd06e2bc37a..c6aaf414873d 100644 --- a/servant/README.md +++ b/servant/README.md @@ -3,7 +3,7 @@ title: Servant category: Behavioral language: en tag: - - Decoupling +- Decoupling --- ## Intent @@ -11,6 +11,217 @@ Servant is used for providing some behavior to a group of classes. Instead of defining that behavior in each class - or when we cannot factor out this behavior in the common parent class - it is defined once in the Servant. +## Explanation + +Real-world example + +> King, Queen, and other royal member of palace need servant to service them for feeding, +> organizing drinks, and so on. + +In plain words + +> Ensures one servant object to give some specific services for a group of serviced classes. + +Wikipedia says + +> In software engineering, the servant pattern defines an object used to offer some functionality +> to a group of classes without defining that functionality in each of them. A Servant is a class +> whose instance (or even just class) provides methods that take care of a desired service, while +> objects for which (or with whom) the servant does something, are taken as parameters. + +**Programmatic Example** + +Servant class which can give services to other royal members of palace. + +```java +/** + * Servant. + */ +public class Servant { + + public String name; + + /** + * Constructor. + */ + public Servant(String name) { + this.name = name; + } + + public void feed(Royalty r) { + r.getFed(); + } + + public void giveWine(Royalty r) { + r.getDrink(); + } + + public void giveCompliments(Royalty r) { + r.receiveCompliments(); + } + + /** + * Check if we will be hanged. + */ + public boolean checkIfYouWillBeHanged(List<Royalty> tableGuests) { + return tableGuests.stream().allMatch(Royalty::getMood); + } +} +``` + +Royalty is an interface. It is implemented by King, and Queen classes to get services from servant. + +```java +interface Royalty { + + void getFed(); + + void getDrink(); + + void changeMood(); + + void receiveCompliments(); + + boolean getMood(); +} +``` +King, class is implementing Royalty interface. +```java +public class King implements Royalty { + + private boolean isDrunk; + private boolean isHungry = true; + private boolean isHappy; + private boolean complimentReceived; + + @Override + public void getFed() { + isHungry = false; + } + + @Override + public void getDrink() { + isDrunk = true; + } + + public void receiveCompliments() { + complimentReceived = true; + } + + @Override + public void changeMood() { + if (!isHungry && isDrunk) { + isHappy = true; + } + if (complimentReceived) { + isHappy = false; + } + } + + @Override + public boolean getMood() { + return isHappy; + } +} +``` +Queen, class is implementing Royalty interface. +```java +public class Queen implements Royalty { + + private boolean isDrunk = true; + private boolean isHungry; + private boolean isHappy; + private boolean isFlirty = true; + private boolean complimentReceived; + + @Override + public void getFed() { + isHungry = false; + } + + @Override + public void getDrink() { + isDrunk = true; + } + + public void receiveCompliments() { + complimentReceived = true; + } + + @Override + public void changeMood() { + if (complimentReceived && isFlirty && isDrunk && !isHungry) { + isHappy = true; + } + } + + @Override + public boolean getMood() { + return isHappy; + } + + public void setFlirtiness(boolean f) { + this.isFlirty = f; + } + +} +``` + +Then in order to use: + +```java +public class App { + + private static final Servant jenkins = new Servant("Jenkins"); + private static final Servant travis = new Servant("Travis"); + + /** + * Program entry point. + */ + public static void main(String[] args) { + scenario(jenkins, 1); + scenario(travis, 0); + } + + /** + * Can add a List with enum Actions for variable scenarios. + */ + public static void scenario(Servant servant, int compliment) { + var k = new King(); + var q = new Queen(); + + var guests = List.of(k, q); + + // feed + servant.feed(k); + servant.feed(q); + // serve drinks + servant.giveWine(k); + servant.giveWine(q); + // compliment + servant.giveCompliments(guests.get(compliment)); + + // outcome of the night + guests.forEach(Royalty::changeMood); + + // check your luck + if (servant.checkIfYouWillBeHanged(guests)) { + LOGGER.info("{} will live another day", servant.name); + } else { + LOGGER.info("Poor {}. His days are numbered", servant.name); + } + } +} +``` + +The console output + +``` +Jenkins will live another day +Poor Travis. His days are numbered +``` + + ## Class diagram 

train

test

iluwatar

train

iluwatar/java-design-patterns/2266_2596

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2266

iluwatar/java-design-patterns/2596

cb2d794cf85ed7bb4c251decf36fef0e0655d820

ffbcbdcb33bcd739fbfb58b70faab5cc26a44954

Explanation for Type-Object

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/typeobjectpattern/README.md b/typeobjectpattern/README.md index f75e217d2616..742792a8f423 100644 --- a/typeobjectpattern/README.md +++ b/typeobjectpattern/README.md @@ -7,17 +7,63 @@ tag: - Extensibility --- +# Type-Object Pattern in Java + +## Explanation + +In Java, the Type-Object pattern is a design pattern that encapsulates type information in an object. This pattern is particularly useful when dealing with multiple objects of the same kind, and there is a need to add new types without altering existing code. + ## Intent As explained in the book Game Programming Patterns by Robert Nystrom, type object pattern helps in > Allowing flexible creation of new “classes” by creating a single class, each instance of which represents a different type of object -## Explanation -Say, we are working on a game which has a hero and many monsters which are going to attack the hero. These monsters have certain attributes like attack, points etc. and come in different 'breeds' like zombie or ogres. The obvious answer is to have a base Monster class which has some fields and methods, which may be overriden by subclasses like the Zombie or Ogre class. But as we continue to build the game, there may be more and more breeds of monsters added and certain attributes may need to be changed in the existing monsters too. The OOP solution of inheriting from the base class would not be an efficient method in this case. +## Real World Example +Let's consider a real-world example. Say, we are working on a game which has a hero and many monsters which are going to attack the hero. These monsters have certain attributes like attack, points etc. and come in different 'breeds' like zombie or ogres. The obvious answer is to have a base Monster class which has some fields and methods, which may be overriden by subclasses like the Zombie or Ogre class. But as we continue to build the game, there may be more and more breeds of monsters added and certain attributes may need to be changed in the existing monsters too. The OOP solution of inheriting from the base class would not be an efficient method in this case. Using the type-object pattern, instead of creating many classes inheriting from a base class, we have 1 class with a field which represents the 'type' of object. This makes the code cleaner and object instantiation also becomes as easy as parsing a json file with the object properties. -## Class diagram - +## In Plain Words + +The Type-Object pattern in Java is a method to encapsulate type-specific properties and behaviors within an object. This design pattern facilitates the addition of new types without necessitating changes to existing code, thereby enhancing codebase expansion and maintenance. + +## Wikipedia Says + +While there isn't a specific Wikipedia entry for the Type-Object pattern, it is a commonly used technique in object-oriented programming. This pattern assists in managing objects that share similar characteristics but have different values for those characteristics. It finds widespread use in game development, where numerous types of objects (like enemies) share common behavior but have different properties. + +## Programmatic Example + +Consider an example involving different types of enemies in a game. Each enemy type has distinct properties like speed, health, and damage. + +```java +public class EnemyType { + private String name; + private int speed; + private int health; + private int damage; + + public EnemyType(String name, int speed, int health, int damage) { + this.name = name; + this.speed = speed; + this.health = health; + this.damage = damage; + } + + // getters and setters +} + +public class Enemy { + private EnemyType type; + + // Encapsulating type information in an object + public Enemy(EnemyType type) { + this.type = type; + } + + // other methods +} +``` + +In the above example, `EnemyType` encapsulates type-specific properties (name, speed, health, damage), and `Enemy` uses an instance of `EnemyType` to define its type. This way, you can add as many enemy types as you want without modifying the `Enemy` class. ## Applicability This pattern can be used when: @@ -25,7 +71,10 @@ This pattern can be used when: * We don’t know what types we will need up front. * We want to be able to modify or add new types without having to recompile or change code. * Only difference between the different 'types' of objects is the data, not the behaviour. - + +## Another example with class diagram + + ## Credits * [Game Programming Patterns - Type Object](http://gameprogrammingpatterns.com/type-object.html)

test

test

iluwatar

train

iluwatar/java-design-patterns/2250_2597

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2250

iluwatar/java-design-patterns/2597

cb2d794cf85ed7bb4c251decf36fef0e0655d820

b75c7c1041aa56a837a35b6c41b04a5d9680a6e4

Explanation for Page Object

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/page-object/README.md b/page-object/README.md index 87046a85d917..93777ad2e032 100644 --- a/page-object/README.md +++ b/page-object/README.md @@ -6,13 +6,69 @@ tag: - Decoupling --- +# Page Object Pattern in Java + +## Real World Example + +Consider a web automation scenario where you need to interact with a web page using a test framework like Selenium. The Page Object pattern can be applied to model each web page as a Java class. Each class encapsulates the structure and behavior of the corresponding web page, making it easier to manage and update the automation code. + ## Intent Page Object encapsulates the UI, hiding the underlying UI widgetry of an application (commonly a web application) and providing an application-specific API to allow the manipulation of UI components required for tests. In doing so, it allows the test class itself to focus on the test logic instead. -## Class diagram - +## In Plain Words + +The Page Object pattern in Java is a design pattern used in test automation to represent web pages as Java classes. Each class corresponds to a specific web page and contains methods to interact with the elements on that page. This pattern enhances code maintainability and readability in automated testing. + +## Wikipedia Says + +While there isn't a specific Wikipedia entry for the Page Object pattern, it is widely used in software testing, particularly in the context of UI automation. The Page Object pattern helps abstract the details of a web page, providing a cleaner and more maintainable way to interact with web elements in automated tests. + +## Programmatic Example + +Let's create a simple programmatic example of the Page Object pattern for a login page using Selenium in Java: + +```java +import org.openqa.selenium.By; +import org.openqa.selenium.WebDriver; +import org.openqa.selenium.WebElement; + +public class LoginPage { + private final WebDriver driver; + // Web elements on the login page + private final By usernameInput = By.id("username"); + private final By passwordInput = By.id("password"); + private final By loginButton = By.id("login-button"); + + public LoginPage(WebDriver driver) { + this.driver = driver; + } + + // Methods to interact with the login page + + public void enterUsername(String username) { + WebElement usernameElement = driver.findElement(usernameInput); + usernameElement.sendKeys(username); + } + + public void enterPassword(String password) { + WebElement passwordElement = driver.findElement(passwordInput); + passwordElement.sendKeys(password); + } + + public void clickLoginButton() { + WebElement loginButtonElement = driver.findElement(loginButton); + loginButtonElement.click(); + } + + // Other methods specific to the login page if needed +} +``` + +In this example, the `LoginPage` class represents the login page of a web application. It encapsulates the web elements on the page and provides methods to interact with those elements. The actual Selenium WebDriver instance is passed to the constructor, allowing the methods to perform actions on the web page. + +This Page Object can be used in test scripts to interact with the login page without exposing the details of the page structure in the test code, promoting maintainability and reusability. ## Applicability @@ -21,6 +77,9 @@ Use the Page Object pattern when * You are writing automated tests for your web application and you want to separate the UI manipulation required for the tests from the actual test logic. * Make your tests less brittle, and more readable and robust +## Another example with Class diagram + + ## Credits * [Martin Fowler - PageObject](http://martinfowler.com/bliki/PageObject.html)

train

test

iluwatar

train

iluwatar/java-design-patterns/2263_2614

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2263

iluwatar/java-design-patterns/2614

cb2d794cf85ed7bb4c251decf36fef0e0655d820

b71eea4b4e4849e593b8d7e23bb0cbbb6404955c

Explanation for Step Builder

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/step-builder/README.md b/step-builder/README.md index 659da6e31968..a1e98b237611 100644 --- a/step-builder/README.md +++ b/step-builder/README.md @@ -6,16 +6,100 @@ tag: - Instantiation --- +# Step Builder Pattern + +## Explanation + +The Step Builder pattern is a creational design pattern used to construct a complex object step by step. It provides a fluent interface to create an object with a large number of possible configurations, making the code more readable and reducing the need for multiple constructors or setter methods. + ## Intent An extension of the Builder pattern that fully guides the user through the creation of the object with no chances of confusion. The user experience will be much more improved by the fact that he will only see the next step methods available, NO build method until is the right time to build the object. -## Class diagram - +## Real World Example + +Imagine you are building a configuration object for a database connection. The connection has various optional parameters such as host, port, username, password, and others. Using the Step Builder pattern, you can set these parameters in a clean and readable way: + +```java +DatabaseConnection connection = new DatabaseConnection.Builder() + .setHost("localhost") + .setPort(3306) + .setUsername("user") + .setPassword("password") + .setSSL(true) + .build(); +``` + +## In Plain Words + +The Step Builder pattern allows you to construct complex objects by breaking down the construction process into a series of steps. Each step corresponds to setting a particular attribute or configuration option of the object. This results in more readable and maintainable code, especially when dealing with objects that have numerous configuration options. + +## Wikipedia Says + +According to Wikipedia, the Step Builder pattern is a creational design pattern in which an object is constructed step by step. It involves a dedicated 'director' class, which orchestrates the construction process through a series of 'builder' classes, each responsible for a specific aspect of the object's configuration. This pattern is particularly useful when dealing with objects that have a large number of optional parameters. + +## Programmatic Example + +Assuming you have a class `Product` with several configurable attributes, a Step Builder for it might look like this: + +```java +public class Product { + private String name; + private double price; + private int quantity; + + // private constructor to force the use of the builder + private Product(String name, double price, int quantity) { + + this.name = name; + this.price = price; + this.quantity = quantity; + + } + + public static class Builder { + private String name; + private double price; + private int quantity; + + public Builder setName(String name) { + this.name = name; + return this; + } + + public Builder setPrice(double price) { + this.price = price; + return this; + } + + public Builder setQuantity(int quantity) { + this.quantity = quantity; + return this; + } + + public Product build() { + return new Product(name, price, quantity); + } + } +} + +// Usage +Product product = new Product.Builder() + .setName("Example Product") + .setPrice(29.99) + .setQuantity(100) + .build(); +``` + +This example demonstrates how you can use the Step Builder pattern to create a `Product` object with a customizable set of attributes. Each method in the builder corresponds to a step in the construction process. ## Applicability Use the Step Builder pattern when the algorithm for creating a complex object should be independent of the parts that make up the object and how they're assembled the construction process must allow different representations for the object that's constructed when in the process of constructing the order is important. +## Another example with class diagram + + + ## Credits * [Marco Castigliego - Step Builder](http://rdafbn.blogspot.co.uk/2012/07/step-builder-pattern_28.html)

train

test

iluwatar

train

iluwatar/java-design-patterns/2230_2622

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2230

iluwatar/java-design-patterns/2622

72da91e561421d9fc9e6a15fd8190ad4d16c00c8

f9ae5961e6cc3dbb3c3cee16d56fb1f39c8e5b0f

Explanation for Feature Toggle

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/feature-toggle/README.md b/feature-toggle/README.md index 915a255690da..982108bc7440 100644 --- a/feature-toggle/README.md +++ b/feature-toggle/README.md @@ -10,10 +10,53 @@ tag: Feature Flag ## Intent -Used to switch code execution paths based on properties or groupings. Allowing new features to be released, tested -and rolled out. Allowing switching back to the older feature quickly if needed. It should be noted that this pattern, -can easily introduce code complexity. There is also cause for concern that the old feature that the toggle is eventually -going to phase out is never removed, causing redundant code smells and increased maintainability. +A technique used in software development to control and manage the rollout of specific features or functionality in a +program without changing the code. It can act as an on/off switch for features depending on the status or properties of +other values in the program. This is similar to A/B testing, where features are rolled out based on properties such as +location or device. Implementing this design pattern can increase code complexity, and it is important to remember to +remove redundant code if this design pattern is being used to phase out a system or feature. + +## Explanation +Real-world Example +> This design pattern works really well in any sort of development, in particular mobile development. Say you want to +> introduce a feature such as dark mode, but you want to ensure that the feature works correctly and don't want to roll +> out the feature to everyone immediately. You write in the code, and have it switched off as default. From here, it is +> easy to turn on the code for specific users based on selection criteria, or randomly. This will also allow the feature +> to be turned off easily without any drastic changes to the code, or any need for redeployment or updates. + +In plain words +> Feature Toggle is a way to introduce new features gradually instead of deployment all at once. + +Wikipedia says +> A feature toggle in software development provides an alternative to maintaining multiple feature branches in source +> code. A condition within the code enables or disables a feature during runtime. In agile settings the toggle is +> used in production, to switch on the feature on demand, for some or all the users. + +## Programmatic Example +This example shows Java code that allows a feature to show when it is enabled by the developer, and when a user is a +Premium member of the application. This is useful for subscription locked features. +```java +public class FeatureToggleExample { + // Bool for feature enabled or disabled + private static boolean isNewFeatureEnabled = false; + + public static void main(String[] args) { + boolean userIsPremium = true; // Example: Check if the user is a premium user + + // Check if the new feature should be enabled for the user + if (userIsPremium && isNewFeatureEnabled) { + // User is premium and the new feature is enabled + showNewFeature(); + } + } + + private static void showNewFeature() { + // If user is allowed to see locked feature, this is where the code would go + } +} +``` +The code shows how simple it is to implement this design pattern, and the criteria can be further refined or broadened +should the developers choose to do so. ## Class diagram  @@ -24,7 +67,20 @@ Use the Feature Toggle pattern when * Giving different features to different users. * Rolling out a new feature incrementally. * Switching between development and production environments. +* Quickly disable problematic features +* External management of feature deployment +* Ability to maintain multiple version releases of a feature +* 'Hidden' deployment, releasing a feature in code for designated testing but not publicly making it available + +## Consequences +Consequences involved with using the Feature Toggle pattern + +* Code complexity is increased +* Testing of multiple states is harder and more time-consuming +* Confusion between friends on why features are missing +* Keeping documentation up to date with all features can be difficult ## Credits * [Martin Fowler 29 October 2010 (2010-10-29).](http://martinfowler.com/bliki/FeatureToggle.html) +* [Feature Toggle - Java Design Patterns](https://java-design-patterns.com/patterns/feature-toggle/)

val

test

iluwatar

train

iluwatar/java-design-patterns/2249_2634

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2249

iluwatar/java-design-patterns/2634

b86f2357b0546f346a889d57a56f0c42346b2fcb

4d9b8b4d0fa34dd31deb3f273d50c56806a25cbb

Explanation for Object Mother

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/object-mother/README.md b/object-mother/README.md index 99d49af4b04d..4f2a6664cd48 100644 --- a/object-mother/README.md +++ b/object-mother/README.md @@ -7,7 +7,7 @@ tag: --- ## Object Mother -Define a factory of immutable content with separated builder and factory interfaces. +It is used to define a factory of immutable content with separated builder and factory interfaces. ## Class diagram  @@ -19,6 +19,69 @@ Use the Object Mother pattern when * You want to reduce code for creation of objects in tests * Every test should run with fresh data + +## Understanding the Object Mother Pattern + +### Real-World Scenario +Imagine you're developing a Java application for a travel agency. In your system, there are different types of travelers, such as tourists, business travelers, and travel agents, each with specific attributes and behaviors. To perform thorough testing, you need to create and manipulate these traveler objects in various contexts. The Object Mother Pattern can help you generate consistent and predefined traveler objects for testing purposes, ensuring that your tests are based on known, reliable data. + +### In Plain Terms +The Object Mother Pattern is a design pattern used in Java to simplify the creation of objects with specific configurations, especially for testing. Instead of manually constructing objects with varying properties for each test case, you create a dedicated "Object Mother" class or method that produces these objects with predefined settings. This ensures that you have consistent and predictable test data, making your tests more reliable and easier to manage. + +### Overview from a Testing Perspective +The Object Mother Pattern is a testing-related design pattern that assists in maintaining a consistent and reliable testing environment. It allows you to define and create objects with specific attributes, helping you ensure that your tests produce consistent and predictable results, making it easier to spot issues and maintain your test suite. + +### Practical Usage in Testing +In software testing, especially unit testing, the Object Mother Pattern is invaluable. It helps ensure that your tests are not influenced by unpredictable data, thus making your tests more robust and repeatable. By centralizing the creation of test objects in an Object Mother, you can easily adapt your test data to different scenarios. + +### Example in Java +Here's an illustrative Java example of the Object Mother Pattern within the context of a travel agency application: + +```java +class Traveler { + private String name; + private int age; + private boolean isBusinessTraveler; + + // Constructor and methods for the traveler + // ... + + // Getter and setter methods + // ... +} + +class TravelerMother { + public static Traveler createTourist(String name, int age) { + Traveler traveler = new Traveler(); + traveler.setName(name); + traveler.setAge(age); + traveler.setBusinessTraveler(false); + return traveler; + } + + public static Traveler createBusinessTraveler(String name, int age) { + Traveler traveler = new Traveler(); + traveler.setName(name); + traveler.setAge(age); + traveler.setBusinessTraveler(true); + return traveler; + } +} + +public class TravelAgency { + public static void main(String[] args) { + // Using the Object Mother to create traveler objects for testing + Traveler tourist = TravelerMother.createTourist("Alice", 28); + Traveler businessTraveler = TravelerMother.createBusinessTraveler("Bob", 35); + + // Now you have consistent traveler objects for testing. + } +} + +``` + +In this example, TravelerMother is the Object Mother class responsible for generating predefined Traveler objects with specific configurations. This approach ensures that you have consistent test data for various scenarios in a travel agency application, enhancing the reliability and effectiveness of your testing efforts. + ## Credits * [Answer by David Brown](http://stackoverflow.com/questions/923319/what-is-an-objectmother) to the stackoverflow question: [What is an ObjectMother?](http://stackoverflow.com/questions/923319/what-is-an-objectmother)

train

test

iluwatar

train

iluwatar/java-design-patterns/2631_2641

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2631

iluwatar/java-design-patterns/2641

54d628032245b1f6b00ecc6261b96b278440a7a6

09b9ee2f5f1d0c957421fbf18b09f0eccaa16502

Translate the README file of the callback pattern to Korean & Place it under localization/ko/callback

### #2282 Translate the README file of the callback pattern to Korean & Place it under localization/ko/callback

diff --git a/localization/ko/callback/README.md b/localization/ko/callback/README.md new file mode 100644 index 000000000000..b11c6dea68e7 --- /dev/null +++ b/localization/ko/callback/README.md @@ -0,0 +1,71 @@ +--- +title: Callback +category: Idiom +language: ko +tag: +- Reactive +--- + +## 의도 + +콜백은 다른 코드에 인자로 넘어가는 실행 가능한 코드의 일부로, 인자는 적절한 시점에 다시 호출 (실행) 된다. + +## 설명 + +실제 예제 + +> 실행 항목이 완료되었다는 사실을 고지받아야 할 때, 콜백 함수를 실행 항목을 담당하는 함수에게 넘겨주고 다시 호출할 때까지 기다린다. + +명확하게는 + +> 콜백은 실행 함수에 넘겨져서 정의된 순간에 호출되는 함수이다. + +위키피디아의 정의는 + +> 컴퓨터 프로그래밍에서, "사후-호출" 함수로도 알려진 콜백은, 다른 코드에 인자로 넘겨지는 실행 가능한 코드를 말한다; +> 다른 코드는 정해진 시간에 인자를 다시 호출 (실행) 할 것으로 기대되어진다. + +**코드 예제** + +콜백은 하나의 메서드를 가지고 있는 단순한 인터페이스이다. + +```java +public interface Callback { + + void call();} +``` + +다음으로 작업의 실행이 끝나고 나서 콜백을 실행시킬 Task 클래스를 정의한다. + +```java +public abstract class Task { + + final void executeWith(Callback callback) { execute(); Optional.ofNullable(callback).ifPresent(Callback::call); } + public abstract void execute();} + +@Slf4j +public final class SimpleTask extends Task { + + @Override public void execute() { LOGGER.info("우선순위의 작업을 마친 이후 콜백 메서드를 호출한다."); + }} +``` + +마지막으로, 다음은 작업을 실행한 후 마쳤을 때 콜백을 받는 방법의 예시이다. + +```java + var task = new SimpleTask(); task.executeWith(() -> LOGGER.info("완료되었음.")); +``` + +## 클래스 다이어그램 + + + +## 적용 + +콜백 패턴을 사용할 수 있을 때는 + +* 동기 또는 비동기적인 임의의 행위가 정의된 어떠한 행위의 실행 이후에 수행되어야 할 때이다. + +## 실질적인 예시들 + +* [CyclicBarrier](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#CyclicBarrier%28int,%20java.lang.Runnable%29) 생성자는 장벽이 넘어질 때마다 발동되는 콜백을 인자로 받을 수 있다. \ No newline at end of file

train

test

Nickolodeon98

train

iluwatar/java-design-patterns/2229_2645

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2229

iluwatar/java-design-patterns/2645

b86f2357b0546f346a889d57a56f0c42346b2fcb

d3cc529f6cbcb826d816e20d253ed1b618b7fad6

Explanation for Extension Objects

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/extension-objects/README.md b/extension-objects/README.md index fa00d3d5319d..5ecc08efb394 100644 --- a/extension-objects/README.md +++ b/extension-objects/README.md @@ -6,10 +6,120 @@ tag: - Extensibility --- +# Extention Objects Pattern + ## Intent Anticipate that an object’s interface needs to be extended in the future. Additional interfaces are defined by extension objects. +## Explanation +Real-world example + +> Suppose you are developing a Java-based game for a client, and in the middle of the development process, new features are suggested. The Extension Objects pattern empowers your program to adapt to unforeseen changes with minimal refactoring, especially when integrating additional functionalities into your project. + +In plain words + +> The Extension Objects pattern is used to dynamically add functionality to objects without modifying their core classes. It is a behavioural design pattern used for adding new functionality to existing classes and objects within a program. This pattern provides programmers with the ability to extend/modify class functionality without having to refactor existing source code. + +Wikipedia says + +> In object-oriented computer programming, an extension objects pattern is a design pattern added to an object after the original object was compiled. The modified object is often a class, a prototype or a type. Extension object patterns are features of some object-oriented programming languages. There is no syntactic difference between calling an extension method and calling a method declared in the type definition. + +**Programmatic example** + +The aim of utilising the Extension Objects pattern is to implement new features/functionality without having to refactor every class. +The following examples shows utilising this pattern for an Enemy class extending Entity within a game: + +Primary App class to execute our program from. +```java +public class App { + public static void main(String[] args) { + Entity enemy = new Enemy("Enemy"); + checkExtensionsForEntity(enemy); + } + + private static void checkExtensionsForEntity(Entity entity) { + Logger logger = Logger.getLogger(App.class.getName()); + String name = entity.getName(); + Function<String, Runnable> func = (e) -> () -> logger.info(name + " without " + e); + + String extension = "EnemyExtension"; + Optional.ofNullable(entity.getEntityExtension(extension)) + .map(e -> (EnemyExtension) e) + .ifPresentOrElse(EnemyExtension::extendedAction, func.apply(extension)); + } +} +``` +Enemy class with initial actions and extensions. +```java +class Enemy extends Entity { + public Enemy(String name) { + super(name); + } + + @Override + protected void performInitialAction() { + super.performInitialAction(); + System.out.println("Enemy wants to attack you."); + } + + @Override + public EntityExtension getEntityExtension(String extensionName) { + if (extensionName.equals("EnemyExtension")) { + return Optional.ofNullable(entityExtension).orElseGet(EnemyExtension::new); + } + return super.getEntityExtension(extensionName); + } +} +``` +EnemyExtension class with overriding extendAction() method. +```java +class EnemyExtension implements EntityExtension { + @Override + public void extendedAction() { + System.out.println("Enemy has advanced towards you!"); + } +} +``` +Entity class which will be extended by Enemy. +```java +class Entity { + private String name; + protected EntityExtension entityExtension; + + public Entity(String name) { + this.name = name; + performInitialAction(); + } + + protected void performInitialAction() { + System.out.println(name + " performs the initial action."); + } + + public EntityExtension getEntityExtension(String extensionName) { + return null; + } + + public String getName() { + return name; + } +} +``` +EntityExtension interface to be used by EnemyExtension. +```java +interface EntityExtension { + void extendedAction(); +} +``` +Program output: +```markdown +Enemy performs the initial action. +Enemy wants to attack you. +Enemy has advanced towards you! +``` +In this example, the Extension Objects pattern allows the enemy entity to perform unique initial actions and advanced actions when specific extensions are applied. This pattern provides flexibility and extensibility to the codebase while minimizing the need for major code changes. + + ## Class diagram 

val

test

iluwatar

train

iluwatar/java-design-patterns/2248_2706

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2248

iluwatar/java-design-patterns/2706

f63c5dd46ddaaeaa6c2844dd7db6192fafce616a

7fdd5742a229c6c19be3284224f68804515bc3b5

Explanation for Naked Objects

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/naked-objects/README.md b/naked-objects/README.md index b091c55d0414..8ed8210de4d2 100644 --- a/naked-objects/README.md +++ b/naked-objects/README.md @@ -3,40 +3,142 @@ title: Naked Objects category: Architectural language: en tag: -- Decoupling -- Extensibility -- Presentation + - Decoupling + - Extensibility + - Presentation --- ## Intent -The Naked Objects architectural pattern is well suited for rapid -prototyping. Using the pattern, you only need to write the domain objects, -everything else is autogenerated by the framework. This pattern enforces a strong domain-driven design principle as the generated UI directly reflects your domain objects and allows users to view as well as interact with them directly (hence the 'naked' part). This allows the users to become more of a problem-solver rather than a process-follower when using the UI. + +> The naked object design pattern is a way to build user interfaces (UIs) for software applications that is based on the idea of direct manipulation. This means that users interact directly with the underlying domain objects of the application, without any intermediary UI elements. + +> The naked object pattern is implemented by exposing the domain objects to the user in a way that is both meaningful and accessible. This is typically done by generating a UI automatically from the domain object definitions. The UI presents the domain objects to the user in a simple and straightforward way, allowing them to create, retrieve, update, and delete objects, as well as invoke methods on them. + +> The naked object pattern has a number of advantages, including: + +> 1. <ins>Reduced development time and cost</ins>: The naked object pattern can significantly reduce the time and cost required to develop and maintain a software application. This is because the UI is generated automatically, and the domain objects are designed to be both user-visible and manipulatable. + +> 2. <ins>Empowered users</ins>: The naked object pattern gives users direct access to the underlying domain objects of the application. This allows them to interact with the application in a way that is natural and intuitive. + +> 3. <ins>Increased flexibility and adaptability</ins>: The naked object pattern is highly flexible and adaptable. This is because the UI is generated from the domain object definitions, which means that the UI can be easily changed as the domain model evolves. ## Explanation - + **In plain words** -> Naked objects allows you to rapidly generate objected-oriented UI that allows users to perform tasks in ways that they want. - +> Imagine you are building a software application to manage a customer database. You could use the naked object pattern to build the UI for this application as follows: + +> 1. Define the domain objects for your application. This includes objects such as Customer, Order, and Product. + +> 2. Implement the business logic for your application on these domain objects. For example, you could implement methods to create a new customer, add a product to an order, or calculate the total price of an order. + +> 3. Use a naked object framework to generate a UI for your application from the domain object definitions. + +> The generated UI will present the domain objects to the user in a simple and straightforward way. The user will be able to create, retrieve, update, and delete customers, orders, and products, as well as invoke methods on them. + +For example, the user could create a new customer by entering the customer's name, address, and phone number into the UI. The user could also retrieve a list of all customers by clicking a button. To update a customer's information, the user could simply change the corresponding values in the UI and click a save button. + **Wikipedia says** + > Naked objects is an architectural pattern used in software engineering. It is defined by three principles: -> +> > 1. All business logic should be encapsulated onto the domain objects. This principle is not unique to naked objects; it is a strong commitment to encapsulation. > 2. The user interface should be a direct representation of the domain objects, with all user actions consisting of creating, retrieving, or invoking methods on domain objects. This principle is not unique to naked objects: it is an interpretation of an object-oriented user interface. > -> The naked object pattern's innovative feature arises by combining the 1st and 2nd principles into a 3rd principle: -> 3. The user interface shall be entirely automatically created from the definitions of the domain objects. This may be done using reflection or source code generation. +> The naked object pattern's innovative feature arises by combining the 1st and 2nd principles into a 3rd principle: 3. The user interface shall be entirely automatically created from the definitions of the domain objects. This may be done using reflection or source code generation. + +## Programmatic example + +> Certainly, here's a programmatic example section for the Naked Objects pattern: + +## Programmatic Example + +In the context of the Naked Objects pattern, let's consider a simplified example with domain objects representing books and authors. The example demonstrates how the Naked Objects pattern can be applied to create a user interface for managing a library catalog. + +Suppose we have the following domain objects in a Java-based application: + +````java +@DomainObject +public class Book { + @Property + private String title; + + @Property + private String author; + + @Action + public void borrow() { + // Implement borrowing logic here + } +} + +@DomainObject +public class Author { + @Property + private String name; + + @Collection + public List<Book> getBooks() { + // Implement logic to retrieve books by this author + } + + @Action + public Book createBook(String title) { + // Implement logic to create a new book by this author + } +} +```` + + +> In this example, we define two domain objects: Book and Author. The Book class has properties for the title and author, as well as an action to borrow the book. The Author class has a property for the author's name, a collection of books they have written, and an action to create a new book. + +> With the Naked Objects framework or tool, the user interface for managing books and authors can be automatically generated based on these domain object definitions. Users can interact with the generated UI to create, retrieve, update, and delete books and authors directly through a user-friendly interface. +> Here's how you can use these domain objects to create and interact with books and authors programmatically: + +```java +var author = new Author(); +author.setName("J.K. Rowling"); +var book = author.createBook("Harry Potter and the Philosopher's Stone"); +book.setAuthor(author); +book.borrow(); + +var booksByAuthor = author.getBooks(); + +``` +> This example demonstrates how the Naked Objects pattern can be implemented in a Java-based application with domain objects for books and authors. Users can directly manipulate these domain objects through the generated user interface. + ## Applicability -Use the Naked Objects pattern when -* You are prototyping and need fast development cycle -* An autogenerated user interface is good enough -* You want to automatically publish the domain as REST services +> The naked objects pattern is applicable to a wide range of software applications, but it is particularly well-suited for applications where users need to have direct access to the underlying data model. This is often the case in business applications, such as: + +* Customer relationship management (CRM) systems +* Enterprise resource planning (ERP) systems +* Human resources (HR) systems +* Order management systems +* Inventory management systems +* Asset management systems +* Project management systems +* Knowledge management systems + +> The naked objects pattern can also be used to build UIs for scientific and engineering applications, such as: + +* Data analysis applications +* Simulation applications +* Modeling applications +* Visualization applications +>In general, the naked objects pattern is a good choice for any application where users need to be able to create, retrieve, update, and delete data, as well as run complex reports and analyses on that data. + +## Known uses +> 1. Here are some specific examples of applications that have been built using the naked objects pattern: + +> 2. The Department of Social and Family Affairs in Ireland uses the naked objects pattern for its Child Benefit Administration system. + +> 3. The UK National Health Service uses the naked objects pattern for its Electronic Patient Record system. + +> 4. The Australian Taxation Office uses the naked objects pattern for its tax return processing system. -## Known uses -> The Department of Social and Family Affairs in Ireland, responsible for social welfare payments, has successfully incorporated the naked objects pattern for re-designing their existing Child Benefit Administration system architecture. A case study evaluation of the project shows that users had positive responses to the increased flexibility of working with the new system and that it is easier now to respond to future changes. +> 5. The US Department of Defense uses the naked objects pattern for its logistics management system. ## Quick start @@ -48,3 +150,4 @@ Apache Isis is a Java framework that implements the naked objects pattern. Check * [Apache Isis - Introducing Apache Isis](https://isis.apache.org/versions/1.16.0/pages/downloadable-presentations/resources/downloadable-presentations/IntroducingApacheIsis-notes.pdf) +````

test

test

iluwatar

train

iluwatar/java-design-patterns/2255_2707

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2255

iluwatar/java-design-patterns/2707

f63c5dd46ddaaeaa6c2844dd7db6192fafce616a

b186ff5e731fa3c1654ccfa812533b6aa61bf354

Explanation for Queue-Based Load Leveling

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/queue-load-leveling/README.md b/queue-load-leveling/README.md index 5bffdcb2958c..49c37e6238dc 100644 --- a/queue-load-leveling/README.md +++ b/queue-load-leveling/README.md @@ -14,6 +14,281 @@ intermittent heavy loads that may otherwise cause the service to fail or the tas This pattern can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service. +## Explanation + +Real world example +> A Microsoft Azure web role stores data by using a separate storage service. If a large number of instances of the web +> role run concurrently, it is possible that the storage service could be overwhelmed and be unable to respond to requests +> quickly enough to prevent these requests from timing out or failing. + +In plain words +> Makes resource-load balanced by ensuring an intermediate data structure like queue that makes bridge +> between service-takers and service-givers. Where both takers and givers are running asynchronously and +> service-takers can tolerate some amount of delay to get feedback. +> + +Wikipedia says + +> In computing, load balancing is the process of distributing a set of tasks over a set of resources +> (computing units), with the aim of making their overall processing more efficient. Load balancing can +> optimize the response time and avoid unevenly overloading some compute nodes while other compute nodes +> are left idle. + +**Programmatic Example** + +TaskGenerator implements Task, runnable interfaces. Hence, It runs asynchronously. + +```java +/** + * Task Interface. + */ +public interface Task { + void submit(Message msg); +} +``` +It submits tasks to ServiceExecutor to serve tasks. +```java +/** + * TaskGenerator class. Each TaskGenerator thread will be a Worker which submit's messages to the + * queue. We need to mention the message count for each of the TaskGenerator threads. + */ +@Slf4j +public class TaskGenerator implements Task, Runnable { + + // MessageQueue reference using which we will submit our messages. + private final MessageQueue msgQueue; + + // Total message count that a TaskGenerator will submit. + private final int msgCount; + + // Parameterized constructor. + public TaskGenerator(MessageQueue msgQueue, int msgCount) { + this.msgQueue = msgQueue; + this.msgCount = msgCount; + } + + /** + * Submit messages to the Blocking Queue. + */ + public void submit(Message msg) { + try { + this.msgQueue.submitMsg(msg); + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + } + + /** + * Each TaskGenerator thread will submit all the messages to the Queue. After every message + * submission TaskGenerator thread will sleep for 1 second. + */ + public void run() { + var count = this.msgCount; + + try { + while (count > 0) { + var statusMsg = "Message-" + count + " submitted by " + Thread.currentThread().getName(); + this.submit(new Message(statusMsg)); + + LOGGER.info(statusMsg); + + // reduce the message count. + count--; + + // Make the current thread to sleep after every Message submission. + Thread.sleep(1000); + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + } +} +``` +It also implements runnable interface and run asynchronously. It retrieves tasks one by one +from blockingQueue to serve. +```java +/** + * ServiceExecuotr class. This class will pick up Messages one by one from the Blocking Queue and + * process them. + */ +@Slf4j +public class ServiceExecutor implements Runnable { + + private final MessageQueue msgQueue; + + public ServiceExecutor(MessageQueue msgQueue) { + this.msgQueue = msgQueue; + } + + /** + * The ServiceExecutor thread will retrieve each message and process it. + */ + public void run() { + try { + while (!Thread.currentThread().isInterrupted()) { + var msg = msgQueue.retrieveMsg(); + + if (null != msg) { + LOGGER.info(msg.toString() + " is served."); + } else { + LOGGER.info("Service Executor: Waiting for Messages to serve .. "); + } + + Thread.sleep(1000); + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + } +} +``` + +BlockingQueue data-structure is used in MessageQueue class for acting buffer +between TaskGenerator to ServiceExecutor. + +```java +public class MessageQueue { + + private final BlockingQueue<Message> blkQueue; + + // Default constructor when called creates Blocking Queue object. + public MessageQueue() { + this.blkQueue = new ArrayBlockingQueue<>(1024); + } + + /** + * All the TaskGenerator threads will call this method to insert the Messages in to the Blocking + * Queue. + */ + public void submitMsg(Message msg) { + try { + if (null != msg) { + blkQueue.add(msg); + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + } + + /** + * All the messages will be retrieved by the ServiceExecutor by calling this method and process + * them. Retrieves and removes the head of this queue, or returns null if this queue is empty. + */ + public Message retrieveMsg() { + try { + return blkQueue.poll(); + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + return null; + } +} +``` +TaskGenerator submit message object to ServiceExecutor for serving. +```java +/** + * Message class with only one parameter. + */ +@Getter +@RequiredArgsConstructor +public class Message { + private final String msg; + + @Override + public String toString() { + return msg; + } +} +``` +To simulate the situation ExecutorService is used here. ExecutorService automatically provides a pool of threads and +an API for assigning tasks to it. +```java +public class App { + + //Executor shut down time limit. + private static final int SHUTDOWN_TIME = 15; + + /** + * Program entry point. + * + * @param args command line args + */ + public static void main(String[] args) { + + // An Executor that provides methods to manage termination and methods that can + // produce a Future for tracking progress of one or more asynchronous tasks. + ExecutorService executor = null; + + try { + // Create a MessageQueue object. + var msgQueue = new MessageQueue(); + + LOGGER.info("Submitting TaskGenerators and ServiceExecutor threads."); + + // Create three TaskGenerator threads. Each of them will submit different number of jobs. + final var taskRunnable1 = new TaskGenerator(msgQueue, 5); + final var taskRunnable2 = new TaskGenerator(msgQueue, 1); + final var taskRunnable3 = new TaskGenerator(msgQueue, 2); + + // Create e service which should process the submitted jobs. + final var srvRunnable = new ServiceExecutor(msgQueue); + + // Create a ThreadPool of 2 threads and + // submit all Runnable task for execution to executor.. + executor = Executors.newFixedThreadPool(2); + executor.submit(taskRunnable1); + executor.submit(taskRunnable2); + executor.submit(taskRunnable3); + + // submitting serviceExecutor thread to the Executor service. + executor.submit(srvRunnable); + + // Initiates an orderly shutdown. + LOGGER.info("Initiating shutdown." + + " Executor will shutdown only after all the Threads are completed."); + executor.shutdown(); + + // Wait for SHUTDOWN_TIME seconds for all the threads to complete + // their tasks and then shut down the executor and then exit. + if (!executor.awaitTermination(SHUTDOWN_TIME, TimeUnit.SECONDS)) { + LOGGER.info("Executor was shut down and Exiting."); + executor.shutdownNow(); + } + } catch (Exception e) { + LOGGER.error(e.getMessage()); + } + } +} +``` + +The console output +``` +[main] INFO App - Submitting TaskGenerators and ServiceExecutor threads. +[main] INFO App - Initiating shutdown. Executor will shutdown only after all the Threads are completed. +[pool-1-thread-2] INFO TaskGenerator - Message-1 submitted by pool-1-thread-2 +[pool-1-thread-1] INFO TaskGenerator - Message-5 submitted by pool-1-thread-1 +[pool-1-thread-1] INFO TaskGenerator - Message-4 submitted by pool-1-thread-1 +[pool-1-thread-2] INFO TaskGenerator - Message-2 submitted by pool-1-thread-2 +[pool-1-thread-1] INFO TaskGenerator - Message-3 submitted by pool-1-thread-1 +[pool-1-thread-2] INFO TaskGenerator - Message-1 submitted by pool-1-thread-2 +[pool-1-thread-1] INFO TaskGenerator - Message-2 submitted by pool-1-thread-1 +[pool-1-thread-2] INFO ServiceExecutor - Message-1 submitted by pool-1-thread-2 is served. +[pool-1-thread-1] INFO TaskGenerator - Message-1 submitted by pool-1-thread-1 +[pool-1-thread-2] INFO ServiceExecutor - Message-5 submitted by pool-1-thread-1 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-4 submitted by pool-1-thread-1 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-2 submitted by pool-1-thread-2 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-3 submitted by pool-1-thread-1 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-1 submitted by pool-1-thread-2 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-2 submitted by pool-1-thread-1 is served. +[pool-1-thread-2] INFO ServiceExecutor - Message-1 submitted by pool-1-thread-1 is served. +[pool-1-thread-2] INFO ServiceExecutor - Service Executor: Waiting for Messages to serve .. +[pool-1-thread-2] INFO ServiceExecutor - Service Executor: Waiting for Messages to serve .. +[pool-1-thread-2] INFO ServiceExecutor - Service Executor: Waiting for Messages to serve .. +[pool-1-thread-2] INFO ServiceExecutor - Service Executor: Waiting for Messages to serve .. +[main] INFO App - Executor was shut down and Exiting. +[pool-1-thread-2] ERROR ServiceExecutor - sleep interrupted +``` + ## Class diagram  @@ -25,10 +300,8 @@ for both the task and the service. ## Tutorials * [Queue-Based Load Leveling Pattern](http://java-design-patterns.com/blog/queue-load-leveling/) -## Real world example - -* A Microsoft Azure web role stores data by using a separate storage service. If a large number of instances of the web role run concurrently, it is possible that the storage service could be overwhelmed and be unable to respond to requests quickly enough to prevent these requests from timing out or failing. ## Credits * [Queue-Based Load Leveling pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling) +* [Load-Balancing](https://www.wikiwand.com/en/Load_balancing_(computing))

train

test

iluwatar

train

iluwatar/java-design-patterns/2247_2716

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2247

iluwatar/java-design-patterns/2716

f63c5dd46ddaaeaa6c2844dd7db6192fafce616a

bb8de8701588261c5c6b0a0bdf3b4b1e122e4263

Explanation for Mute Idiom

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/mute-idiom/README.md b/mute-idiom/README.md index 6e94ce4d989f..1b25e95fcaf5 100644 --- a/mute-idiom/README.md +++ b/mute-idiom/README.md @@ -2,23 +2,94 @@ title: Mute Idiom category: Idiom language: en -tag: - - Decoupling +tag: +- Decoupling --- + ## Intent Provide a template to suppress any exceptions that either are declared but cannot occur or should only be logged; while executing some business logic. The template removes the need to write repeated `try-catch` blocks. + +## Explanation +Real World Example +> The vending machine contained in your office displays a warning when making a transaction. The issue occurs when the +> customer decides to pay with physical money that is not recognized by the system. However, you and everyone in the office +> only pays with the company credit card and will never encounter this issue. + +In plain words +> The Mute Idiom design pattern is used to reduce the requirement of catching exceptions when they cannot be thrown or +> should be ignored when thrown. This applies in cases such as API functions, where the underlying code cannot be changed +> to include individual use cases. + +Programmatic Example + +Converting the real-world example into a programmatic representation, we represent an API function as the +office Vending machine + +```java + +public class VendingMachine { + public void purchaseItem(int itemID, PaymentMethod paymentMethod) throws Exception { + if (paymentMethod == PaymentMethod.Cash) { + throw new Exception(); + } + else { + System.out.println("Here is your item"); + } + } +} +``` + +```java +public enum PaymentMethod { + Card,Cash +} +``` + +We then run our office's daily routine, which involves purchasing items +from the vending machine with the company card, using the mute pattern to ignore the exceptions that can't be thrown +```java +package com.iluwatar.mute; + +public class Office { + private PaymentMethod companyCard = PaymentMethod.Card; + private VendingMachine officeVendingMachine = new VendingMachine(); + + public static void main(String[] args) { + Office office = new Office(); + office.dailyRoutine(); + + } + public void dailyRoutine() { + Mute.mute(() -> { + officeVendingMachine.purchaseItem(1,companyCard); + officeVendingMachine.purchaseItem(1,companyCard); + officeVendingMachine.purchaseItem(1,companyCard); + }); + } +} + +``` + + ## Class diagram  + ## Applicability Use this idiom when - * an API declares some exception but can never throw that exception eg. ByteArrayOutputStream bulk write method. * you need to suppress some exception just by logging it, such as closing a resource. + + + ## Credits + * [JOOQ: Mute Design Pattern](http://blog.jooq.org/2016/02/18/the-mute-design-pattern/) + + +

train

test

iluwatar

train

iluwatar/java-design-patterns/2245_2717

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2245

iluwatar/java-design-patterns/2717

f63c5dd46ddaaeaa6c2844dd7db6192fafce616a

fb507110442bc2a132704c45bdc6364197c0119d

Explanation for Monad

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/monad/README.md b/monad/README.md index f53632faee70..9ccaaebb98ce 100644 --- a/monad/README.md +++ b/monad/README.md @@ -15,6 +15,107 @@ operations: bind - that takes monadic object and a function from plain object to monadic value and returns monadic value return - that takes plain type object and returns this object wrapped in a monadic value. +## Explanation + +The Monad pattern provides a way to chain operations together and manage sequencing, +side effects, and exception handling in a consistent manner. + +Real-world example + +> Consider a conveyor belt in a factory: items move from one station to another, +> and each station performs a specific task, with the assurance that every task will be carried out, +> even if some items are rejected at certain stations. + +In plain words + +> Monad pattern ensures that each operation is executed regardless of the success or failure of previous ones. + +Wikipedia says + +> In functional programming, a monad is a structure that combines program fragments (functions) +> and wraps their return values in a type with additional computation. In addition to defining a +> wrapping monadic type, monads define two operators: one to wrap a value in the monad type, and +> another to compose together functions that output values of the monad type (these are known as +> monadic functions). General-purpose languages use monads to reduce boilerplate code needed for +> common operations (such as dealing with undefined values or fallible functions, or encapsulating +> bookkeeping code). Functional languages use monads to turn complicated sequences of functions into +> succinct pipelines that abstract away control flow, and side-effects. + +**Programmatic Example** + +Here’s the Monad implementation in Java. + +The `Validator` takes an object, validates it against specified predicates, and collects any +validation errors. The `validate` method allows you to add validation steps, and the `get` method +either returns the validated object or throws an `IllegalStateException` with a list of validation +exceptions if any of the validation steps fail. + +```java +public class Validator<T> { + private final T obj; + private final List<Throwable> exceptions = new ArrayList<>(); + + private Validator(T obj) { + this.obj = obj; + } + public static <T> Validator<T> of(T t) { + return new Validator<>(Objects.requireNonNull(t)); + } + + public Validator<T> validate(Predicate<? super T> validation, String message) { + if (!validation.test(obj)) { + exceptions.add(new IllegalStateException(message)); + } + return this; + } + + public <U> Validator<T> validate( + Function<? super T, ? extends U> projection, + Predicate<? super U> validation, + String message + ) { + return validate(projection.andThen(validation::test)::apply, message); + } + + public T get() throws IllegalStateException { + if (exceptions.isEmpty()) { + return obj; + } + var e = new IllegalStateException(); + exceptions.forEach(e::addSuppressed); + throw e; + } +} +``` + +Next we define an enum `Sex`. + +```java +public enum Sex { + MALE, FEMALE +} +``` + +Now we can introduce the `User`. + +```java +public record User(String name, int age, Sex sex, String email) { +} +``` + +And finally, a `User` object is validated for its name, email, and age using the `Validator` monad. + +```java +public static void main(String[] args) { + var user = new User("user", 24, Sex.FEMALE, "foobar.com"); + LOGGER.info(Validator.of(user).validate(User::name, Objects::nonNull, "name is null") + .validate(User::name, name -> !name.isEmpty(), "name is empty") + .validate(User::email, email -> !email.contains("@"), "email doesn't contains '@'") + .validate(User::age, age -> age > 20 && age < 30, "age isn't between...").get() + .toString()); +} +``` + ## Class diagram 

test

test

iluwatar

train

iluwatar/java-design-patterns/2238_2770

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2238

iluwatar/java-design-patterns/2770

163c3017bb356937d876cd9a05905c012f3b0af6

2c35b34c41e14affe08179150b9e66b361ef6851

Explanation for Leader Election

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/leader-election/README.md b/leader-election/README.md index d2a6ff473e3f..ec57487a9c03 100644 --- a/leader-election/README.md +++ b/leader-election/README.md @@ -7,7 +7,821 @@ tag: --- ## Intent -Leader Election pattern is commonly used in cloud system design. It can help to ensure that task instances select the leader instance correctly and do not conflict with each other, cause contention for shared resources, or inadvertently interfere with the work that other task instances are performing. +Leader Election pattern is commonly used in cloud system design. It can help to ensure that task +instances select the leader instance correctly and do not conflict with each other, cause +contention for shared resources, or inadvertently interfere with the work that other task +instances are performing. + +## Explanation + +Real world example +> In a horizontally scaling cloud-based system, multiple instances of the same task could be +> running at the same time with each instance serving a different user. If these instances +> write to a shared resource, it's necessary to coordinate their actions to prevent each instance +> from overwriting the changes made by the others. In another scenario, if the tasks are performing +> individual elements of a complex calculation in parallel, the results need to be aggregated +> when they all complete. + +In plain words +> this pattern is used in distributed cloud-based system where leader must need to act as +> coordinator/aggregator among horizontal scaling instances for avoiding conflict on shared resources. + +Wikipedia says +> In distributed computing, leader election is the process of designating a single process as +> the organizer of some task distributed among several computers (nodes). + +**Programmatic Example** + +Ring algorithm and Bully algorithm implement leader election pattern. +Each algorithm require every participated instance to have unique ID. + +```java +public interface Instance { + + /** + * Check if the instance is alive or not. + * + * @return {@code true} if the instance is alive. + */ + boolean isAlive(); + + /** + * Set the health status of the certain instance. + * + * @param alive {@code true} for alive. + */ + void setAlive(boolean alive); + + /** + * Consume messages from other instances. + * + * @param message Message sent by other instances + */ + void onMessage(Message message); + +} +``` + +Abstract class who implements Instance and Runnable interfaces. +```java +public abstract class AbstractInstance implements Instance, Runnable { + + protected static final int HEARTBEAT_INTERVAL = 5000; + private static final String INSTANCE = "Instance "; + + protected MessageManager messageManager; + protected Queue<Message> messageQueue; + protected final int localId; + protected int leaderId; + protected boolean alive; + + /** + * Constructor of BullyInstance. + */ + public AbstractInstance(MessageManager messageManager, int localId, int leaderId) { + this.messageManager = messageManager; + this.messageQueue = new ConcurrentLinkedQueue<>(); + this.localId = localId; + this.leaderId = leaderId; + this.alive = true; + } + + /** + * The instance will execute the message in its message queue periodically once it is alive. + */ + @Override + @SuppressWarnings("squid:S2189") + public void run() { + while (true) { + if (!this.messageQueue.isEmpty()) { + this.processMessage(this.messageQueue.remove()); + } + } + } + + /** + * Once messages are sent to the certain instance, it will firstly be added to the queue and wait + * to be executed. + * + * @param message Message sent by other instances + */ + @Override + public void onMessage(Message message) { + messageQueue.offer(message); + } + + /** + * Check if the instance is alive or not. + * + * @return {@code true} if the instance is alive. + */ + @Override + public boolean isAlive() { + return alive; + } + + /** + * Set the health status of the certain instance. + * + * @param alive {@code true} for alive. + */ + @Override + public void setAlive(boolean alive) { + this.alive = alive; + } + + /** + * Process the message according to its type. + * + * @param message Message polled from queue. + */ + private void processMessage(Message message) { + switch (message.getType()) { + case ELECTION -> { + LOGGER.info(INSTANCE + localId + " - Election Message handling..."); + handleElectionMessage(message); + } + case LEADER -> { + LOGGER.info(INSTANCE + localId + " - Leader Message handling..."); + handleLeaderMessage(message); + } + case HEARTBEAT -> { + LOGGER.info(INSTANCE + localId + " - Heartbeat Message handling..."); + handleHeartbeatMessage(message); + } + case ELECTION_INVOKE -> { + LOGGER.info(INSTANCE + localId + " - Election Invoke Message handling..."); + handleElectionInvokeMessage(); + } + case LEADER_INVOKE -> { + LOGGER.info(INSTANCE + localId + " - Leader Invoke Message handling..."); + handleLeaderInvokeMessage(); + } + case HEARTBEAT_INVOKE -> { + LOGGER.info(INSTANCE + localId + " - Heartbeat Invoke Message handling..."); + handleHeartbeatInvokeMessage(); + } + default -> { + } + } + } + + /** + * Abstract methods to handle different types of message. These methods need to be implemented in + * concrete instance class to implement corresponding leader-selection pattern. + */ + protected abstract void handleElectionMessage(Message message); + + protected abstract void handleElectionInvokeMessage(); + + protected abstract void handleLeaderMessage(Message message); + + protected abstract void handleLeaderInvokeMessage(); + + protected abstract void handleHeartbeatMessage(Message message); + + protected abstract void handleHeartbeatInvokeMessage(); + +} +``` + +```java +/** + * Message used to transport data between instances. + */ +@Setter +@Getter +@EqualsAndHashCode +@AllArgsConstructor +@NoArgsConstructor +public class Message { + + private MessageType type; + private String content; + +} +``` + +```java +public interface MessageManager { + + /** + * Send heartbeat message to leader instance to check whether the leader instance is alive. + * + * @param leaderId Instance ID of leader instance. + * @return {@code true} if leader instance is alive, or {@code false} if not. + */ + boolean sendHeartbeatMessage(int leaderId); + + /** + * Send election message to other instances. + * + * @param currentId Instance ID of which sends this message. + * @param content Election message content. + * @return {@code true} if the message is accepted by the target instances. + */ + boolean sendElectionMessage(int currentId, String content); + + /** + * Send new leader notification message to other instances. + * + * @param currentId Instance ID of which sends this message. + * @param leaderId Leader message content. + * @return {@code true} if the message is accepted by the target instances. + */ + boolean sendLeaderMessage(int currentId, int leaderId); + + /** + * Send heartbeat invoke message. This will invoke heartbeat task in the target instance. + * + * @param currentId Instance ID of which sends this message. + */ + void sendHeartbeatInvokeMessage(int currentId); + +} +``` +These type of messages are used to pass among instances. +```java +/** + * Message Type enum. + */ +public enum MessageType { + + /** + * Start the election. The content of the message stores ID(s) of the candidate instance(s). + */ + ELECTION, + + /** + * Nodify the new leader. The content of the message should be the leader ID. + */ + LEADER, + + /** + * Check health of current leader instance. + */ + HEARTBEAT, + + /** + * Inform target instance to start election. + */ + ELECTION_INVOKE, + + /** + * Inform target instance to notify all the other instance that it is the new leader. + */ + LEADER_INVOKE, + + /** + * Inform target instance to start heartbeat. + */ + HEARTBEAT_INVOKE + +} +``` +Abstract class who implements MessageManager interface. It helps to manage messages among instance. +```java +/** + * Abstract class of all the message manager classes. + */ +public abstract class AbstractMessageManager implements MessageManager { + + /** + * Contain all the instances in the system. Key is its ID, and value is the instance itself. + */ + protected Map<Integer, Instance> instanceMap; + + /** + * Constructor of AbstractMessageManager. + */ + public AbstractMessageManager(Map<Integer, Instance> instanceMap) { + this.instanceMap = instanceMap; + } + + /** + * Find the next instance with smallest ID. + * + * @return The next instance. + */ + protected Instance findNextInstance(int currentId) { + Instance result = null; + var candidateList = instanceMap.keySet() + .stream() + .filter((i) -> i > currentId && instanceMap.get(i).isAlive()) + .sorted() + .toList(); + if (candidateList.isEmpty()) { + var index = instanceMap.keySet() + .stream() + .filter((i) -> instanceMap.get(i).isAlive()) + .sorted() + .toList() + .get(0); + result = instanceMap.get(index); + } else { + var index = candidateList.get(0); + result = instanceMap.get(index); + } + return result; + } + +} +``` + +Here the implementation of Ring Algorithm +```java +/** + * Implementation with token ring algorithm. The instances in the system are organized as a ring. + * Each instance should have a sequential id and the instance with smallest (or largest) id should + * be the initial leader. All the other instances send heartbeat message to leader periodically to + * check its health. If one certain instance finds the server done, it will send an election message + * to the next alive instance in the ring, which contains its own ID. Then the next instance add its + * ID into the message and pass it to the next. After all the alive instances' ID are add to the + * message, the message is send back to the first instance and it will choose the instance with + * smallest ID to be the new leader, and then send a leader message to other instances to inform the + * result. + */ +@Slf4j +public class RingInstance extends AbstractInstance { + private static final String INSTANCE = "Instance "; + + /** + * Constructor of RingInstance. + */ + public RingInstance(MessageManager messageManager, int localId, int leaderId) { + super(messageManager, localId, leaderId); + } + + /** + * Process the heartbeat invoke message. After receiving the message, the instance will send a + * heartbeat to leader to check its health. If alive, it will inform the next instance to do the + * heartbeat. If not, it will start the election process. + */ + @Override + protected void handleHeartbeatInvokeMessage() { + try { + var isLeaderAlive = messageManager.sendHeartbeatMessage(this.leaderId); + if (isLeaderAlive) { + LOGGER.info(INSTANCE + localId + "- Leader is alive. Start next heartbeat in 5 second."); + Thread.sleep(HEARTBEAT_INTERVAL); + messageManager.sendHeartbeatInvokeMessage(this.localId); + } else { + LOGGER.info(INSTANCE + localId + "- Leader is not alive. Start election."); + messageManager.sendElectionMessage(this.localId, String.valueOf(this.localId)); + } + } catch (InterruptedException e) { + LOGGER.info(INSTANCE + localId + "- Interrupted."); + } + } + + /** + * Process election message. If the local ID is contained in the ID list, the instance will select + * the alive instance with smallest ID to be the new leader, and send the leader inform message. + * If not, it will add its local ID to the list and send the message to the next instance in the + * ring. + */ + @Override + protected void handleElectionMessage(Message message) { + var content = message.getContent(); + LOGGER.info(INSTANCE + localId + " - Election Message: " + content); + var candidateList = Arrays.stream(content.trim().split(",")) + .map(Integer::valueOf) + .sorted() + .toList(); + if (candidateList.contains(localId)) { + var newLeaderId = candidateList.get(0); + LOGGER.info(INSTANCE + localId + " - New leader should be " + newLeaderId + "."); + messageManager.sendLeaderMessage(localId, newLeaderId); + } else { + content += "," + localId; + messageManager.sendElectionMessage(localId, content); + } + } + + /** + * Process leader Message. The instance will set the leader ID to be the new one and send the + * message to the next instance until all the alive instance in the ring is informed. + */ + @Override + protected void handleLeaderMessage(Message message) { + var newLeaderId = Integer.valueOf(message.getContent()); + if (this.leaderId != newLeaderId) { + LOGGER.info(INSTANCE + localId + " - Update leaderID"); + this.leaderId = newLeaderId; + messageManager.sendLeaderMessage(localId, newLeaderId); + } else { + LOGGER.info(INSTANCE + localId + " - Leader update done. Start heartbeat."); + messageManager.sendHeartbeatInvokeMessage(localId); + } + } + + /** + * Not used in Ring instance. + */ + @Override + protected void handleLeaderInvokeMessage() { + // Not used in Ring instance. + } + + @Override + protected void handleHeartbeatMessage(Message message) { + // Not used in Ring instance. + } + + @Override + protected void handleElectionInvokeMessage() { + // Not used in Ring instance. + } + +} +``` + +```java +/** + * Implementation of RingMessageManager. + */ +public class RingMessageManager extends AbstractMessageManager { + + /** + * Constructor of RingMessageManager. + */ + public RingMessageManager(Map<Integer, Instance> instanceMap) { + super(instanceMap); + } + + /** + * Send heartbeat message to current leader instance to check the health. + * + * @param leaderId leaderID + * @return {@code true} if the leader is alive. + */ + @Override + public boolean sendHeartbeatMessage(int leaderId) { + var leaderInstance = instanceMap.get(leaderId); + var alive = leaderInstance.isAlive(); + return alive; + } + + /** + * Send election message to the next instance. + * + * @param currentId currentID + * @param content list contains all the IDs of instances which have received this election + * message. + * @return {@code true} if the election message is accepted by the target instance. + */ + @Override + public boolean sendElectionMessage(int currentId, String content) { + var nextInstance = this.findNextInstance(currentId); + var electionMessage = new Message(MessageType.ELECTION, content); + nextInstance.onMessage(electionMessage); + return true; + } + + /** + * Send leader message to the next instance. + * + * @param currentId Instance ID of which sends this message. + * @param leaderId Leader message content. + * @return {@code true} if the leader message is accepted by the target instance. + */ + @Override + public boolean sendLeaderMessage(int currentId, int leaderId) { + var nextInstance = this.findNextInstance(currentId); + var leaderMessage = new Message(MessageType.LEADER, String.valueOf(leaderId)); + nextInstance.onMessage(leaderMessage); + return true; + } + + /** + * Send heartbeat invoke message to the next instance. + * + * @param currentId Instance ID of which sends this message. + */ + @Override + public void sendHeartbeatInvokeMessage(int currentId) { + var nextInstance = this.findNextInstance(currentId); + var heartbeatInvokeMessage = new Message(MessageType.HEARTBEAT_INVOKE, ""); + nextInstance.onMessage(heartbeatInvokeMessage); + } + +} +``` +```java +public static void main(String[] args) { + + Map<Integer, Instance> instanceMap = new HashMap<>(); + var messageManager = new RingMessageManager(instanceMap); + + var instance1 = new RingInstance(messageManager, 1, 1); + var instance2 = new RingInstance(messageManager, 2, 1); + var instance3 = new RingInstance(messageManager, 3, 1); + var instance4 = new RingInstance(messageManager, 4, 1); + var instance5 = new RingInstance(messageManager, 5, 1); + + instanceMap.put(1, instance1); + instanceMap.put(2, instance2); + instanceMap.put(3, instance3); + instanceMap.put(4, instance4); + instanceMap.put(5, instance5); + + instance2.onMessage(new Message(MessageType.HEARTBEAT_INVOKE, "")); + + final var thread1 = new Thread(instance1); + final var thread2 = new Thread(instance2); + final var thread3 = new Thread(instance3); + final var thread4 = new Thread(instance4); + final var thread5 = new Thread(instance5); + + thread1.start(); + thread2.start(); + thread3.start(); + thread4.start(); + thread5.start(); + + instance1.setAlive(false); + } +``` + +The console output +``` +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Heartbeat Invoke Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 2- Leader is not alive. Start election. +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Election Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 3 - Election Message: 2 +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Election Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 4 - Election Message: 2,3 +[Thread-4] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 5 - Election Message handling... +[Thread-4] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 5 - Election Message: 2,3,4 +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Election Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 2 - Election Message: 2,3,4,5 +[Thread-1] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 2 - New leader should be 2. +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Leader Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 3 - Update leaderID +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Leader Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 4 - Update leaderID +[Thread-4] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 5 - Leader Message handling... +[Thread-4] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 5 - Update leaderID +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Leader Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 2 - Update leaderID +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Leader Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 3 - Leader update done. Start heartbeat. +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Heartbeat Invoke Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.ring.RingInstance - Instance 4- Leader is alive. Start next heartbeat in 5 second. +``` +Here the implementation of Bully algorithm +```java +/** + * Impelemetation with bully algorithm. Each instance should have a sequential id and is able to + * communicate with other instances in the system. Initially the instance with smallest (or largest) + * ID is selected to be the leader. All the other instances send heartbeat message to leader + * periodically to check its health. If one certain instance finds the server done, it will send an + * election message to all the instances of which the ID is larger. If the target instance is alive, + * it will return an alive message (in this sample return true) and then send election message with + * its ID. If not, the original instance will send leader message to all the other instances. + */ +@Slf4j +public class BullyInstance extends AbstractInstance { + private static final String INSTANCE = "Instance "; + + /** + * Constructor of BullyInstance. + */ + public BullyInstance(MessageManager messageManager, int localId, int leaderId) { + super(messageManager, localId, leaderId); + } + + /** + * Process the heartbeat invoke message. After receiving the message, the instance will send a + * heartbeat to leader to check its health. If alive, it will inform the next instance to do the + * heartbeat. If not, it will start the election process. + */ + @Override + protected void handleHeartbeatInvokeMessage() { + try { + boolean isLeaderAlive = messageManager.sendHeartbeatMessage(leaderId); + if (isLeaderAlive) { + LOGGER.info(INSTANCE + localId + "- Leader is alive."); + Thread.sleep(HEARTBEAT_INTERVAL); + messageManager.sendHeartbeatInvokeMessage(localId); + } else { + LOGGER.info(INSTANCE + localId + "- Leader is not alive. Start election."); + boolean electionResult = + messageManager.sendElectionMessage(localId, String.valueOf(localId)); + if (electionResult) { + LOGGER.info(INSTANCE + localId + "- Succeed in election. Start leader notification."); + messageManager.sendLeaderMessage(localId, localId); + } + } + } catch (InterruptedException e) { + LOGGER.info(INSTANCE + localId + "- Interrupted."); + } + } + + /** + * Process election invoke message. Send election message to all the instances with smaller ID. If + * any one of them is alive, do nothing. If no instance alive, send leader message to all the + * alive instance and restart heartbeat. + */ + @Override + protected void handleElectionInvokeMessage() { + if (!isLeader()) { + LOGGER.info(INSTANCE + localId + "- Start election."); + boolean electionResult = messageManager.sendElectionMessage(localId, String.valueOf(localId)); + if (electionResult) { + LOGGER.info(INSTANCE + localId + "- Succeed in election. Start leader notification."); + leaderId = localId; + messageManager.sendLeaderMessage(localId, localId); + messageManager.sendHeartbeatInvokeMessage(localId); + } + } + } + + /** + * Process leader message. Update local leader information. + */ + @Override + protected void handleLeaderMessage(Message message) { + leaderId = Integer.valueOf(message.getContent()); + LOGGER.info(INSTANCE + localId + " - Leader update done."); + } + + private boolean isLeader() { + return localId == leaderId; + } + + @Override + protected void handleLeaderInvokeMessage() { + // Not used in Bully Instance + } + + @Override + protected void handleHeartbeatMessage(Message message) { + // Not used in Bully Instance + } + + @Override + protected void handleElectionMessage(Message message) { + // Not used in Bully Instance + } +} +``` + +```java +/** + * Implementation of BullyMessageManager. + */ +public class BullyMessageManager extends AbstractMessageManager { + + /** + * Constructor of BullyMessageManager. + */ + public BullyMessageManager(Map<Integer, Instance> instanceMap) { + super(instanceMap); + } + + /** + * Send heartbeat message to current leader instance to check the health. + * + * @param leaderId leaderID + * @return {@code true} if the leader is alive. + */ + @Override + public boolean sendHeartbeatMessage(int leaderId) { + var leaderInstance = instanceMap.get(leaderId); + var alive = leaderInstance.isAlive(); + return alive; + } + + /** + * Send election message to all the instances with smaller ID. + * + * @param currentId Instance ID of which sends this message. + * @param content Election message content. + * @return {@code true} if no alive instance has smaller ID, so that the election is accepted. + */ + @Override + public boolean sendElectionMessage(int currentId, String content) { + var candidateList = findElectionCandidateInstanceList(currentId); + if (candidateList.isEmpty()) { + return true; + } else { + var electionMessage = new Message(MessageType.ELECTION_INVOKE, ""); + candidateList.stream().forEach((i) -> instanceMap.get(i).onMessage(electionMessage)); + return false; + } + } + + /** + * Send leader message to all the instances to notify the new leader. + * + * @param currentId Instance ID of which sends this message. + * @param leaderId Leader message content. + * @return {@code true} if the message is accepted. + */ + @Override + public boolean sendLeaderMessage(int currentId, int leaderId) { + var leaderMessage = new Message(MessageType.LEADER, String.valueOf(leaderId)); + instanceMap.keySet() + .stream() + .filter((i) -> i != currentId) + .forEach((i) -> instanceMap.get(i).onMessage(leaderMessage)); + return false; + } + + /** + * Send heartbeat invoke message to the next instance. + * + * @param currentId Instance ID of which sends this message. + */ + @Override + public void sendHeartbeatInvokeMessage(int currentId) { + var nextInstance = this.findNextInstance(currentId); + var heartbeatInvokeMessage = new Message(MessageType.HEARTBEAT_INVOKE, ""); + nextInstance.onMessage(heartbeatInvokeMessage); + } + + /** + * Find all the alive instances with smaller ID than current instance. + * + * @param currentId ID of current instance. + * @return ID list of all the candidate instance. + */ + private List<Integer> findElectionCandidateInstanceList(int currentId) { + return instanceMap.keySet() + .stream() + .filter((i) -> i < currentId && instanceMap.get(i).isAlive()) + .toList(); + } + +} +``` + +```java +public static void main(String[] args) { + + Map<Integer, Instance> instanceMap = new HashMap<>(); + var messageManager = new BullyMessageManager(instanceMap); + + var instance1 = new BullyInstance(messageManager, 1, 1); + var instance2 = new BullyInstance(messageManager, 2, 1); + var instance3 = new BullyInstance(messageManager, 3, 1); + var instance4 = new BullyInstance(messageManager, 4, 1); + var instance5 = new BullyInstance(messageManager, 5, 1); + + instanceMap.put(1, instance1); + instanceMap.put(2, instance2); + instanceMap.put(3, instance3); + instanceMap.put(4, instance4); + instanceMap.put(5, instance5); + + instance4.onMessage(new Message(MessageType.HEARTBEAT_INVOKE, "")); + + final var thread1 = new Thread(instance1); + final var thread2 = new Thread(instance2); + final var thread3 = new Thread(instance3); + final var thread4 = new Thread(instance4); + final var thread5 = new Thread(instance5); + + thread1.start(); + thread2.start(); + thread3.start(); + thread4.start(); + thread5.start(); + + instance1.setAlive(false); + } +``` + +The console output +``` +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Heartbeat Invoke Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 4- Leader is alive. +[Thread-4] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 5 - Heartbeat Invoke Message handling... +[Thread-4] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 5- Leader is not alive. Start election. +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Election Invoke Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Election Invoke Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 4- Start election. +[Thread-2] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 3- Start election. +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Election Invoke Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 3- Start election. +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Election Invoke Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 2- Start election. +[Thread-1] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 2- Succeed in election. Start leader notification. +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Election Invoke Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 4 - Leader Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Leader Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Election Invoke Message handling... +[Thread-4] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 5 - Leader Message handling... +[Thread-0] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 1 - Leader Message handling... +[Thread-1] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 2 - Election Invoke Message handling... +[Thread-3] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 4 - Leader update done. +[Thread-2] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 3 - Leader update done. +[Thread-0] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 1 - Leader update done. +[Thread-4] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 5 - Leader update done. +[Thread-2] INFO com.iluwatar.leaderelection.AbstractInstance - Instance 3 - Heartbeat Invoke Message handling... +[Thread-2] INFO com.iluwatar.leaderelection.bully.BullyInstance - Instance 3- Leader is alive. +``` ## Class diagram  @@ -22,10 +836,7 @@ Do not use this pattern when * there is a natural leader or dedicated process that can always act as the leader. For example, it may be possible to implement a singleton process that coordinates the task instances. If this process fails or becomes unhealthy, the system can shut it down and restart it. * the coordination between tasks can be easily achieved by using a more lightweight mechanism. For example, if several task instances simply require coordinated access to a shared resource, a preferable solution might be to use optimistic or pessimistic locking to control access to that resource. -## Real world examples - -* [Raft Leader Election](https://github.com/ronenhamias/raft-leader-election) - ## Credits * [Leader Election pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/leader-election) +* [Raft Leader Election](https://github.com/ronenhamias/raft-leader-election)

train

test

iluwatar

train

iluwatar/java-design-patterns/2223_2771

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2223

iluwatar/java-design-patterns/2771

163c3017bb356937d876cd9a05905c012f3b0af6

83986c794bdd27755ab3504113eedd1fdac36f69

Explanation for Double Buffer

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/double-buffer/README.md b/double-buffer/README.md index 089e30e6d3d2..04b47ad97f7e 100644 --- a/double-buffer/README.md +++ b/double-buffer/README.md @@ -1,14 +1,243 @@ ---- +--- title: Double Buffer category: Behavioral language: en tag: - Performance - Game programming ---- +--- ## Intent -Double buffering is a term used to describe a device that has two buffers. The usage of multiple buffers increases the overall throughput of a device and helps prevents bottlenecks. This example shows using double buffer pattern on graphics. It is used to show one image or frame while a separate frame is being buffered to be shown next. This method makes animations and games look more realistic than the same done in a single buffer mode. +Double buffering is a term used to describe a device that has two buffers. The usage of multiple +buffers increases the overall throughput of a device and helps prevents bottlenecks. This example +shows using double buffer pattern on graphics. It is used to show one image or frame while a separate +frame is being buffered to be shown next. This method makes animations and games look more realistic +than the same done in a single buffer mode. + +## Explanation + +Real world example +> A typical example, and one that every game engine must address, is rendering. When the game draws +> the world the users see, it does so one piece at a time -- the mountains in the distance, +> the rolling hills, the trees, each in its turn. If the user watched the view draw incrementally +> like that, the illusion of a coherent world would be shattered. The scene must update smoothly +> and quickly, displaying a series of complete frames, each appearing instantly. Double buffering solves +> the problem. + +In plain words +> It ensures a state that is being rendered correctly while that state is modifying incrementally. It is +> widely used in computer graphics. + +Wikipedia says +> In computer science, multiple buffering is the use of more than one buffer to hold a block of data, +> so that a "reader" will see a complete (though perhaps old) version of the data, rather than a +> partially updated version of the data being created by a "writer". It is very commonly used for +> computer display images. + +**Programmatic Example** + +Buffer interface that assures basic functionalities of a buffer. + +```java +/** + * Buffer interface. + */ +public interface Buffer { + + /** + * Clear the pixel in (x, y). + * + * @param x X coordinate + * @param y Y coordinate + */ + void clear(int x, int y); + + /** + * Draw the pixel in (x, y). + * + * @param x X coordinate + * @param y Y coordinate + */ + void draw(int x, int y); + + /** + * Clear all the pixels. + */ + void clearAll(); + + /** + * Get all the pixels. + * + * @return pixel list + */ + Pixel[] getPixels(); + +} +``` + +One of the implementation of Buffer interface. +```java +/** + * FrameBuffer implementation class. + */ +public class FrameBuffer implements Buffer { + + public static final int WIDTH = 10; + public static final int HEIGHT = 8; + + private final Pixel[] pixels = new Pixel[WIDTH * HEIGHT]; + + public FrameBuffer() { + clearAll(); + } + + @Override + public void clear(int x, int y) { + pixels[getIndex(x, y)] = Pixel.WHITE; + } + + @Override + public void draw(int x, int y) { + pixels[getIndex(x, y)] = Pixel.BLACK; + } + + @Override + public void clearAll() { + Arrays.fill(pixels, Pixel.WHITE); + } + + @Override + public Pixel[] getPixels() { + return pixels; + } + + private int getIndex(int x, int y) { + return x + WIDTH * y; + } +} +``` + +```java +/** + * Pixel enum. Each pixel can be white (not drawn) or black (drawn). + */ +public enum Pixel { + + WHITE, + BLACK; +} +``` +Scene represents the game scene where current buffer has already been rendered. +```java +/** + * Scene class. Render the output frame. + */ +@Slf4j +public class Scene { + + private final Buffer[] frameBuffers; + + private int current; + + private int next; + + /** + * Constructor of Scene. + */ + public Scene() { + frameBuffers = new FrameBuffer[2]; + frameBuffers[0] = new FrameBuffer(); + frameBuffers[1] = new FrameBuffer(); + current = 0; + next = 1; + } + + /** + * Draw the next frame. + * + * @param coordinateList list of pixels of which the color should be black + */ + public void draw(List<? extends Pair<Integer, Integer>> coordinateList) { + LOGGER.info("Start drawing next frame"); + LOGGER.info("Current buffer: " + current + " Next buffer: " + next); + frameBuffers[next].clearAll(); + coordinateList.forEach(coordinate -> { + var x = coordinate.getKey(); + var y = coordinate.getValue(); + frameBuffers[next].draw(x, y); + }); + LOGGER.info("Swap current and next buffer"); + swap(); + LOGGER.info("Finish swapping"); + LOGGER.info("Current buffer: " + current + " Next buffer: " + next); + } + + public Buffer getBuffer() { + LOGGER.info("Get current buffer: " + current); + return frameBuffers[current]; + } + + private void swap() { + current = current ^ next; + next = current ^ next; + current = current ^ next; + } + +} +``` + +```java +public static void main(String[] args) { + final var scene = new Scene(); + var drawPixels1 = List.of( + new MutablePair<>(1, 1), + new MutablePair<>(5, 6), + new MutablePair<>(3, 2) + ); + scene.draw(drawPixels1); + var buffer1 = scene.getBuffer(); + printBlackPixelCoordinate(buffer1); + + var drawPixels2 = List.of( + new MutablePair<>(3, 7), + new MutablePair<>(6, 1) + ); + scene.draw(drawPixels2); + var buffer2 = scene.getBuffer(); + printBlackPixelCoordinate(buffer2); + } + + private static void printBlackPixelCoordinate(Buffer buffer) { + StringBuilder log = new StringBuilder("Black Pixels: "); + var pixels = buffer.getPixels(); + for (var i = 0; i < pixels.length; ++i) { + if (pixels[i] == Pixel.BLACK) { + var y = i / FrameBuffer.WIDTH; + var x = i % FrameBuffer.WIDTH; + log.append(" (").append(x).append(", ").append(y).append(")"); + } + } + LOGGER.info(log.toString()); + } +``` + +The console output +```text +[main] INFO com.iluwatar.doublebuffer.Scene - Start drawing next frame +[main] INFO com.iluwatar.doublebuffer.Scene - Current buffer: 0 Next buffer: 1 +[main] INFO com.iluwatar.doublebuffer.Scene - Swap current and next buffer +[main] INFO com.iluwatar.doublebuffer.Scene - Finish swapping +[main] INFO com.iluwatar.doublebuffer.Scene - Current buffer: 1 Next buffer: 0 +[main] INFO com.iluwatar.doublebuffer.Scene - Get current buffer: 1 +[main] INFO com.iluwatar.doublebuffer.App - Black Pixels: (1, 1) (3, 2) (5, 6) +[main] INFO com.iluwatar.doublebuffer.Scene - Start drawing next frame +[main] INFO com.iluwatar.doublebuffer.Scene - Current buffer: 1 Next buffer: 0 +[main] INFO com.iluwatar.doublebuffer.Scene - Swap current and next buffer +[main] INFO com.iluwatar.doublebuffer.Scene - Finish swapping +[main] INFO com.iluwatar.doublebuffer.Scene - Current buffer: 0 Next buffer: 1 +[main] INFO com.iluwatar.doublebuffer.Scene - Get current buffer: 0 +[main] INFO com.iluwatar.doublebuffer.App - Black Pixels: (6, 1) (3, 7) +``` ## Class diagram 

val

test

iluwatar

train

iluwatar/java-design-patterns/2366_2776

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2366

iluwatar/java-design-patterns/2776

163c3017bb356937d876cd9a05905c012f3b0af6

0f39267a197e1e6ba08dfffa2d9df774fe25c6fe

Uniform handling for H2 databases

At the moment, many of the patterns utilize H2 databases to demonstrate data access (search for `jdbc:h2`). The problem is that we don't have a unified approach. Some of the patterns use file-based database written somewhere under the home directory and some use in-memory databases. Perhaps we could use in-memory databases everywhere so the user's disk would not be cluttered? If not possible, at least store the database files under the same directory. Acceptance criteria - H2 database handling is unified

diff --git a/dao/src/main/java/com/iluwatar/dao/App.java b/dao/src/main/java/com/iluwatar/dao/App.java index 20d1db0633dd..f0d19749c64b 100644 --- a/dao/src/main/java/com/iluwatar/dao/App.java +++ b/dao/src/main/java/com/iluwatar/dao/App.java @@ -44,7 +44,7 @@ */ @Slf4j public class App { - private static final String DB_URL = "jdbc:h2:~/dao"; + private static final String DB_URL = "jdbc:h2:mem:dao;DB_CLOSE_DELAY=-1"; private static final String ALL_CUSTOMERS = "customerDao.getAllCustomers(): "; /** diff --git a/domain-model/src/main/java/com/iluwatar/domainmodel/App.java b/domain-model/src/main/java/com/iluwatar/domainmodel/App.java index 89c848f6696c..aade9924a400 100644 --- a/domain-model/src/main/java/com/iluwatar/domainmodel/App.java +++ b/domain-model/src/main/java/com/iluwatar/domainmodel/App.java @@ -49,7 +49,7 @@ */ public class App { - public static final String H2_DB_URL = "jdbc:h2:~/test"; + public static final String H2_DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; public static final String CREATE_SCHEMA_SQL = "CREATE TABLE CUSTOMERS (name varchar primary key, money decimal);" diff --git a/layers/src/main/resources/application.properties b/layers/src/main/resources/application.properties index fad9b72a5ce7..233a9db6c8a5 100644 --- a/layers/src/main/resources/application.properties +++ b/layers/src/main/resources/application.properties @@ -2,7 +2,7 @@ spring.main.web-application-type=none #datasource settings -spring.datasource.url=jdbc:h2:~/databases/cake +spring.datasource.url=jdbc:h2:mem:databases-cake spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=sa diff --git a/repository/src/main/java/com/iluwatar/repository/AppConfig.java b/repository/src/main/java/com/iluwatar/repository/AppConfig.java index ea93c21089e5..995c790b6e35 100644 --- a/repository/src/main/java/com/iluwatar/repository/AppConfig.java +++ b/repository/src/main/java/com/iluwatar/repository/AppConfig.java @@ -54,7 +54,7 @@ public class AppConfig { public DataSource dataSource() { var basicDataSource = new BasicDataSource(); basicDataSource.setDriverClassName("org.h2.Driver"); - basicDataSource.setUrl("jdbc:h2:~/databases/person"); + basicDataSource.setUrl("jdbc:h2:mem:databases-person"); basicDataSource.setUsername("sa"); basicDataSource.setPassword("sa"); return basicDataSource; diff --git a/repository/src/main/resources/applicationContext.xml b/repository/src/main/resources/applicationContext.xml index 0de00f39f01d..718b6b6e6e13 100644 --- a/repository/src/main/resources/applicationContext.xml +++ b/repository/src/main/resources/applicationContext.xml @@ -30,7 +30,7 @@ </bean> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="org.h2.Driver" /> - <property name="url" value="jdbc:h2:~/databases/person" /> + <property name="url" value="jdbc:h2:mem:databases-person;DB_CLOSE_DELAY=-1" /> <property name="username" value="sa" /> <property name="password" value="sa" /> </bean> diff --git a/serialized-entity/README.md b/serialized-entity/README.md index a994aa19cfbf..d18a2c83e9ad 100644 --- a/serialized-entity/README.md +++ b/serialized-entity/README.md @@ -136,7 +136,7 @@ methods to read and deserialize data items to `Country` objects. ```java @Slf4j public class App { - private static final String DB_URL = "jdbc:h2:~/test"; + private static final String DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; private App() { diff --git a/serialized-entity/src/main/java/com/iluwatar/serializedentity/App.java b/serialized-entity/src/main/java/com/iluwatar/serializedentity/App.java index c86102a8231e..7f1f46905875 100644 --- a/serialized-entity/src/main/java/com/iluwatar/serializedentity/App.java +++ b/serialized-entity/src/main/java/com/iluwatar/serializedentity/App.java @@ -48,7 +48,7 @@ */ @Slf4j public class App { - private static final String DB_URL = "jdbc:h2:~/test"; + private static final String DB_URL = "jdbc:h2:mem:testdb"; private App() { diff --git a/table-module/src/main/java/com/iluwatar/tablemodule/App.java b/table-module/src/main/java/com/iluwatar/tablemodule/App.java index 632b4019dfa7..1c528df8a7f5 100644 --- a/table-module/src/main/java/com/iluwatar/tablemodule/App.java +++ b/table-module/src/main/java/com/iluwatar/tablemodule/App.java @@ -45,7 +45,7 @@ */ @Slf4j public final class App { - private static final String DB_URL = "jdbc:h2:~/test"; + private static final String DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; /** * Private constructor. diff --git a/transaction-script/src/main/java/com/iluwatar/transactionscript/App.java b/transaction-script/src/main/java/com/iluwatar/transactionscript/App.java index 0525e6e64a63..909943ce41d4 100644 --- a/transaction-script/src/main/java/com/iluwatar/transactionscript/App.java +++ b/transaction-script/src/main/java/com/iluwatar/transactionscript/App.java @@ -46,7 +46,7 @@ */ public class App { - private static final String H2_DB_URL = "jdbc:h2:~/test"; + private static final String H2_DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; private static final Logger LOGGER = LoggerFactory.getLogger(App.class); /**

diff --git a/dao/src/test/java/com/iluwatar/dao/DbCustomerDaoTest.java b/dao/src/test/java/com/iluwatar/dao/DbCustomerDaoTest.java index 666c7634c158..cfa7e9882981 100644 --- a/dao/src/test/java/com/iluwatar/dao/DbCustomerDaoTest.java +++ b/dao/src/test/java/com/iluwatar/dao/DbCustomerDaoTest.java @@ -49,7 +49,7 @@ */ class DbCustomerDaoTest { - private static final String DB_URL = "jdbc:h2:~/dao"; + private static final String DB_URL = "jdbc:h2:mem:dao;DB_CLOSE_DELAY=-1"; private DbCustomerDao dao; private final Customer existingCustomer = new Customer(1, "Freddy", "Krueger"); diff --git a/serialized-entity/src/test/java/com/iluwatar/serializedentity/AppTest.java b/serialized-entity/src/test/java/com/iluwatar/serializedentity/AppTest.java index 52ac9cd6e026..a15557d5ffdb 100644 --- a/serialized-entity/src/test/java/com/iluwatar/serializedentity/AppTest.java +++ b/serialized-entity/src/test/java/com/iluwatar/serializedentity/AppTest.java @@ -1,3 +1,27 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ package com.iluwatar.serializedentity; import org.junit.jupiter.api.Test; diff --git a/table-module/src/test/java/com/iluwatar/tablemodule/UserTableModuleTest.java b/table-module/src/test/java/com/iluwatar/tablemodule/UserTableModuleTest.java index a9dc41b3e3f2..f45c20176700 100644 --- a/table-module/src/test/java/com/iluwatar/tablemodule/UserTableModuleTest.java +++ b/table-module/src/test/java/com/iluwatar/tablemodule/UserTableModuleTest.java @@ -36,7 +36,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows; class UserTableModuleTest { - private static final String DB_URL = "jdbc:h2:~/test"; + private static final String DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; private static DataSource createDataSource() { var dataSource = new JdbcDataSource(); diff --git a/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelDaoImplTest.java b/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelDaoImplTest.java index ae288c703c1b..2f587397d873 100644 --- a/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelDaoImplTest.java +++ b/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelDaoImplTest.java @@ -49,7 +49,7 @@ */ class HotelDaoImplTest { - private static final String DB_URL = "jdbc:h2:~/test"; + private static final String DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; private HotelDaoImpl dao; private Room existingRoom = new Room(1, "Single", 50, false); diff --git a/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelTest.java b/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelTest.java index 1274a542a77e..e8a7f6a0b8e4 100644 --- a/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelTest.java +++ b/transaction-script/src/test/java/com/iluwatar/transactionscript/HotelTest.java @@ -39,7 +39,7 @@ */ class HotelTest { - private static final String H2_DB_URL = "jdbc:h2:~/test"; + private static final String H2_DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1"; private Hotel hotel; private HotelDaoImpl dao;

train

test

iluwatar

train

iluwatar/java-design-patterns/1297_2818

iluwatar/java-design-patterns

iluwatar/java-design-patterns/1297

iluwatar/java-design-patterns/2818

e340f4f3f8c33efa63e10041b490516f3f892db5

98505c61dde1b91f730543fdf42c2ded9ee85630

Gateway pattern

https://stackoverflow.com/questions/4422211/what-is-the-difference-between-facade-and-gateway-design-patterns

diff --git a/gateway/README.md b/gateway/README.md index f1152ec6cfb4..9307b5d1d0f9 100644 --- a/gateway/README.md +++ b/gateway/README.md @@ -3,7 +3,6 @@ title: Gateway category: Structural language: en tag: -- Gang of Four - Decoupling --- @@ -38,7 +37,7 @@ The main class in our example is the `ExternalService` that contains items. class ExternalServiceA implements Gateway { @Override public void execute() throws Exception { - System.out.println("Executing Service A"); + LOGGER.info("Executing Service A"); // Simulate a time-consuming task Thread.sleep(1000); } @@ -50,7 +49,7 @@ class ExternalServiceA implements Gateway { class ExternalServiceB implements Gateway { @Override public void execute() throws Exception { - System.out.println("Executing Service B"); + LOGGER.info("Executing Service B"); // Simulate a time-consuming task Thread.sleep(1000); } @@ -62,7 +61,7 @@ class ExternalServiceB implements Gateway { class ExternalServiceC implements Gateway { @Override public void execute() throws Exception { - System.out.println("Executing Service C"); + LOGGER.info("Executing Service C"); // Simulate a time-consuming task Thread.sleep(1000); } @@ -100,7 +99,7 @@ public class App { serviceB.execute(); serviceC.execute(); } catch (ThreadDeath e) { - System.out.println("Interrupted!" + e); + LOGGER.info("Interrupted!" + e); throw e; } } diff --git a/pom.xml b/pom.xml index 8af7ff7ae8a2..afa454245f25 100644 --- a/pom.xml +++ b/pom.xml @@ -212,6 +212,7 @@ <module>health-check</module> <module>notification</module> <module>single-table-inheritance</module> + <module>gateway</module> </modules> <repositories> <repository>

train

test

iluwatar

train

iluwatar/java-design-patterns/2215_2875

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2215

iluwatar/java-design-patterns/2875

7c1889b8e5800b60013a96d567b64df51dd62ae1

9538c7820c34e879443078d9614fb570a00b4911

Explanation for Collection Pipeline

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/collection-pipeline/README.md b/collection-pipeline/README.md index 3ae285accb69..aab323e0ec14 100644 --- a/collection-pipeline/README.md +++ b/collection-pipeline/README.md @@ -3,25 +3,145 @@ title: Collection Pipeline category: Functional language: en tag: - - Reactive + - Reactive + - Data processing --- ## Intent -Collection Pipeline introduces Function Composition and Collection Pipeline, two functional-style patterns that you can combine to iterate collections in your code. -In functional programming, it's common to sequence complex operations through a series of smaller modular functions or operations. The series is called a composition of functions, or a function composition. When a collection of data flows through a function composition, it becomes a collection pipeline. Function Composition and Collection Pipeline are two design patterns frequently used in functional-style programming. + +The Collection Pipeline design pattern is intended to process collections of data by chaining together operations in a +sequence where the output of one operation is the input for the next. It promotes a declarative approach to handling +collections, focusing on what should be done rather than how. + +## Explanation + +Real-world example + +> Imagine you're in a large library filled with books, and you're tasked with finding all the science fiction books +> published after 2000, then arranging them by author name in alphabetical order, and finally picking out the top 5 based +> on their popularity or ratings. + +In plain words + +> The Collection Pipeline pattern involves processing data by passing it through a series of operations, each +> transforming the data in sequence, much like an assembly line in a factory. + +Wikipedia says + +> In software engineering, a pipeline consists of a chain of processing elements (processes, threads, coroutines, +> functions, etc.), arranged so that the output of each element is the input of the next; the name is by analogy to a +> physical pipeline. Usually some amount of buffering is provided between consecutive elements. The information that flows +> in these pipelines is often a stream of records, bytes, or bits, and the elements of a pipeline may be called filters; +> this is also called the pipe(s) and filters design pattern. Connecting elements into a pipeline is analogous to function +> composition. + +**Programmatic Example** + +The Collection Pipeline pattern is implemented in this code example by using Java's Stream API to perform a series of +transformations on a collection of Car objects. The transformations are chained together to form a pipeline. Here's a +breakdown of how it's done: + +1. Creation of Cars: A list of Car objects is created using the `CarFactory.createCars()` method. + +`var cars = CarFactory.createCars();` + +2. Filtering and Transforming: The `FunctionalProgramming.getModelsAfter2000(cars)` method filters the cars to only + include those made after the year 2000, and then transforms the filtered cars into a list of their model names. + +`var modelsFunctional = FunctionalProgramming.getModelsAfter2000(cars);` + +In the `getModelsAfter2000` method, the pipeline is created as follows: + +```java +public static List<String> getModelsAfter2000(List<Car> cars){ + return cars.stream().filter(car->car.getYear()>2000) + .sorted(comparing(Car::getYear)) + .map(Car::getModel) + .collect(toList()); + } +``` + +3. Grouping: The `FunctionalProgramming.getGroupingOfCarsByCategory(cars)` method groups the cars by their category. + +`var groupingByCategoryFunctional = FunctionalProgramming.getGroupingOfCarsByCategory(cars);` + +In the getGroupingOfCarsByCategory method, the pipeline is created as follows: + +```java +public static Map<Category, List<Car>>getGroupingOfCarsByCategory(List<Car> cars){ + return cars.stream().collect(groupingBy(Car::getCategory)); + } +``` + +4. Filtering, Sorting and Transforming: The `FunctionalProgramming.getSedanCarsOwnedSortedByDate(List.of(john))` method + filters the cars owned by a person to only include sedans, sorts them by date, and then transforms the sorted cars + into a list of Car objects. + +`var sedansOwnedFunctional = FunctionalProgramming.getSedanCarsOwnedSortedByDate(List.of(john));` + +In the `getSedanCarsOwnedSortedByDate` method, the pipeline is created as follows: + +```java +public static List<Car> getSedanCarsOwnedSortedByDate(List<Person> persons){ + return persons.stream().flatMap(person->person.getCars().stream()) + .filter(car->Category.SEDAN.equals(car.getCategory())) + .sorted(comparing(Car::getDate)) + .collect(toList()); + } +``` + +In each of these methods, the Collection Pipeline pattern is used to perform a series of operations on the collection of +cars in a declarative manner, which improves readability and maintainability. ## Class diagram +  ## Applicability -Use the Collection Pipeline pattern when -* When you want to perform a sequence of operations where one operation's collected output is fed into the next -* When you use a lot of statements in your code -* When you use a lot of loops in your code +This pattern is applicable in scenarios involving bulk data operations such as filtering, mapping, sorting, or reducing +collections. It's particularly useful in data analysis, transformation tasks, and where a sequence of operations needs +to be applied to each element of a collection. + +## Known Uses + +* LINQ in .NET +* Stream API in Java 8+ +* Collections in modern functional languages (e.g., Haskell, Scala) +* Database query builders and ORM frameworks + +## Consequences + +Benefits: + +* Readability: The code is more readable and declarative, making it easier to understand the sequence of operations. +* Maintainability: Easier to modify or extend the pipeline with additional operations. +* Reusability: Common operations can be abstracted into reusable functions. +* Lazy Evaluation: Some implementations allow for operations to be lazily evaluated, improving performance. + +Trade-offs: + +* Performance Overhead: Chaining multiple operations can introduce overhead compared to traditional loops, especially + for short pipelines or very large collections. +* Debugging Difficulty: Debugging a chain of operations might be more challenging due to the lack of intermediate + variables. +* Limited to Collections: Primarily focused on collections, and its utility might be limited outside of collection + processing. + +## Related Patterns + +* [Builder](https://java-design-patterns.com/patterns/builder/): Similar fluent interface style but used for object + construction. +* [Chain of Responsibility](https://java-design-patterns.com/patterns/chain-of-responsibility/): Conceptually similar in + chaining handlers, but applied to object requests rather than data collection processing. +* [Strategy](https://java-design-patterns.com/patterns/strategy/): Can be used within a pipeline stage to encapsulate + different algorithms that can be selected at runtime. ## Credits * [Function composition and the Collection Pipeline pattern](https://www.ibm.com/developerworks/library/j-java8idioms2/index.html) -* [Martin Fowler](https://martinfowler.com/articles/collection-pipeline/) +* [Collection Pipeline described by Martin Fowler](https://martinfowler.com/articles/collection-pipeline/) * [Java8 Streams](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html) +* [Refactoring: Improving the Design of Existing Code](https://amzn.to/3VDMWDO) +* [Functional Programming in Scala](https://amzn.to/4cEo6K2) +* [Java 8 in Action: Lambdas, Streams, and functional-style programming](https://amzn.to/3THp4wy) diff --git a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Car.java b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Car.java index 97e13231b24f..2cfeb963ba49 100644 --- a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Car.java +++ b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Car.java @@ -22,22 +22,11 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -package com.iluwatar.collectionpipeline; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; +package com.iluwatar.collectionpipeline; /** * A Car class that has the properties of make, model, year and category. */ -@Getter -@EqualsAndHashCode -@RequiredArgsConstructor -public class Car { - private final String make; - private final String model; - private final int year; - private final Category category; - -} \ No newline at end of file +public record Car(String make, String model, int year, Category category) { +} diff --git a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/FunctionalProgramming.java b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/FunctionalProgramming.java index adf0fda4bda2..20bf77d29a2f 100644 --- a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/FunctionalProgramming.java +++ b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/FunctionalProgramming.java @@ -22,6 +22,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ + package com.iluwatar.collectionpipeline; import java.util.Comparator; @@ -54,9 +55,8 @@ private FunctionalProgramming() { * @return {@link List} of {@link String} representing models built after year 2000 */ public static List<String> getModelsAfter2000(List<Car> cars) { - return cars.stream().filter(car -> car.getYear() > 2000) - .sorted(Comparator.comparing(Car::getYear)) - .map(Car::getModel).toList(); + return cars.stream().filter(car -> car.year() > 2000).sorted(Comparator.comparing(Car::year)) + .map(Car::model).toList(); } /** @@ -66,7 +66,7 @@ public static List<String> getModelsAfter2000(List<Car> cars) { * @return {@link Map} with category as key and cars belonging to that category as value */ public static Map<Category, List<Car>> getGroupingOfCarsByCategory(List<Car> cars) { - return cars.stream().collect(Collectors.groupingBy(Car::getCategory)); + return cars.stream().collect(Collectors.groupingBy(Car::category)); } /** @@ -76,8 +76,8 @@ public static Map<Category, List<Car>> getGroupingOfCarsByCategory(List<Car> car * @return {@link List} of {@link Car} to belonging to the group */ public static List<Car> getSedanCarsOwnedSortedByDate(List<Person> persons) { - return persons.stream().map(Person::getCars).flatMap(List::stream) - .filter(car -> Category.SEDAN.equals(car.getCategory())) - .sorted(Comparator.comparing(Car::getYear)).toList(); + return persons.stream().map(Person::cars).flatMap(List::stream) + .filter(car -> Category.SEDAN.equals(car.category())) + .sorted(Comparator.comparing(Car::year)).toList(); } } diff --git a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/ImperativeProgramming.java b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/ImperativeProgramming.java index e3359a389b0d..2a85334c6643 100644 --- a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/ImperativeProgramming.java +++ b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/ImperativeProgramming.java @@ -61,7 +61,7 @@ public static List<String> getModelsAfter2000(List<Car> cars) { List<Car> carsSortedByYear = new ArrayList<>(); for (Car car : cars) { - if (car.getYear() > 2000) { + if (car.year() > 2000) { carsSortedByYear.add(car); } } @@ -69,13 +69,13 @@ public static List<String> getModelsAfter2000(List<Car> cars) { Collections.sort(carsSortedByYear, new Comparator<Car>() { @Override public int compare(Car car1, Car car2) { - return car1.getYear() - car2.getYear(); + return car1.year() - car2.year(); } }); List<String> models = new ArrayList<>(); for (Car car : carsSortedByYear) { - models.add(car.getModel()); + models.add(car.model()); } return models; @@ -90,12 +90,12 @@ public int compare(Car car1, Car car2) { public static Map<Category, List<Car>> getGroupingOfCarsByCategory(List<Car> cars) { Map<Category, List<Car>> groupingByCategory = new HashMap<>(); for (Car car : cars) { - if (groupingByCategory.containsKey(car.getCategory())) { - groupingByCategory.get(car.getCategory()).add(car); + if (groupingByCategory.containsKey(car.category())) { + groupingByCategory.get(car.category()).add(car); } else { List<Car> categoryCars = new ArrayList<>(); categoryCars.add(car); - groupingByCategory.put(car.getCategory(), categoryCars); + groupingByCategory.put(car.category(), categoryCars); } } return groupingByCategory; @@ -111,12 +111,12 @@ public static Map<Category, List<Car>> getGroupingOfCarsByCategory(List<Car> car public static List<Car> getSedanCarsOwnedSortedByDate(List<Person> persons) { List<Car> cars = new ArrayList<>(); for (Person person : persons) { - cars.addAll(person.getCars()); + cars.addAll(person.cars()); } List<Car> sedanCars = new ArrayList<>(); for (Car car : cars) { - if (Category.SEDAN.equals(car.getCategory())) { + if (Category.SEDAN.equals(car.category())) { sedanCars.add(car); } } @@ -124,7 +124,7 @@ public static List<Car> getSedanCarsOwnedSortedByDate(List<Person> persons) { sedanCars.sort(new Comparator<Car>() { @Override public int compare(Car o1, Car o2) { - return o1.getYear() - o2.getYear(); + return o1.year() - o2.year(); } }); diff --git a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Person.java b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Person.java index 80b6a8bf0303..992596125423 100644 --- a/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Person.java +++ b/collection-pipeline/src/main/java/com/iluwatar/collectionpipeline/Person.java @@ -25,16 +25,8 @@ package com.iluwatar.collectionpipeline; import java.util.List; -import lombok.Getter; -import lombok.RequiredArgsConstructor; /** * A Person class that has the list of cars that the person owns and use. */ -@Getter -@RequiredArgsConstructor -public class Person { - - private final List<Car> cars; - -} \ No newline at end of file +public record Person(List<Car> cars) {}

train

test

iluwatar

train

iluwatar/java-design-patterns/2876_2877

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2876

iluwatar/java-design-patterns/2877

8471c93035b643528455cbba3957a0922d17e4de

2228212c2361c3ed54babe2b3778f386f5aac9d5

Explanation for Combinator pattern

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/combinator/README.md b/combinator/README.md index 15ec1ea59019..70b6a82f7942 100644 --- a/combinator/README.md +++ b/combinator/README.md @@ -1,132 +1,136 @@ --- title: Combinator -category: Idiom +category: Functional language: en tag: - - Reactive + - Idiom + - Reactive --- ## Also known as -Composition pattern +* Function Composition +* Functional Combinator ## Intent -The functional pattern representing a style of organizing libraries centered around the idea of combining functions. -Putting it simply, there is some type T, some functions for constructing “primitive” values of type T, and some “combinators” which can combine values of type T in various ways to build up more complex values of type T. +The Combinator pattern is intended to enable complex functionalities by combining simple functions into more complex +ones. It aims to achieve modularization and reusability by breaking down a task into simpler, interchangeable components +that can be composed in various ways. ## Explanation Real world example -> In computer science, combinatory logic is used as a simplified model of computation, used in computability theory and proof theory. Despite its simplicity, combinatory logic captures many essential features of computation. -> +> In computer science, combinatory logic is used as a simplified model of computation, used in computability theory and +> proof theory. Despite its simplicity, combinatory logic captures many essential features of computation. In plain words -> The combinator allows you to create new "things" from previously defined "things". -> +> The combinator allows you to create new "things" from previously defined "things" Wikipedia says -> A combinator is a higher-order function that uses only function application and earlier defined combinators to define a result from its arguments. -> +> A combinator is a higher-order function that uses only function application and earlier defined combinators to define +> a result from its arguments. **Programmatic Example** -Translating the combinator example above. First of all, we have a interface consist of several methods `contains`, `not`, `or`, `and` . +Translating the combinator example above. First of all, we have an interface consist of several +methods `contains`, `not`, `or`, `and` . ```java // Functional interface to find lines in text. public interface Finder { - // The function to find lines in text. - List<String> find(String text); - - // Simple implementation of function {@link #find(String)}. - static Finder contains(String word) { - return txt -> Stream.of(txt.split("\n")) - .filter(line -> line.toLowerCase().contains(word.toLowerCase())) - .collect(Collectors.toList()); - } - - // combinator not. - default Finder not(Finder notFinder) { - return txt -> { - List<String> res = this.find(txt); - res.removeAll(notFinder.find(txt)); - return res; - }; - } - - // combinator or. - default Finder or(Finder orFinder) { - return txt -> { - List<String> res = this.find(txt); - res.addAll(orFinder.find(txt)); - return res; - }; - } - - // combinator and. - default Finder and(Finder andFinder) { - return - txt -> this - .find(txt) - .stream() - .flatMap(line -> andFinder.find(line).stream()) - .collect(Collectors.toList()); - } + // The function to find lines in text. + List<String> find(String text); + + // Simple implementation of function {@link #find(String)}. + static Finder contains(String word) { + return txt -> Stream.of(txt.split("\n")) + .filter(line -> line.toLowerCase().contains(word.toLowerCase())) + .collect(Collectors.toList()); + } + + // combinator not. + default Finder not(Finder notFinder) { + return txt -> { + List<String> res = this.find(txt); + res.removeAll(notFinder.find(txt)); + return res; + }; + } + + // combinator or. + default Finder or(Finder orFinder) { + return txt -> { + List<String> res = this.find(txt); + res.addAll(orFinder.find(txt)); + return res; + }; + } + + // combinator and. + default Finder and(Finder andFinder) { + return + txt -> this + .find(txt) + .stream() + .flatMap(line -> andFinder.find(line).stream()) + .collect(Collectors.toList()); + } ... } ``` -Then we have also another combinator for some complex finders `advancedFinder`, `filteredFinder`, `specializedFinder` and `expandedFinder`. +Then we have also another combinator for some complex finders `advancedFinder`, `filteredFinder`, `specializedFinder` +and `expandedFinder`. ```java // Complex finders consisting of simple finder. public class Finders { - private Finders() { - } - - // Finder to find a complex query. - public static Finder advancedFinder(String query, String orQuery, String notQuery) { - return - Finder.contains(query) - .or(Finder.contains(orQuery)) - .not(Finder.contains(notQuery)); - } - - // Filtered finder looking a query with excluded queries as well. - public static Finder filteredFinder(String query, String... excludeQueries) { - var finder = Finder.contains(query); - - for (String q : excludeQueries) { - finder = finder.not(Finder.contains(q)); - } - return finder; - } - - // Specialized query. Every next query is looked in previous result. - public static Finder specializedFinder(String... queries) { - var finder = identMult(); - - for (String query : queries) { - finder = finder.and(Finder.contains(query)); - } - return finder; - } - - // Expanded query. Looking for alternatives. - public static Finder expandedFinder(String... queries) { - var finder = identSum(); - - for (String query : queries) { - finder = finder.or(Finder.contains(query)); - } - return finder; - } + private Finders() { + } + + // Finder to find a complex query. + public static Finder advancedFinder(String query, String orQuery, String notQuery) { + return + Finder.contains(query) + .or(Finder.contains(orQuery)) + .not(Finder.contains(notQuery)); + } + + // Filtered finder looking a query with excluded queries as well. + public static Finder filteredFinder(String query, String... excludeQueries) { + var finder = Finder.contains(query); + + for (String q : excludeQueries) { + finder = finder.not(Finder.contains(q)); + } + return finder; + } + + // Specialized query. Every next query is looked in previous result. + public static Finder specializedFinder(String... queries) { + var finder = identMult(); + + for (String query : queries) { + finder = finder.and(Finder.contains(query)); + } + return finder; + } + + // Expanded query. Looking for alternatives. + public static Finder expandedFinder(String... queries) { + var finder = identSum(); + + for (String query : queries) { + finder = finder.or(Finder.contains(query)); + } + return finder; + } ... } ``` @@ -134,75 +138,102 @@ public class Finders { Now we have created the interface and methods for combinators. Now we have an application working on these combinators. ```java -var queriesOr = new String[]{"many", "Annabel"}; -var finder = Finders.expandedFinder(queriesOr); -var res = finder.find(text()); -LOGGER.info("the result of expanded(or) query[{}] is {}", queriesOr, res); +var queriesOr=new String[]{"many","Annabel"}; + var finder=Finders.expandedFinder(queriesOr); + var res=finder.find(text()); + LOGGER.info("the result of expanded(or) query[{}] is {}",queriesOr,res); -var queriesAnd = new String[]{"Annabel", "my"}; -finder = Finders.specializedFinder(queriesAnd); -res = finder.find(text()); -LOGGER.info("the result of specialized(and) query[{}] is {}", queriesAnd, res); + var queriesAnd=new String[]{"Annabel","my"}; + finder=Finders.specializedFinder(queriesAnd); + res=finder.find(text()); + LOGGER.info("the result of specialized(and) query[{}] is {}",queriesAnd,res); -finder = Finders.advancedFinder("it was", "kingdom", "sea"); -res = finder.find(text()); -LOGGER.info("the result of advanced query is {}", res); + finder=Finders.advancedFinder("it was","kingdom","sea"); + res=finder.find(text()); + LOGGER.info("the result of advanced query is {}",res); -res = Finders.filteredFinder(" was ", "many", "child").find(text()); -LOGGER.info("the result of filtered query is {}", res); + res=Finders.filteredFinder(" was ","many","child").find(text()); + LOGGER.info("the result of filtered query is {}",res); -private static String text() { - return +private static String text(){ + return "It was many and many a year ago,\n" - + "In a kingdom by the sea,\n" - + "That a maiden there lived whom you may know\n" - + "By the name of ANNABEL LEE;\n" - + "And this maiden she lived with no other thought\n" - + "Than to love and be loved by me.\n" - + "I was a child and she was a child,\n" - + "In this kingdom by the sea;\n" - + "But we loved with a love that was more than love-\n" - + "I and my Annabel Lee;\n" - + "With a love that the winged seraphs of heaven\n" - + "Coveted her and me."; - } + +"In a kingdom by the sea,\n" + +"That a maiden there lived whom you may know\n" + +"By the name of ANNABEL LEE;\n" + +"And this maiden she lived with no other thought\n" + +"Than to love and be loved by me.\n" + +"I was a child and she was a child,\n" + +"In this kingdom by the sea;\n" + +"But we loved with a love that was more than love-\n" + +"I and my Annabel Lee;\n" + +"With a love that the winged seraphs of heaven\n" + +"Coveted her and me."; + } ``` **Program output:** ```java -the result of expanded(or) query[[many, Annabel]] is [It was many and many a year ago,, By the name of ANNABEL LEE;, I and my Annabel Lee;] -the result of specialized(and) query[[Annabel, my]] is [I and my Annabel Lee;] -the result of advanced query is [It was many and many a year ago,] -the result of filtered query is [But we loved with a love that was more than love-] +the result of expanded(or)query[[many,Annabel]]is[It was many and many a year ago,,By the name of ANNABEL LEE;,I and my Annabel Lee;] + the result of specialized(and)query[[Annabel,my]]is[I and my Annabel Lee;] + the result of advanced query is[It was many and many a year ago,] + the result of filtered query is[But we loved with a love that was more than love-] ``` -Now we can design our app to with the queries finding feature `expandedFinder`, `specializedFinder`, `advancedFinder`, `filteredFinder` which are all derived from `contains`, `or`, `not`, `and`. - +Now we can design our app to with the queries finding +feature `expandedFinder`, `specializedFinder`, `advancedFinder`, `filteredFinder` which are all derived +from `contains`, `or`, `not`, `and`. ## Class diagram +  ## Applicability -Use the combinator pattern when: -- You are able to create a more complex value from more plain values but having the same type(a combination of them) +This pattern is applicable in scenarios where: + +* The solution to a problem can be constructed from simple, reusable components. +* There is a need for high modularity and reusability of functions. +* The programming environment supports first-class functions and higher-order functions. + +## Known Uses + +* Functional programming languages like Haskell and Scala extensively use combinators for tasks ranging from parsing to + UI construction. +* In domain-specific languages, particularly those involved in parsing, such as parsing expression grammars. +* In libraries for functional programming in languages like JavaScript, Python, and Ruby. +* java.util.function.Function#compose +* java.util.function.Function#andThen + +## Consequences + +Benefits: -## Benefits +* Enhances modularity and reusability by breaking down complex tasks into simpler, composable functions. +* Promotes readability and maintainability by using a declarative style of programming. +* Facilitates lazy evaluation and potentially more efficient execution through function composition. -- From a developers perspective the API is made of terms from the domain. -- There is a clear distinction between combining and application phase. -- One first constructs an instance and then executes it. -- This makes the pattern applicable in a parallel environment. +Trade-offs: +* Can lead to a steep learning curve for those unfamiliar with functional programming principles. +* May result in performance overhead due to the creation of intermediate functions. +* Debugging can be challenging due to the abstract nature of function compositions. -## Real world examples +## Related Patterns -- java.util.function.Function#compose -- java.util.function.Function#andThen +[Strategy](https://java-design-patterns.com/patterns/strategy/): Both involve selecting an algorithm at runtime, but +Combinator uses composition of functions. +[Decorator](https://java-design-patterns.com/patterns/decorator/): Similar to Combinator in enhancing functionality, but +Decorator focuses on object augmentation. +[Chain of Responsibility](https://java-design-patterns.com/patterns/chain-of-responsibility/): Relies on chaining +objects, whereas Combinator chains functions. ## Credits -- [Example for java](https://gtrefs.github.io/code/combinator-pattern/) +- [Example for Java](https://gtrefs.github.io/code/combinator-pattern/) - [Combinator pattern](https://wiki.haskell.org/Combinator_pattern) - [Combinatory logic](https://wiki.haskell.org/Combinatory_logic) +- [Structure and Interpretation of Computer Programs](https://amzn.to/3PJwVsf) +- [Functional Programming in Scala](https://amzn.to/4cEo6K2) +- [Haskell: The Craft of Functional Programming](https://amzn.to/4axxtcF)

diff --git a/combinator/src/test/java/com/iluwatar/combinator/FinderTest.java b/combinator/src/test/java/com/iluwatar/combinator/FinderTest.java index 4f0d42258d62..c4a505df075d 100644 --- a/combinator/src/test/java/com/iluwatar/combinator/FinderTest.java +++ b/combinator/src/test/java/com/iluwatar/combinator/FinderTest.java @@ -22,6 +22,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ + package com.iluwatar.combinator; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -33,12 +34,12 @@ class FinderTest { @Test void contains() { var example = """ - the first one - the second one\s - """; + the first one + the second one\s + """; var result = Finder.contains("second").find(example); assertEquals(1, result.size()); - assertEquals( "the second one ", result.get(0)); + assertEquals("the second one ", result.get(0)); } } diff --git a/combinator/src/test/java/com/iluwatar/combinator/FindersTest.java b/combinator/src/test/java/com/iluwatar/combinator/FindersTest.java index bf34af1704f7..aa84b9350d5b 100644 --- a/combinator/src/test/java/com/iluwatar/combinator/FindersTest.java +++ b/combinator/src/test/java/com/iluwatar/combinator/FindersTest.java @@ -22,6 +22,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ + package com.iluwatar.combinator; import static com.iluwatar.combinator.Finders.advancedFinder; @@ -38,48 +39,47 @@ class FindersTest { void advancedFinderTest() { var res = advancedFinder("it was", "kingdom", "sea").find(text()); assertEquals(1, res.size()); - assertEquals( "It was many and many a year ago,", res.get(0)); + assertEquals("It was many and many a year ago,", res.get(0)); } @Test void filteredFinderTest() { var res = filteredFinder(" was ", "many", "child").find(text()); assertEquals(1, res.size()); - assertEquals( "But we loved with a love that was more than love-", res.get(0)); + assertEquals("But we loved with a love that was more than love-", res.get(0)); } @Test void specializedFinderTest() { var res = specializedFinder("love", "heaven").find(text()); assertEquals(1, res.size()); - assertEquals( "With a love that the winged seraphs of heaven", res.get(0)); + assertEquals("With a love that the winged seraphs of heaven", res.get(0)); } @Test void expandedFinderTest() { var res = expandedFinder("It was", "kingdom").find(text()); assertEquals(3, res.size()); - assertEquals( "It was many and many a year ago,", res.get(0)); - assertEquals( "In a kingdom by the sea,", res.get(1)); - assertEquals( "In this kingdom by the sea;", res.get(2)); + assertEquals("It was many and many a year ago,", res.get(0)); + assertEquals("In a kingdom by the sea,", res.get(1)); + assertEquals("In this kingdom by the sea;", res.get(2)); } private String text() { - return - """ - It was many and many a year ago, - In a kingdom by the sea, - That a maiden there lived whom you may know - By the name of ANNABEL LEE; - And this maiden she lived with no other thought - Than to love and be loved by me. - I was a child and she was a child, - In this kingdom by the sea; - But we loved with a love that was more than love- - I and my Annabel Lee; - With a love that the winged seraphs of heaven - Coveted her and me."""; + return """ + It was many and many a year ago, + In a kingdom by the sea, + That a maiden there lived whom you may know + By the name of ANNABEL LEE; + And this maiden she lived with no other thought + Than to love and be loved by me. + I was a child and she was a child, + In this kingdom by the sea; + But we loved with a love that was more than love- + I and my Annabel Lee; + With a love that the winged seraphs of heaven + Coveted her and me."""; } }

train

test

iluwatar

train

iluwatar/java-design-patterns/2216_2878

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2216

iluwatar/java-design-patterns/2878

2228212c2361c3ed54babe2b3778f386f5aac9d5

81ebcf0a791adb28175186332038922f5087c82d

Explanation for Commander

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/commander/README.md b/commander/README.md index 472370f4bbe1..f6cacd243f76 100644 --- a/commander/README.md +++ b/commander/README.md @@ -1,25 +1,162 @@ --- title: Commander -category: Concurrency +category: Behavioral language: en tag: - - Cloud distributed + - Cloud distributed + - Microservices + - Transactions --- +## Also known as + +* Distributed Transaction Commander +* Transaction Coordinator + ## Intent -> Used to handle all problems that can be encountered when doing distributed transactions. +The intent of the Commander pattern in the context of distributed transactions is to manage and coordinate complex +transactions across multiple distributed components or services, ensuring consistency and integrity of the overall +transaction. It encapsulates transaction commands and coordination logic, facilitating the implementation of distributed +transaction protocols like two-phase commit or Saga. + +## Explanation + +Real-world example + +> Imagine organizing a large international music festival where various bands from around the world are scheduled to +> perform. Each band's arrival, soundcheck, and performance are like individual transactions in a distributed system. The +> festival organizer acts as the "Commander," coordinating these transactions to ensure that if a band's flight is +> delayed (akin to a transaction failure), there's a backup plan, such as rescheduling or swapping time slots with another +> band (compensating actions), to keep the overall schedule intact. This setup mirrors the Commander pattern in +> distributed transactions, where various components must be coordinated to achieve a successful outcome despite +> individual failures. + +In plain words + +> The Commander pattern turns a request into a stand-alone object, allowing for the parameterization of commands, +> queueing of actions, and the implementation of undo operations. + +**Programmatic Example** + +Managing transactions across different services in a distributed system, such as an e-commerce platform with separate +Payment and Shipping microservices, requires careful coordination to avoid issues. When a user places an order but one +service (e.g., Payment) is unavailable while the other (e.g., Shipping) is ready, we need a robust solution to handle +this discrepancy. + +A strategy to address this involves using a Commander component that orchestrates the process. Initially, the order is +processed by the available service (Shipping in this case). The commander then attempts to synchronize the order with +the currently unavailable service (Payment) by storing the order details in a database or queueing it for future +processing. This queueing system must also account for possible failures in adding requests to the queue. + +The commander repeatedly tries to process the queued orders to ensure both services eventually reflect the same +transaction data. This process involves ensuring idempotence, meaning that even if the same order synchronization +request is made multiple times, it will only be executed once, preventing duplicate transactions. The goal is to achieve +eventual consistency across services, where all systems are synchronized over time despite initial failures or delays. + +In the provided code, the Commander pattern is used to handle distributed transactions across multiple services ( +PaymentService, ShippingService, MessagingService, EmployeeHandle). Each service has its own database and can throw +exceptions to simulate failures. + +The Commander class is the central part of this pattern. It takes instances of all services and their databases, along +with some configuration parameters. The placeOrder method in the Commander class is used to place an order, which +involves interacting with all the services. + +```java +public class Commander { + // ... constructor and other methods ... + + public void placeOrder(Order order) { + // ... implementation ... + } +} +``` + +The User and Order classes represent a user and an order respectively. An order is placed by a user. + +```java +public class User { + // ... constructor and other methods ... +} + +public class Order { + // ... constructor and other methods ... +} +``` + +Each service (e.g., PaymentService, ShippingService, MessagingService, EmployeeHandle) has its own database and can +throw exceptions to simulate failures. For example, the PaymentService might throw a DatabaseUnavailableException if its +database is unavailable. + +```java +public class PaymentService { + // ... constructor and other methods ... +} +``` + +The DatabaseUnavailableException, ItemUnavailableException, and ShippingNotPossibleException classes represent different +types of exceptions that can occur. + +```java +public class DatabaseUnavailableException extends Exception { + // ... constructor and other methods ... +} + +public class ItemUnavailableException extends Exception { + // ... constructor and other methods ... +} + +public class ShippingNotPossibleException extends Exception { + // ... constructor and other methods ... +} +``` + +In the main method of each class (AppQueueFailCases, AppShippingFailCases), different scenarios are simulated by +creating instances of the Commander class with different configurations and calling the placeOrder method. ## Class diagram +  ## Applicability -This pattern can be used when we need to make commits into 2 (or more) databases to complete transaction, which cannot be done atomically and can thereby create problems. -## Explanation -Handling distributed transactions can be tricky, but if we choose to not handle it carefully, there could be unwanted consequences. Say, we have an e-commerce website which has a Payment microservice and a Shipping microservice. If the shipping is available currently but payment service is not up, or vice versa, how would we deal with it after having already received the order from the user? -We need a mechanism in place which can handle these kinds of situations. We have to direct the order to either one of the services (in this example, shipping) and then add the order into the database of the other service (in this example, payment), since two databases cannot be updated atomically. If currently unable to do it, there should be a queue where this request can be queued, and there has to be a mechanism which allows for a failure in the queueing as well. All this needs to be done by constant retries while ensuring idempotence (even if the request is made several times, the change should only be applied once) by a commander class, to reach a state of eventual consistency. +Use the Commander pattern for distributed transactions when: + +* You need to ensure data consistency across distributed services in the event of partial system failures. +* Transactions span multiple microservices or distributed components requiring coordinated commit or rollback. +* You are implementing long-lived transactions requiring compensating actions for rollback. + +## Known Uses + +* Two-Phase Commit (2PC) Protocols: Coordinating commit or rollback across distributed databases or services. +* Saga Pattern Implementations: Managing long-lived business processes that span multiple microservices, with each step + having a compensating action for rollback. +* Distributed Transactions in Microservices Architecture: Coordinating complex operations across microservices while + maintaining data integrity and consistency. + +## Consequences + +Benefits: + +* Provides a clear mechanism for managing complex distributed transactions, enhancing system reliability. +* Enables the implementation of compensating transactions, which are crucial for maintaining consistency in long-lived + transactions. +* Facilitates the integration of heterogeneous systems within a transactional context. + +Trade-offs: + +* Increases complexity, especially in failure scenarios, due to the need for coordinated rollback mechanisms. +* Potentially impacts performance due to the overhead of coordination and consistency checks. +* Saga-based implementations can lead to increased complexity in understanding the overall business process flow. + +## Related Patterns + +[Saga Pattern](https://java-design-patterns.com/patterns/saga/): Often discussed in tandem with the Commander pattern +for distributed transactions, focusing on long-lived transactions with compensating actions. ## Credits * [Distributed Transactions: The Icebergs of Microservices](https://www.grahamlea.com/2016/08/distributed-transactions-microservices-icebergs/) +* [Microservices Patterns: With examples in Java](https://amzn.to/4axjnYW) +* [Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems](https://amzn.to/4axHwOV) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://amzn.to/4aATcRe) diff --git a/commander/src/main/java/com/iluwatar/commander/Commander.java b/commander/src/main/java/com/iluwatar/commander/Commander.java index 6b6c90a03f8d..4a1483c11e02 100644 --- a/commander/src/main/java/com/iluwatar/commander/Commander.java +++ b/commander/src/main/java/com/iluwatar/commander/Commander.java @@ -121,7 +121,7 @@ void placeOrder(Order order) throws Exception { sendShippingRequest(order); } - private void sendShippingRequest(Order order) throws Exception { + private void sendShippingRequest(Order order) { var list = shippingService.exceptionsList; Retry.Operation op = (l) -> { if (!l.isEmpty()) { @@ -233,7 +233,7 @@ private void sendPaymentRequest(Order order) { try { r.perform(list, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); @@ -282,7 +282,7 @@ private void updateQueue(QueueTask qt) { try { r.perform(list, qt); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); @@ -305,7 +305,7 @@ private void tryDoingTasksInQueue() { //commander controls operations done to qu try { r.perform(list, null); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t2.start(); @@ -324,12 +324,12 @@ private void tryDequeue() { }; Retry.HandleErrorIssue<QueueTask> handleError = (o, err) -> { }; - var r = new Retry<QueueTask>(op, handleError, numOfRetries, retryDuration, + var r = new Retry<>(op, handleError, numOfRetries, retryDuration, e -> DatabaseUnavailableException.class.isAssignableFrom(e.getClass())); try { r.perform(list, null); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t3.start(); @@ -351,7 +351,7 @@ private void sendSuccessMessage(Order order) { try { r.perform(list, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); @@ -409,7 +409,7 @@ private void sendPaymentFailureMessage(Order order) { try { r.perform(list, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); @@ -465,7 +465,7 @@ private void sendPaymentPossibleErrorMsg(Order order) { try { r.perform(list, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); @@ -537,7 +537,7 @@ private void employeeHandleIssue(Order order) { try { r.perform(list, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } }); t.start(); diff --git a/commander/src/main/java/com/iluwatar/commander/Retry.java b/commander/src/main/java/com/iluwatar/commander/Retry.java index 45984dfaa910..71614668254b 100644 --- a/commander/src/main/java/com/iluwatar/commander/Retry.java +++ b/commander/src/main/java/com/iluwatar/commander/Retry.java @@ -94,7 +94,7 @@ public void perform(List<Exception> list, T obj) { this.errors.add(e); if (this.attempts.incrementAndGet() >= this.maxAttempts || !this.test.test(e)) { this.handleError.handleIssue(obj, e); - return; //return here...dont go further + return; //return here... don't go further } try { long testDelay = diff --git a/commander/src/main/java/com/iluwatar/commander/employeehandle/EmployeeHandle.java b/commander/src/main/java/com/iluwatar/commander/employeehandle/EmployeeHandle.java index ac161fbb5404..441ce920feae 100644 --- a/commander/src/main/java/com/iluwatar/commander/employeehandle/EmployeeHandle.java +++ b/commander/src/main/java/com/iluwatar/commander/employeehandle/EmployeeHandle.java @@ -47,7 +47,7 @@ protected String updateDb(Object... parameters) throws DatabaseUnavailableExcept var o = (Order) parameters[0]; if (database.get(o.id) == null) { database.add(o); - return o.id; //true rcvd - change addedToEmployeeHandle to true else dont do anything + return o.id; //true rcvd - change addedToEmployeeHandle to true else don't do anything } return null; } diff --git a/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingDatabase.java b/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingDatabase.java index 7339a623c1ce..e4a000f1cf62 100644 --- a/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingDatabase.java +++ b/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingDatabase.java @@ -38,7 +38,7 @@ public class MessagingDatabase extends Database<MessageRequest> { @Override public MessageRequest add(MessageRequest r) { - return data.put(r.reqId, r); + return data.put(r.reqId(), r); } @Override diff --git a/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingService.java b/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingService.java index 47d14b970b68..e00bde4997b6 100644 --- a/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingService.java +++ b/commander/src/main/java/com/iluwatar/commander/messagingservice/MessagingService.java @@ -44,11 +44,7 @@ enum MessageToSend { PAYMENT_SUCCESSFUL } - @RequiredArgsConstructor - static class MessageRequest { - final String reqId; - final MessageToSend msg; - } + record MessageRequest(String reqId, MessageToSend msg) {} public MessagingService(MessagingDatabase db, Exception... exc) { super(db, exc); diff --git a/commander/src/main/java/com/iluwatar/commander/paymentservice/PaymentService.java b/commander/src/main/java/com/iluwatar/commander/paymentservice/PaymentService.java index 0ba0c531001f..28fda2eb2106 100644 --- a/commander/src/main/java/com/iluwatar/commander/paymentservice/PaymentService.java +++ b/commander/src/main/java/com/iluwatar/commander/paymentservice/PaymentService.java @@ -51,7 +51,7 @@ public PaymentService(PaymentDatabase db, Exception... exc) { */ public String receiveRequest(Object... parameters) throws DatabaseUnavailableException { - //it could also be sending a userid, payment details here or something, not added here + //it could also be sending an userid, payment details here or something, not added here var id = generateId(); var req = new PaymentRequest(id, (float) parameters[0]); return updateDb(req); diff --git a/commander/src/main/java/com/iluwatar/commander/queue/QueueDatabase.java b/commander/src/main/java/com/iluwatar/commander/queue/QueueDatabase.java index 5f4f40b5b5df..b8189e6f0025 100644 --- a/commander/src/main/java/com/iluwatar/commander/queue/QueueDatabase.java +++ b/commander/src/main/java/com/iluwatar/commander/queue/QueueDatabase.java @@ -25,7 +25,6 @@ package com.iluwatar.commander.queue; import com.iluwatar.commander.Database; -import com.iluwatar.commander.exceptions.DatabaseUnavailableException; import com.iluwatar.commander.exceptions.IsEmptyException; import java.util.ArrayList; import java.util.List;

diff --git a/commander/src/test/java/com/iluwatar/commander/RetryTest.java b/commander/src/test/java/com/iluwatar/commander/RetryTest.java index 2276b340efc7..c74fb94d0f9d 100644 --- a/commander/src/test/java/com/iluwatar/commander/RetryTest.java +++ b/commander/src/test/java/com/iluwatar/commander/RetryTest.java @@ -31,9 +31,13 @@ import java.util.ArrayList; import java.util.List; import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; class RetryTest { + private static final Logger LOG = LoggerFactory.getLogger(RetryTest.class); + @Test void performTest() { Retry.Operation op = (l) -> { @@ -53,16 +57,16 @@ void performTest() { try { r1.perform(arr1, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } var arr2 = new ArrayList<>(List.of(new DatabaseUnavailableException(), new ItemUnavailableException())); try { r2.perform(arr2, order); } catch (Exception e1) { - e1.printStackTrace(); + LOG.error("An exception occurred", e1); } //r1 stops at ItemUnavailableException, r2 retries because it encounters DatabaseUnavailableException - assertTrue(arr1.size() == 1 && arr2.size() == 0); + assertTrue(arr1.size() == 1 && arr2.isEmpty()); } }

val

test

iluwatar

train

iluwatar/java-design-patterns/2870_2885

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2870

iluwatar/java-design-patterns/2885

74cce87c70385a629d3eb929c2767aec503ff0db

9f97c1505d8985d7b0f6d4cea3f91c23a0b54bdd

Upgrade jackson-databind

The version bump of jackson-databind seems to need some work. See https://github.com/iluwatar/java-design-patterns/pull/2867 Acceptance criteria - jackson-databind successfully upgraded to the latest version

diff --git a/dynamic-proxy/pom.xml b/dynamic-proxy/pom.xml index 0ec69f0bcc6e..d308c7885993 100644 --- a/dynamic-proxy/pom.xml +++ b/dynamic-proxy/pom.xml @@ -35,10 +35,15 @@ </parent> <artifactId>dynamic-proxy</artifactId> <dependencies> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-core</artifactId> + <version>2.17.0</version> + </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> - <version>2.16.1</version> + <version>2.17.0</version> </dependency> <dependency> <groupId>org.springframework</groupId> diff --git a/event-sourcing/pom.xml b/event-sourcing/pom.xml index 569a5fceebd8..19f6feb8f7a7 100644 --- a/event-sourcing/pom.xml +++ b/event-sourcing/pom.xml @@ -39,9 +39,15 @@ <artifactId>junit-jupiter-engine</artifactId> <scope>test</scope> </dependency> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-core</artifactId> + <version>2.17.0</version> + </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> + <version>2.17.0</version> </dependency> </dependencies> <build>

train

test

iluwatar

train

iluwatar/java-design-patterns/2853_2886

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2853

iluwatar/java-design-patterns/2886

74cce87c70385a629d3eb929c2767aec503ff0db

3ac7cc326898429855246d2a9578cf59553b3153

Composite View refactoring needed

Servlets are components in Java web development, responsible for processing HTTP requests and generating responses. In this context, exceptions are used to handle and manage unexpected errors or exceptional conditions that may occur during the execution of a servlet. Exceptions should not be thrown from servlet methods. These 4 hotspots need to be fixed: AppServlet.java:64 AppServlet.java:71 AppServlet.java:81 AppServlet.java:90 Acceptance criteria - The aforementioned exceptions have been caught properly

diff --git a/composite-view/src/main/java/com/iluwatar/compositeview/AppServlet.java b/composite-view/src/main/java/com/iluwatar/compositeview/AppServlet.java index 0cef25d2dd22..d2ec90675eb5 100644 --- a/composite-view/src/main/java/com/iluwatar/compositeview/AppServlet.java +++ b/composite-view/src/main/java/com/iluwatar/compositeview/AppServlet.java @@ -25,18 +25,17 @@ package com.iluwatar.compositeview; import jakarta.servlet.RequestDispatcher; -import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpServlet; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; -import java.io.IOException; import java.io.PrintWriter; +import lombok.extern.slf4j.Slf4j; /** * A servlet object that extends HttpServlet. * Runs on Tomcat 10 and handles Http requests */ - +@Slf4j public final class AppServlet extends HttpServlet { private static final String CONTENT_TYPE = "text/html"; private String msgPartOne = "<h1>This Server Doesn't Support"; @@ -56,39 +55,44 @@ public AppServlet() { } @Override - public void doGet(HttpServletRequest req, HttpServletResponse resp) - throws ServletException, IOException { - RequestDispatcher requestDispatcher = req.getRequestDispatcher(destination); - ClientPropertiesBean reqParams = new ClientPropertiesBean(req); - req.setAttribute("properties", reqParams); - requestDispatcher.forward(req, resp); + public void doGet(HttpServletRequest req, HttpServletResponse resp) { + try { + RequestDispatcher requestDispatcher = req.getRequestDispatcher(destination); + ClientPropertiesBean reqParams = new ClientPropertiesBean(req); + req.setAttribute("properties", reqParams); + requestDispatcher.forward(req, resp); + } catch (Exception e) { + LOGGER.error("Exception occurred GET request processing ", e); + } } @Override - public void doPost(HttpServletRequest req, HttpServletResponse resp) - throws ServletException, IOException { + public void doPost(HttpServletRequest req, HttpServletResponse resp) { resp.setContentType(CONTENT_TYPE); try (PrintWriter out = resp.getWriter()) { out.println(msgPartOne + " Post " + msgPartTwo); + } catch (Exception e) { + LOGGER.error("Exception occurred POST request processing ", e); } - } @Override - public void doDelete(HttpServletRequest req, HttpServletResponse resp) - throws ServletException, IOException { + public void doDelete(HttpServletRequest req, HttpServletResponse resp) { resp.setContentType(CONTENT_TYPE); try (PrintWriter out = resp.getWriter()) { out.println(msgPartOne + " Delete " + msgPartTwo); + } catch (Exception e) { + LOGGER.error("Exception occurred DELETE request processing ", e); } } @Override - public void doPut(HttpServletRequest req, HttpServletResponse resp) - throws ServletException, IOException { + public void doPut(HttpServletRequest req, HttpServletResponse resp) { resp.setContentType(CONTENT_TYPE); try (PrintWriter out = resp.getWriter()) { out.println(msgPartOne + " Put " + msgPartTwo); + } catch (Exception e) { + LOGGER.error("Exception occurred PUT request processing ", e); } } }

train

test

iluwatar

train

iluwatar/java-design-patterns/2217_2896

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2217

iluwatar/java-design-patterns/2896

8f777cdc981877545194e513ac87f336f2e6fc00

faac96b21b3074cc7196713ab029810b68db4961

Explanation for Command Query Responsibility Segregation (CQRS)

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/cqrs/README.md b/cqrs/README.md index 6ac6061ef70e..e4af36bc3c51 100644 --- a/cqrs/README.md +++ b/cqrs/README.md @@ -3,25 +3,89 @@ title: CQRS category: Architectural language: en tag: - - Performance - - Cloud distributed + - Event-driven + - Performance + - Scalability --- ## Intent -CQRS Command Query Responsibility Segregation - Separate the query side from the command side. + +CQRS aims to segregate the operations that modify the state of an application (commands) from the operations that read the state (queries). This separation allows for more flexible and optimized designs, especially in complex systems. + +## Explanation + +Real world example + +> Imagine a modern library where the tasks of borrowing and returning books (commands) are handled at the front desk, while the task of searching for books and reading them (queries) happens in the reading area. The front desk optimizes for transaction efficiency and record-keeping, ensuring books are properly checked in and out. Meanwhile, the reading area is optimized for comfort and accessibility, making it easy for readers to find and engage with the books. This separation improves the library's overall efficiency and user experience, much like the CQRS pattern enhances a software system's performance and maintainability. + +In plain words + +> The CQRS design pattern separates the actions of modifying data (commands) from the actions of retrieving data (queries) to enhance performance, scalability, and maintainability in software systems. + +**Programmatic Example** + +One way to implement the Command Query Responsibility Segregation (CQRS) pattern is to separate the read and write operations into different services. + +1. Command Service: The `CommandServiceImpl` class is used for write operations. It provides methods to create authors and books, and to add books to authors. Here's a snippet of how it's used: + +```java +var commands=new CommandServiceImpl(); + commands.authorCreated(AppConstants.E_EVANS,"Eric Evans","evans@email.com"); + commands.bookAddedToAuthor("Domain-Driven Design",60.08,AppConstants.E_EVANS); +``` + +2. Query Service: The `QueryServiceImpl` class is used for read operations. It provides methods to get author and book details. Here's a snippet of how it's used: + +```java +var queries=new QueryServiceImpl(); + var evans=queries.getAuthorByUsername(AppConstants.E_EVANS); + var dddBook=queries.getBook("Domain-Driven Design"); +``` + +This separation of concerns allows for flexibility in how the application handles data access and manipulation, and is a key aspect of the CQRS pattern. ## Class diagram +  ## Applicability -Use the CQRS pattern when -* You want to scale the queries and commands independently. -* You want to use different data models for queries and commands. Useful when dealing with complex domains. -* You want to use architectures like event sourcing or task based UI. +* Systems requiring distinct models for read and write operations for scalability and maintainability. +* Complex domain models where the task of updating objects differs significantly from the task of reading object data. +* Scenarios where performance optimization for read operations is crucial, and the system can benefit from different data models or databases for reads and writes. + +## Known Uses + +* Distributed Systems and Microservices Architecture, where different services manage read and write responsibilities. +* Event-Sourced Systems, where changes to the application state are stored as a sequence of events. +* High-Performance Web Applications, segregating read and write databases to optimize load handling. + +## Consequences + +Benefits: + +* Scalability: By separating read and write models, each can be scaled independently according to their specific demands. +* Optimization: Allows for the optimization of read models for query efficiency and write models for transactional integrity. +* Maintainability: Reduces complexity by separating the concerns, leading to cleaner, more maintainable code. +* Flexibility: Offers the flexibility to choose different technologies for the read and write sides according to their requirements. + +Trade-Offs: + +* Complexity: Introduces complexity due to synchronization between read and write models, especially in consistency maintenance. +* Overhead: Might be an overkill for simple systems where the benefits do not outweigh the additional complexity. +* Learning Curve: Requires a deeper understanding and careful design to implement effectively, increasing the initial learning curve. + +## Related Patterns + +* [Event Sourcing](https://java-design-patterns.com/patterns/event-sourcing/): Often used in conjunction with CQRS, where changes to the application state are stored as a sequence of events. +* Domain-Driven Design (DDD): CQRS fits well within the DDD context, providing clear boundaries and separation of concerns. +* [Repository](https://java-design-patterns.com/patterns/repository/): Can be used to abstract the data layer, providing a more seamless integration between the command and query sides. ## Credits +* [Patterns, Principles, and Practices of Domain-Driven Design](https://amzn.to/3vNV4Hm) +* [Implementing Domain-Driven Design](https://amzn.to/3TJN2HH) +* [Microsoft .NET: Architecting Applications for the Enterprise](https://amzn.to/4aktRes) * [Greg Young - CQRS, Task Based UIs, Event Sourcing agh!](http://codebetter.com/gregyoung/2010/02/16/cqrs-task-based-uis-event-sourcing-agh/) * [Martin Fowler - CQRS](https://martinfowler.com/bliki/CQRS.html) * [Oliver Wolf - CQRS for Great Good](https://www.youtube.com/watch?v=Ge53swja9Dw) diff --git a/cqrs/pom.xml b/cqrs/pom.xml index 58ad7f29a62c..ec78265cff66 100644 --- a/cqrs/pom.xml +++ b/cqrs/pom.xml @@ -26,55 +26,53 @@ --> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> - <modelVersion>4.0.0</modelVersion> - <parent> - <groupId>com.iluwatar</groupId> - <artifactId>java-design-patterns</artifactId> - <version>1.26.0-SNAPSHOT</version> - </parent> - <artifactId>cqrs</artifactId> - <dependencies> - <dependency> - <groupId>org.junit.jupiter</groupId> - <artifactId>junit-jupiter-engine</artifactId> - <scope>test</scope> - </dependency> - <dependency> - <groupId>com.h2database</groupId> - <artifactId>h2</artifactId> - </dependency> - <dependency> - <groupId>org.hibernate</groupId> - <artifactId>hibernate-core</artifactId> - </dependency> - <dependency> - <groupId>org.glassfish.jaxb</groupId> - <artifactId>jaxb-runtime</artifactId> - <scope>test</scope> - </dependency> - <dependency> - <groupId>javax.xml.bind</groupId> - <artifactId>jaxb-api</artifactId> - <scope>test</scope> - </dependency> - </dependencies> - <build> - <plugins> - <plugin> - <groupId>org.apache.maven.plugins</groupId> - <artifactId>maven-assembly-plugin</artifactId> - <executions> - <execution> - <configuration> - <archive> - <manifest> - <mainClass>com.iluwatar.cqrs.app.App</mainClass> - </manifest> - </archive> - </configuration> - </execution> - </executions> - </plugin> - </plugins> - </build> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>com.iluwatar</groupId> + <artifactId>java-design-patterns</artifactId> + <version>1.26.0-SNAPSHOT</version> + </parent> + <artifactId>cqrs</artifactId> + <dependencies> + <dependency> + <groupId>org.junit.jupiter</groupId> + <artifactId>junit-jupiter-engine</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>com.h2database</groupId> + <artifactId>h2</artifactId> + </dependency> + <dependency> + <groupId>org.hibernate</groupId> + <artifactId>hibernate-core</artifactId> + </dependency> + <dependency> + <groupId>org.glassfish.jaxb</groupId> + <artifactId>jaxb-runtime</artifactId> + </dependency> + <dependency> + <groupId>javax.xml.bind</groupId> + <artifactId>jaxb-api</artifactId> + </dependency> + </dependencies> + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-assembly-plugin</artifactId> + <executions> + <execution> + <configuration> + <archive> + <manifest> + <mainClass>com.iluwatar.cqrs.app.App</mainClass> + </manifest> + </archive> + </configuration> + </execution> + </executions> + </plugin> + </plugins> + </build> </project>

test

test

iluwatar

train

iluwatar/java-design-patterns/2219_2899

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2219

iluwatar/java-design-patterns/2899

356ba272720da7eb9cf3d622a4768c0957fa0e87

ea55eb4e58dc7c0b3517dfb92c3a9b7cec1f6954

Explanation for Data Locality

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/data-locality/README.md b/data-locality/README.md index 212bd663a08d..c44ba1a34fa5 100644 --- a/data-locality/README.md +++ b/data-locality/README.md @@ -1,29 +1,135 @@ --- title: Data Locality -category: Behavioral +category: Performance optimization language: en tag: - - Game programming - - Performance + - Caching + - Data access + - Game programming + - Memory management + - Performance --- +## Also known as + +* Cache-Friendly Design +* Data-Oriented Design + ## Intent -Accelerate memory access by arranging data to take advantage of CPU caching. -Modern CPUs have caches to speed up memory access. These can access memory adjacent to recently accessed memory much quicker. Take advantage of that to improve performance by increasing data locality keeping data in contiguous memory in the order that you process it. +The Data Locality design pattern aims to minimize data access times and improve cache utilization by arranging data in memory to take advantage of spatial locality. This pattern is particularly useful in high-performance computing and game development where access speed is crucial. + +## Explanation + +Real-world example + +> Consider a supermarket where items are arranged based on purchase patterns and categories for efficiency. Just like the Data Locality pattern organizes data in memory for quick access, the supermarket places frequently bought items together and in easily accessible areas. This layout minimizes the time shoppers spend searching for items, enhancing their shopping experience by ensuring that related and popular items are close at hand, much like how data locality improves cache utilization and reduces access latency in computing. + +In plain words + +> The Data Locality pattern organizes data in memory to reduce access times and improve performance by ensuring that data frequently accessed together is stored close together. + +Programmatic Example + +The Data Locality pattern is a design pattern that aims to improve performance by arranging data in memory to take advantage of spatial locality. This pattern is particularly useful in high-performance computing and game development where access speed is crucial. + +In the data-locality module, the pattern is demonstrated using a game loop that processes a bunch of game entities. These entities are decomposed into different domains: AI, physics, and rendering. + +The GameEntity class is the main class that represents a game entity. It contains an array of AiComponent, PhysicsComponent, and RenderComponent objects. These components represent different aspects of a game entity. + +```java +public class GameEntity { + private final AiComponent[] aiComponents; + private final PhysicsComponent[] physicsComponents; + private final RenderComponent[] renderComponents; +// ... +} +``` + +The GameEntity class has a start method that initializes all the components. + +```java +public void start() { + for (int i = 0; i < numEntities; i++) { + aiComponents[i] = new AiComponent(); + physicsComponents[i] = new PhysicsComponent(); + renderComponents[i] = new RenderComponent(); + } +} +``` + +The GameEntity class also has an update method that updates all the components. This method demonstrates the data locality pattern. Instead of updating all aspects of a single entity at a time (AI, physics, and rendering), it updates the same aspect (e.g., AI) for all entities first, then moves on to the next aspect (e.g., physics). This approach improves cache utilization because it's more likely that the data needed for the update is already in the cache. + +```java +public void update() { + for (int i = 0; i < numEntities; i++) { + aiComponents[i].update(); + } + for (int i = 0; i < numEntities; i++) { + physicsComponents[i].update(); + } + for (int i = 0; i < numEntities; i++) { + renderComponents[i].update(); + } +} +``` + +The Application class contains the main method that creates a GameEntity object and starts the game loop. + +```java +public class Application { + public static void main(String[] args) { + var gameEntity = new GameEntity(NUM_ENTITIES); + gameEntity.start(); + gameEntity.update(); + } +} +``` + +In this way, the data-locality module demonstrates the Data Locality pattern. By updating all components of the same type together, it increases the likelihood that the data needed for the update is already in the cache, thereby improving performance. ## Class diagram +  ## Applicability -* Like most optimizations, the first guideline for using the Data Locality pattern is when you have a performance problem. -* With this pattern specifically, you’ll also want to be sure your performance problems are caused by cache misses. +This pattern is applicable in scenarios where large datasets are processed and performance is critical. It's particularly useful in: + +* Game development for efficient rendering and physics calculations. +* High-performance computing tasks that require rapid access to large data sets. +* Real-time data processing systems where latency is a critical factor. + +## Known Uses + +* Game engines (e.g., Unity, Unreal Engine) to optimize entity and component data access. +* High-performance matrix libraries in scientific computing to optimize matrix operations. +* Real-time streaming data processing systems for efficient data manipulation and access. + +## Consequences + +Benefits: + +* Improved Cache Utilization: By enhancing spatial locality, data frequently accessed together is stored close together in memory, improving cache hit rates. +* Reduced Access Latency: Minimizes the time taken to fetch data from memory, leading to performance improvements. +* Enhanced Performance: Overall system performance is improved due to reduced memory access times and increased efficiency in data processing. + +Trade-offs: + +* Complexity in Implementation: Managing data layout can add complexity to the system design and implementation. +* Maintenance Overhead: As data access patterns evolve, the layout may need to be re-evaluated, adding to the maintenance overhead. +* Less Flexibility: The tight coupling of data layout to access patterns can reduce flexibility in how data structures are used and evolved over time. -## Real world example +## Related Patterns -* The [Artemis](http://gamadu.com/artemis/) game engine is one of the first and better-known frameworks that uses simple IDs for game entities. +* [Flyweight](https://java-design-patterns.com/patterns/flyweight/): Can be used in conjunction with Data Locality to share data efficiently among multiple objects. +* [Object Pool](https://java-design-patterns.com/patterns/object-pool/): Often used together to manage a group of initialized objects that can be reused, further optimizing memory usage and access. +* [Iterator](https://java-design-patterns.com/patterns/iterator/): Facilitates navigation through a collection of data laid out with data locality in mind. ## Credits -* [Game Programming Patterns Optimization Patterns: Data Locality](http://gameprogrammingpatterns.com/data-locality.html) \ No newline at end of file +* [Game Programming Patterns](https://amzn.to/3vK8c0d) +* [High-Performance Java Persistence](https://amzn.to/3TMc8Wd) +* [Java Performance: The Definitive Guide](https://amzn.to/3Ua392J) +* [Effective Java](https://amzn.to/4cGk2Jz) +* [Game Programming Patterns Optimization Patterns: Data Locality](http://gameprogrammingpatterns.com/data-locality.html)

diff --git a/data-locality/src/test/java/com/iluwatar/data/locality/ApplicationTest.java b/data-locality/src/test/java/com/iluwatar/data/locality/ApplicationTest.java index 1f5986c9f2bc..1f1689425f41 100644 --- a/data-locality/src/test/java/com/iluwatar/data/locality/ApplicationTest.java +++ b/data-locality/src/test/java/com/iluwatar/data/locality/ApplicationTest.java @@ -36,7 +36,6 @@ class ApplicationTest { /** * Issue: Add at least one assertion to this test case. - * * Solution: Inserted assertion to check whether the execution of the main method in {@link Application#main(String[])} * throws an exception. */

train

test

iluwatar

train

iluwatar/java-design-patterns/2220_2900

iluwatar/java-design-patterns

iluwatar/java-design-patterns/2220

iluwatar/java-design-patterns/2900

ea55eb4e58dc7c0b3517dfb92c3a9b7cec1f6954

39acd1d0fb3ba2d70acde009de52bfd3d356e189

Explanation for Data Mapper

In this issue, let's add a proper explanation for the pattern. Acceptance criteria - The pattern's README.md has been amended with an explanation - The explanation consists of - Real world example - In plain words - Wikipedia says - Programmatic example

diff --git a/data-mapper/README.md b/data-mapper/README.md index 7f8b141ee71e..9bf3f1d5124e 100644 --- a/data-mapper/README.md +++ b/data-mapper/README.md @@ -1,183 +1,132 @@ --- title: Data Mapper -category: Architectural +category: Behavioral language: en tag: -- Decoupling + - Data access + - Decoupling + - Object mapping + - Persistence --- +## Also known as + +* Object-Relational Mapping (ORM) + ## Intent ->Data Mapper is the software layer that separates the in-memory objects from the database. ->Its responsibility is to transfer data between the objects and database and isolate them from each other. ->If we obtain a Data Mapper, it is not necessary for the in-memory object to know if the database exists or not. ->The user could directly manipulate the objects via Java command without having knowledge of SQL or database. + +The Data Mapper pattern aims to create an abstraction layer between the database and the business logic, allowing them to evolve independently. It maps data from the database objects to in-memory data structures and vice versa, minimizing direct dependencies between the application's core logic and the underlying database structure. ## Explanation Real world example ->When a user accesses a specific web page through a browser, he only needs to do several operations to the browser. -> The browser and the server will take the responsibility of saving data separately. -> You don't need to know the existence of the server or how to operate the server. + +> When a user accesses a specific web page through a browser, he only needs to do several operations to the browser. The browser and the server will take the responsibility of saving data separately. You don't need to know the existence of the server or how to operate the server. In plain words ->A layer of mappers that moves data between objects and a database while keeping them independent of each other. + +> A layer of mappers that moves data between objects and a database while keeping them independent of each other. Wikipedia says ->A Data Mapper is a Data Access Layer that performs bidirectional transfer of data between a persistent data store -> (often a relational database) and an in-memory data representation (the domain layer). The goal of the pattern is to -> keep the in-memory representation and the persistent data store independent of each other and the data mapper itself. -> This is useful when one needs to model and enforce strict business processes on the data in the domain layer that do -> not map neatly to the persistent data store. -**Programmatic Example** +> A Data Mapper is a Data Access Layer that performs bidirectional transfer of data between a persistent data store (often a relational database) and an in-memory data representation (the domain layer). The goal of the pattern is to keep the in-memory representation and the persistent data store independent of each other and the data mapper itself. This is useful when one needs to model and enforce strict business processes on the data in the domain layer that do not map neatly to the persistent data store. ->We have the student class to defining Students' attributes includes studentId, name and grade. ->We have an interface of StudentDataMapper to lists out the possible behaviour for all possible student mappers. ->And StudentDataMapperImpl class for the implementation of actions on Students Data. +**Programmatic Example** -```java +The Data Mapper is a design pattern that separates the in-memory objects from the database. Its responsibility is to transfer data between the two and also to isolate them from each other. This pattern promotes the [Single Responsibility Principle](https://java-design-patterns.com/principles/#single-responsibility-principle) and [Separation of Concerns](https://java-design-patterns.com/principles/#separation-of-concerns). -public final class Student implements Serializable { +In the data-mapper module, the pattern is demonstrated using a Student class and a StudentDataMapper interface. - private static final long serialVersionUID = 1L; +The Student class is a simple POJO (Plain Old Java Object) that represents a student. It has properties like studentId, name, and grade. - @EqualsAndHashCode.Include +```java +public class Student { private int studentId; private String name; private char grade; - - - public interface StudentDataMapper { - - Optional<Student> find(int studentId); - - void insert(Student student) throws DataMapperException; - - void update(Student student) throws DataMapperException; - - void delete(Student student) throws DataMapperException; - } - - public final class StudentDataMapperImpl implements StudentDataMapper { - @Override - public Optional<Student> find(int studentId) { - return this.getStudents().stream().filter(x -> x.getStudentId() == studentId).findFirst(); - } - - @Override - public void update(Student studentToBeUpdated) throws DataMapperException { - String name = studentToBeUpdated.getName(); - Integer index = Optional.of(studentToBeUpdated) - .map(Student::getStudentId) - .flatMap(this::find) - .map(students::indexOf) - .orElseThrow(() -> new DataMapperException("Student [" + name + "] is not found")); - students.set(index, studentToBeUpdated); - } - - @Override - public void insert(Student studentToBeInserted) throws DataMapperException { - Optional<Student> student = find(studentToBeInserted.getStudentId()); - if (student.isPresent()) { - String name = studentToBeInserted.getName(); - throw new DataMapperException("Student already [" + name + "] exists"); - } - - students.add(studentToBeInserted); - } - - @Override - public void delete(Student studentToBeDeleted) throws DataMapperException { - if (!students.remove(studentToBeDeleted)) { - String name = studentToBeDeleted.getName(); - throw new DataMapperException("Student [" + name + "] is not found"); - } - } - - public List<Student> getStudents() { - return this.students; - } - } + // ... } - ``` ->The below example demonstrates basic CRUD operations: Create, Read, Update, and Delete between the in-memory objects -> and the database. +The StudentDataMapper interface defines the operations that can be performed on Student objects. These operations include insert, update, delete, and find. ```java -@Slf4j -public final class App { - - private static final String STUDENT_STRING = "App.main(), student : "; - - public static void main(final String... args) { - - final var mapper = new StudentDataMapperImpl(); +public interface StudentDataMapper { + void insert(final Student student); - var student = new Student(1, "Adam", 'A'); + void update(final Student student); - mapper.insert(student); + void delete(final Student student); - LOGGER.debug(STUDENT_STRING + student + ", is inserted"); + Optional<Student> find(final int studentId); + // ... +} +``` - final var studentToBeFound = mapper.find(student.getStudentId()); +The StudentDataMapperImpl class implements the StudentDataMapper interface. It contains the actual logic for interacting with the database. - LOGGER.debug(STUDENT_STRING + studentToBeFound + ", is searched"); +```java +public class StudentDataMapperImpl implements StudentDataMapper { + // ... + @Override + public void insert(final Student student) { + // Insert student into the database + } - student = new Student(student.getStudentId(), "AdamUpdated", 'A'); + @Override + public void update(final Student student) { + // Update student in the database + } - mapper.update(student); + @Override + public void delete(final Student student) { + // Delete student from the database + } - LOGGER.debug(STUDENT_STRING + student + ", is updated"); - LOGGER.debug(STUDENT_STRING + student + ", is going to be deleted"); + @Override + public Optional<Student> find(final int studentId) { + // Find student in the database + } + // ... +} +``` - mapper.delete(student); - } +The App class contains the main method that demonstrates the use of the StudentDataMapper. It creates a Student object, inserts it into the database, finds it, updates it, and finally deletes it. - private App() { - } +```java +public class App { + public static void main(final String... args) { + final var mapper = new StudentDataMapperImpl(); + var student = new Student(1, "Adam", 'A'); + mapper.insert(student); + final var studentToBeFound = mapper.find(student.getStudentId()); + student = new Student(student.getStudentId(), "AdamUpdated", 'A'); + mapper.update(student); + mapper.delete(student); + } } ``` Program output: -15:05:00.264 [main] DEBUG com.iluwatar.datamapper.App - App.main(), student : Student(studentId=1, name=Adam, grade=A), is inserted -15:05:00.267 [main] DEBUG com.iluwatar.datamapper.App - App.main(), student : Optional[Student(studentId=1, name=Adam, grade=A)], is searched -15:05:00.268 [main] DEBUG com.iluwatar.datamapper.App - App.main(), student : Student(studentId=1, name=AdamUpdated, grade=A), is updated -15:05:00.268 [main] DEBUG com.iluwatar.datamapper.App - App.main(), student : Student(studentId=1, name=AdamUpdated, grade=A), is going to be deleted - - - -This layer consists of one or more mappers (or data access objects) that perform data transfer. The scope of mapper implementations varies. -A generic mapper will handle many different domain entity types, a dedicated mapper will handle one or a few. - -## Explanation - -Real-world example - -> When accessing web resources through a browser, there is generally no need to interact with the server directly; -> the browser and the proxy server will complete the data acquisition operation, and the three will remain independent. - -In plain words - -> The data mapper will help complete the bi-directional transfer of persistence layer and in-memory data. - -Wikipedia says - -> A Data Mapper is a Data Access Layer that performs bidirectional transfer of data between a -> persistent data store (often a relational database) and an in-memory data representation (the domain layer). - -Programmatic example +``` +13:54:29.234 [main] DEBUG com.iluwatar.datamapper.App -- App.main(), student : Student(studentId=1, name=Adam, grade=A), is inserted +13:54:29.237 [main] DEBUG com.iluwatar.datamapper.App -- App.main(), student : Optional[Student(studentId=1, name=Adam, grade=A)], is searched +13:54:29.237 [main] DEBUG com.iluwatar.datamapper.App -- App.main(), student : Student(studentId=1, name=AdamUpdated, grade=A), is updated +13:54:29.238 [main] DEBUG com.iluwatar.datamapper.App -- App.main(), student : Student(studentId=1, name=AdamUpdated, grade=A), is going to be deleted +``` ## Class diagram +  ## Applicability + Use the Data Mapper in any of the following situations -* when you want to decouple data objects from DB access layer -* when you want to write multiple data retrieval/persistence implementations +* When there's a need to decouple the in-memory objects from the database entities to promote the [Single Responsibility Principle](https://java-design-patterns.com/principles/#single-responsibility-principle) and [Separation of Concerns](https://java-design-patterns.com/principles/#separation-of-concerns). +* In applications requiring an ORM tool to bridge the gap between object-oriented models and relational databases. +* When working with complex database schemas where direct data manipulation and object creation lead to cumbersome and error-prone code. ## Tutorials @@ -186,16 +135,36 @@ Use the Data Mapper in any of the following situations * [Data Transfer Object Pattern in Java - Implementation and Mapping (Tutorial for Model Mapper & MapStruct)](https://stackabuse.com/data-transfer-object-pattern-in-java-implementation-and-mapping/) ## Known uses + +* ORM frameworks such as Hibernate in Java. +* Data access layers in enterprise applications where business logic and database management are kept separate. +* Applications requiring database interactions without tying the code to a specific database implementation. * [SqlSession.getMapper()](https://mybatis.org/mybatis-3/java-api.html) ## Consequences -> Neatly mapped persistence layer data -> Data model follows the single function principle +Benefits: + +* Promotes [Single Responsibility Principle](https://java-design-patterns.com/principles/#single-responsibility-principle) by separating persistence logic from business logic. +* Enhances maintainability and readability by centralizing data interaction logic. +* Improves application's ability to adapt to changes in the database schema with minimal changes to the business logic. + +Trade-offs: + +* Introduces complexity through the additional abstraction layer. +* Might lead to performance overhead due to the abstraction layer, especially in large-scale applications or with complex queries. +* Requires developers to learn and understand the abstraction layer in addition to the database and ORM framework being used. ## Related patterns -* [Active Record Pattern](https://en.wikipedia.org/wiki/Active_record_pattern) -* [Object–relational Mapping](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping) + +* Active Record: Combines data access logic and business logic in the domain entities themselves, contrary to Data Mapper's separation of concerns. +* Object–Relational Mapping (ORM): A technique to map object-oriented programming language data to a relational database. +* [Repository](https://java-design-patterns.com/patterns/repository/): Provides an abstraction of the data layer, acting as a collection of domain objects in memory. +* [Unit of Work](https://java-design-patterns.com/patterns/unit-of-work/): Manages transactions and keeps track of the objects affected by a business transaction to ensure changes are consistent and transactional. ## Credits + +* Patterns of Enterprise Application Architecture +* [Java Persistence with Hibernate](https://amzn.to/3VNzlKe) +* [Clean Architecture: A Craftsman's Guide to Software Structure and Design](https://amzn.to/3xyEFag) * [Data Mapper](http://richard.jp.leguen.ca/tutoring/soen343-f2010/tutorials/implementing-data-mapper/) diff --git a/data-mapper/src/main/java/com/iluwatar/datamapper/DataMapperException.java b/data-mapper/src/main/java/com/iluwatar/datamapper/DataMapperException.java index 3e5419286f70..803adc53114e 100644 --- a/data-mapper/src/main/java/com/iluwatar/datamapper/DataMapperException.java +++ b/data-mapper/src/main/java/com/iluwatar/datamapper/DataMapperException.java @@ -24,6 +24,8 @@ */ package com.iluwatar.datamapper; +import java.io.Serial; + /** * Using Runtime Exception for avoiding dependency on implementation exceptions. This helps in * decoupling. @@ -32,6 +34,7 @@ */ public final class DataMapperException extends RuntimeException { + @Serial private static final long serialVersionUID = 1L; /** diff --git a/data-mapper/src/main/java/com/iluwatar/datamapper/Student.java b/data-mapper/src/main/java/com/iluwatar/datamapper/Student.java index a2c1007854bf..1691d1233246 100644 --- a/data-mapper/src/main/java/com/iluwatar/datamapper/Student.java +++ b/data-mapper/src/main/java/com/iluwatar/datamapper/Student.java @@ -24,6 +24,7 @@ */ package com.iluwatar.datamapper; +import java.io.Serial; import java.io.Serializable; import lombok.AllArgsConstructor; import lombok.EqualsAndHashCode; @@ -41,6 +42,7 @@ @AllArgsConstructor public final class Student implements Serializable { + @Serial private static final long serialVersionUID = 1L; @EqualsAndHashCode.Include diff --git a/data-mapper/src/main/java/com/iluwatar/datamapper/StudentDataMapperImpl.java b/data-mapper/src/main/java/com/iluwatar/datamapper/StudentDataMapperImpl.java index 9f7d3c9d967a..9da1c8f7d169 100644 --- a/data-mapper/src/main/java/com/iluwatar/datamapper/StudentDataMapperImpl.java +++ b/data-mapper/src/main/java/com/iluwatar/datamapper/StudentDataMapperImpl.java @@ -27,10 +27,12 @@ import java.util.ArrayList; import java.util.List; import java.util.Optional; +import lombok.Getter; /** * Implementation of Actions on Students Data. */ +@Getter public final class StudentDataMapperImpl implements StudentDataMapper { /* Note: Normally this would be in the form of an actual database */ @@ -70,8 +72,4 @@ public void delete(Student studentToBeDeleted) throws DataMapperException { throw new DataMapperException("Student [" + name + "] is not found"); } } - - public List<Student> getStudents() { - return this.students; - } }

diff --git a/data-mapper/src/test/java/com/iluwatar/datamapper/AppTest.java b/data-mapper/src/test/java/com/iluwatar/datamapper/AppTest.java index 1f954ff811c8..f45f6cc3266e 100644 --- a/data-mapper/src/test/java/com/iluwatar/datamapper/AppTest.java +++ b/data-mapper/src/test/java/com/iluwatar/datamapper/AppTest.java @@ -36,7 +36,6 @@ final class AppTest { /** * Issue: Add at least one assertion to this test case. - * * Solution: Inserted assertion to check whether the execution of the main method in {@link App#main(String[])} * throws an exception. */ diff --git a/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java b/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java index e1c3e21edead..9a9866e3bcfc 100644 --- a/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java +++ b/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java @@ -41,7 +41,7 @@ final class StudentTest { * @throws Exception if any execution error during test */ @Test - void testEquality() throws Exception { + void testEquality() { /* Create some students */ final var firstStudent = new Student(1, "Adam", 'A');

val

test

iluwatar

train

mockito/mockito/134_141

mockito/mockito

mockito/mockito/134

mockito/mockito/141

fb455b94118bf03faff3baf665cdb0b8f67d6968

a2e731bb416949b7e2e4ce096b3454bed310e6eb

Argument matcher anyXxx() (i.e. anyString(), anyList()) should not match nulls

This is a bug I'm seeing in 1.10.8 version (older version has the same issue - tested with 1.9.0). Given: ``` java Function<Object, Integer> function = Mockito.mock(Function.class); when(function.apply(Mockito.anyString())).thenReturn(1); Integer result = function.apply(2); ``` Expected behavior: ``` java result == null; ``` Actual behavior: ``` java result == 1; ``` Note that the function is called with an integer (not a string), and still the mocked function return the value which it should return only when a string is passed. The same works when using anyBoolean() or any other methof from any\* family.

diff --git a/src/org/mockito/Matchers.java b/src/org/mockito/Matchers.java index 789d598bb4..a8b71dc79e 100644 --- a/src/org/mockito/Matchers.java +++ b/src/org/mockito/Matchers.java @@ -50,13 +50,6 @@ * This implementation is due static type safety imposed by java compiler. * The consequence is that you cannot use <code>anyObject()</code>, <code>eq()</code> methods outside of verified/stubbed method. * - * <p> - * <b>Warning 2:</b> - * <p> - * The any family methods <b>*don't do any type checks*</b>, those are only here to avoid casting - * in your code. If you want to perform type checks use the {@link #isA(Class)} method. - * This <b>might</b> however change (type checks could be added) in a future major release. - * * <h1>Custom Argument Matchers</h1> * * Use {@link Matchers#argThat} method and pass an instance of hamcrest {@link Matcher}. @@ -107,133 +100,97 @@ public class Matchers { private static final MockingProgress MOCKING_PROGRESS = new ThreadSafeMockingProgress(); /** - * Any <code>boolean</code>, <code>Boolean</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>boolean</code> or non-null <code>Boolean</code> * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>false</code>. */ public static boolean anyBoolean() { - return reportMatcher(Any.ANY).returnFalse(); + return reportMatcher(new InstanceOf(Boolean.class)).returnFalse(); } /** - * Any <code>byte</code>, <code>Byte</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>byte</code> or non-null <code>Byte</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static byte anyByte() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Byte.class)).returnZero(); } /** - * Any <code>char</code>, <code>Character</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>char</code> or non-null <code>Character</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static char anyChar() { - return reportMatcher(Any.ANY).returnChar(); + return reportMatcher(new InstanceOf(Character.class)).returnChar(); } /** - * Any int, Integer or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any int or non-null Integer. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static int anyInt() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Integer.class)).returnZero(); } /** - * Any <code>long</code>, <code>Long</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>long</code> or non-null <code>Long</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static long anyLong() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Long.class)).returnZero(); } /** - * Any <code>float</code>, <code>Float</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>float</code> or non-null <code>Float</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static float anyFloat() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Float.class)).returnZero(); } /** - * Any <code>double</code>, <code>Double</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>double</code> or non-null <code>Double</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static double anyDouble() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Double.class)).returnZero(); } /** - * Any <code>short</code>, <code>Short</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any <code>short</code> or non-null <code>Short</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return <code>0</code>. */ public static short anyShort() { - return reportMatcher(Any.ANY).returnZero(); + return reportMatcher(new InstanceOf(Short.class)).returnZero(); } /** - * Any <code>Object</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Matches anything, including null. * <p> - * Has aliases: {@link #any()} and {@link #any(Class clazz)} + * This is an alias of: {@link #any()} and {@link #any(java.lang.Class)} * <p> * See examples in javadoc for {@link Matchers} class * @@ -271,20 +228,16 @@ public static <T> T anyVararg() { } /** - * Any kind object, not necessary of the given class. - * The class argument is provided only to avoid casting. + * Matches any object, including nulls * <p> - * Sometimes looks better than <code>anyObject()</code> - especially when explicit casting is required + * This method doesn't do type checks with the given parameter, it is only there + * to avoid casting in your code. This might however change (type checks could + * be added) in a future major release. * <p> - * Alias to {@link Matchers#anyObject()} + * See examples in javadoc for {@link Matchers} class * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * This is an alias of: {@link #any()} and {@link #anyObject()} * <p> - * See examples in javadoc for {@link Matchers} class - * - * @param clazz The type to avoid casting * @return <code>null</code>. */ public static <T> T any(Class<T> clazz) { @@ -292,61 +245,51 @@ public static <T> T any(Class<T> clazz) { } /** - * Any object or <code>null</code>. + * Matches anything, including nulls * <p> * Shorter alias to {@link Matchers#anyObject()} * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. - * <p> * See examples in javadoc for {@link Matchers} class - * + * <p> + * This is an alias of: {@link #anyObject()} and {@link #any(java.lang.Class)} + * <p> * @return <code>null</code>. */ public static <T> T any() { - return (T) anyObject(); + return anyObject(); } /** - * Any <code>String</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any non-null <code>String</code> * <p> * See examples in javadoc for {@link Matchers} class * * @return empty String ("") */ public static String anyString() { - return reportMatcher(Any.ANY).returnString(); + return reportMatcher(new InstanceOf(String.class)).returnString(); } /** - * Any <code>List</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any non-null <code>List</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return empty List. */ public static List anyList() { - return reportMatcher(Any.ANY).returnList(); - } + return reportMatcher(new InstanceOf(List.class)).returnList(); + } /** * Generic friendly alias to {@link Matchers#anyList()}. * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. * <p> - * Any <code>List</code> or <code>null</code>. + * Any non-null <code>List</code>. * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * This method doesn't do type checks with the given parameter, it is only there + * to avoid casting in your code. This might however change (type checks could + * be added) in a future major release. * <p> * See examples in javadoc for {@link Matchers} class * @@ -354,33 +297,29 @@ public static List anyList() { * @return empty List. */ public static <T> List<T> anyListOf(Class<T> clazz) { - return (List) reportMatcher(Any.ANY).returnList(); - } + return anyList(); + } /** - * Any <code>Set</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any non-null <code>Set</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return empty Set */ public static Set anySet() { - return reportMatcher(Any.ANY).returnSet(); + return reportMatcher(new InstanceOf(Set.class)).returnSet(); } /** * Generic friendly alias to {@link Matchers#anySet()}. * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. * <p> - * Any <code>Set</code> or <code>null</code> + * Any non-null <code>Set</code>. * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * This method doesn't do type checks with the given parameter, it is only there + * to avoid casting in your code. This might however change (type checks could + * be added) in a future major release. * <p> * See examples in javadoc for {@link Matchers} class * @@ -388,33 +327,29 @@ public static Set anySet() { * @return empty Set */ public static <T> Set<T> anySetOf(Class<T> clazz) { - return (Set) reportMatcher(Any.ANY).returnSet(); + return anySet(); } /** - * Any <code>Map</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any non-null <code>Map</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return empty Map. */ public static Map anyMap() { - return reportMatcher(Any.ANY).returnMap(); + return reportMatcher(new InstanceOf(Map.class)).returnMap(); } /** * Generic friendly alias to {@link Matchers#anyMap()}. * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. * <p> - * Any <code>Map</code> or <code>null</code> + * Any non-null <code>Map</code>. * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * This method doesn't do type checks with the given parameter, it is only there + * to avoid casting in your code. This might however change (type checks could + * be added) in a future major release. * <p> * See examples in javadoc for {@link Matchers} class * @@ -423,33 +358,29 @@ public static Map anyMap() { * @return empty Map. */ public static <K, V> Map<K, V> anyMapOf(Class<K> keyClazz, Class<V> valueClazz) { - return reportMatcher(Any.ANY).returnMap(); + return anyMap(); } /** - * Any <code>Collection</code> or <code>null</code>. - * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * Any non-null <code>Collection</code>. * <p> * See examples in javadoc for {@link Matchers} class * * @return empty Collection. */ public static Collection anyCollection() { - return reportMatcher(Any.ANY).returnList(); + return reportMatcher(new InstanceOf(Collection.class)).returnList(); } /** * Generic friendly alias to {@link Matchers#anyCollection()}. - * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. + * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. * <p> - * Any <code>Collection</code> or <code>null</code>. + * Any non-null <code>Collection</code>. * <p> - * This method <b>*don't do any type checks*</b>, it is only there to avoid casting - * in your code. This might however change (type checks could be added) in a - * future major release. + * This method doesn't do type checks with the given parameter, it is only there + * to avoid casting in your code. This might however change (type checks could + * be added) in a future major release. * <p> * See examples in javadoc for {@link Matchers} class * @@ -457,7 +388,7 @@ public static Collection anyCollection() { * @return empty Collection. */ public static <T> Collection<T> anyCollectionOf(Class<T> clazz) { - return (Collection) reportMatcher(Any.ANY).returnList(); + return anyCollection(); } /** diff --git a/src/org/mockito/internal/matchers/Any.java b/src/org/mockito/internal/matchers/Any.java index 1876b38cf2..28a98f027a 100644 --- a/src/org/mockito/internal/matchers/Any.java +++ b/src/org/mockito/internal/matchers/Any.java @@ -14,7 +14,7 @@ public class Any extends ArgumentMatcher implements Serializable { private static final long serialVersionUID = -4062420125651019029L; - public static final Any ANY = new Any(); + public static final Any ANY = new Any(); private Any() {} diff --git a/version.properties b/version.properties index 0e4d43bdff..c3d41c20f9 100644 --- a/version.properties +++ b/version.properties @@ -1,2 +1,2 @@ -version=1.10.17 +version=2.0.0-beta mockito.testng.version=1.0 \ No newline at end of file

diff --git a/test/org/mockitousage/IMethods.java b/test/org/mockitousage/IMethods.java index 557e7c5e14..8c9a1b3359 100644 --- a/test/org/mockitousage/IMethods.java +++ b/test/org/mockitousage/IMethods.java @@ -219,4 +219,6 @@ public interface IMethods { int toIntPrimitive(Integer i); Integer toIntWrapper(int i); + + String forObject(Object object); } \ No newline at end of file diff --git a/test/org/mockitousage/MethodsImpl.java b/test/org/mockitousage/MethodsImpl.java index 539f612de7..347dfa65f6 100644 --- a/test/org/mockitousage/MethodsImpl.java +++ b/test/org/mockitousage/MethodsImpl.java @@ -418,4 +418,8 @@ public int toIntPrimitive(Integer i) { public Integer toIntWrapper(int i) { return null; } + + public String forObject(Object object) { + return null; + } } diff --git a/test/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java b/test/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java index 32c7b6f605..b5d767fe64 100644 --- a/test/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java +++ b/test/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java @@ -24,24 +24,37 @@ public void setUp() { } @Test - public void shouldAnyXMatchersAcceptNull() { - when(mock.oneArg(anyObject())).thenReturn("0"); - when(mock.oneArg(anyString())).thenReturn("1"); - when(mock.forList(anyList())).thenReturn("2"); - when(mock.forMap(anyMap())).thenReturn("3"); - when(mock.forCollection(anyCollection())).thenReturn("4"); - when(mock.forSet(anySet())).thenReturn("5"); + public void shouldAcceptNullsInAnyMatcher() { + when(mock.oneArg(any())).thenReturn("matched"); + + assertEquals(null, mock.forObject(null)); + } + + @Test + public void shouldAcceptNullsInAnyObjectMatcher() { + when(mock.oneArg(anyObject())).thenReturn("matched"); + + assertEquals(null, mock.forObject(null)); + } + + @Test + public void shouldNotAcceptNullInAnyXMatchers() { + when(mock.oneArg(anyString())).thenReturn("0"); + when(mock.forList(anyList())).thenReturn("1"); + when(mock.forMap(anyMap())).thenReturn("2"); + when(mock.forCollection(anyCollection())).thenReturn("3"); + when(mock.forSet(anySet())).thenReturn("4"); - assertEquals("0", mock.oneArg((Object) null)); - assertEquals("1", mock.oneArg((String) null)); - assertEquals("2", mock.forList(null)); - assertEquals("3", mock.forMap(null)); - assertEquals("4", mock.forCollection(null)); - assertEquals("5", mock.forSet(null)); + assertEquals(null, mock.oneArg((Object) null)); + assertEquals(null, mock.oneArg((String) null)); + assertEquals(null, mock.forList(null)); + assertEquals(null, mock.forMap(null)); + assertEquals(null, mock.forCollection(null)); + assertEquals(null, mock.forSet(null)); } @Test - public void shouldAnyPrimiteWraperMatchersAcceptNull() { + public void shouldNotAcceptNullInAllAnyPrimitiveWrapperMatchers() { when(mock.forInteger(anyInt())).thenReturn("0"); when(mock.forCharacter(anyChar())).thenReturn("1"); when(mock.forShort(anyShort())).thenReturn("2"); @@ -51,13 +64,13 @@ public void shouldAnyPrimiteWraperMatchersAcceptNull() { when(mock.forFloat(anyFloat())).thenReturn("6"); when(mock.forDouble(anyDouble())).thenReturn("7"); - assertEquals("0", mock.forInteger(null)); - assertEquals("1", mock.forCharacter(null)); - assertEquals("2", mock.forShort(null)); - assertEquals("3", mock.forByte(null)); - assertEquals("4", mock.forBoolean(null)); - assertEquals("5", mock.forLong(null)); - assertEquals("6", mock.forFloat(null)); - assertEquals("7", mock.forDouble(null)); + assertEquals(null, mock.forInteger(null)); + assertEquals(null, mock.forCharacter(null)); + assertEquals(null, mock.forShort(null)); + assertEquals(null, mock.forByte(null)); + assertEquals(null, mock.forBoolean(null)); + assertEquals(null, mock.forLong(null)); + assertEquals(null, mock.forFloat(null)); + assertEquals(null, mock.forDouble(null)); } } \ No newline at end of file diff --git a/test/org/mockitousage/matchers/MatchersTest.java b/test/org/mockitousage/matchers/MatchersTest.java index 9835bbd660..971a84c84b 100644 --- a/test/org/mockitousage/matchers/MatchersTest.java +++ b/test/org/mockitousage/matchers/MatchersTest.java @@ -225,15 +225,25 @@ public void compareToMatcher() { @Test public void anyStringMatcher() { - when(mock.oneArg(anyString())).thenReturn("1"); + when(mock.oneArg(anyString())).thenReturn("matched"); - assertEquals("1", mock.oneArg("")); - assertEquals("1", mock.oneArg("any string")); - assertEquals(null, mock.oneArg((Object) null)); + assertEquals("matched", mock.oneArg("")); + assertEquals("matched", mock.oneArg("any string")); + assertEquals(null, mock.oneArg((String) null)); } @Test public void anyMatcher() { + when(mock.forObject(any())).thenReturn("matched"); + + assertEquals("matched", mock.forObject(123)); + assertEquals("matched", mock.forObject("any string")); + assertEquals("matched", mock.forObject("any string")); + assertEquals("matched", mock.forObject((Object) null)); + } + + @Test + public void anyXMatcher() { when(mock.oneArg(anyBoolean())).thenReturn("0"); when(mock.oneArg(anyByte())).thenReturn("1"); when(mock.oneArg(anyChar())).thenReturn("2"); diff --git a/test/org/mockitousage/matchers/NewMatchersTest.java b/test/org/mockitousage/matchers/NewMatchersTest.java index 77874f3a60..e9e8f16e13 100644 --- a/test/org/mockitousage/matchers/NewMatchersTest.java +++ b/test/org/mockitousage/matchers/NewMatchersTest.java @@ -29,41 +29,41 @@ public void setUp() { @Test public void shouldAllowAnyList() { - when(mock.forList(anyList())).thenReturn("x"); + when(mock.forList(anyList())).thenReturn("matched"); - assertEquals("x", mock.forList(null)); - assertEquals("x", mock.forList(Arrays.asList("x", "y"))); - - verify(mock, times(2)).forList(anyList()); + assertEquals("matched", mock.forList(Arrays.asList("x", "y"))); + assertEquals(null, mock.forList(null)); + + verify(mock, times(1)).forList(anyList()); } @Test public void shouldAllowAnyCollection() { - when(mock.forCollection(anyCollection())).thenReturn("x"); + when(mock.forCollection(anyCollection())).thenReturn("matched"); - assertEquals("x", mock.forCollection(null)); - assertEquals("x", mock.forCollection(Arrays.asList("x", "y"))); - - verify(mock, times(2)).forCollection(anyCollection()); + assertEquals("matched", mock.forCollection(Arrays.asList("x", "y"))); + assertEquals(null, mock.forCollection(null)); + + verify(mock, times(1)).forCollection(anyCollection()); } @Test public void shouldAllowAnyMap() { - when(mock.forMap(anyMap())).thenReturn("x"); + when(mock.forMap(anyMap())).thenReturn("matched"); - assertEquals("x", mock.forMap(null)); - assertEquals("x", mock.forMap(new HashMap<String, String>())); - - verify(mock, times(2)).forMap(anyMap()); + assertEquals("matched", mock.forMap(new HashMap<String, String>())); + assertEquals(null, mock.forMap(null)); + + verify(mock, times(1)).forMap(anyMap()); } @Test public void shouldAllowAnySet() { - when(mock.forSet(anySet())).thenReturn("x"); + when(mock.forSet(anySet())).thenReturn("matched"); - assertEquals("x", mock.forSet(null)); - assertEquals("x", mock.forSet(new HashSet<String>())); - - verify(mock, times(2)).forSet(anySet()); + assertEquals("matched", mock.forSet(new HashSet<String>())); + assertEquals(null, mock.forSet(null)); + + verify(mock, times(1)).forSet(anySet()); } } \ No newline at end of file diff --git a/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index 65f6bdbe31..44a074ef5c 100644 --- a/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -239,7 +239,10 @@ public void should_print_method_when_matcher_used() throws Exception { "\n" + "Wanted but not invoked:" + "\n" + - "iMethods.twoArgumentMethod(<any>, 100);"; + "iMethods.twoArgumentMethod(\n" + + " isA(java.lang.Integer),\n" + + " 100\n" + + ");"; assertContains(expectedMessage, actualMessage); } } diff --git a/test/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java b/test/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java index e222c95022..05543dd339 100644 --- a/test/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java +++ b/test/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java @@ -65,12 +65,12 @@ public void shouldShowTheTypeOfTheMismatchingArgumentWhenOutputDescriptionsForIn try { //when - verify(boo).withLongAndInt(eq(100), anyInt()); + verify(boo).withLongAndInt(eq(100), any(Integer.class)); fail(); } catch (ArgumentsAreDifferent e) { //then assertContains("withLongAndInt((Long) 100, 200)", e.getMessage()); - assertContains("withLongAndInt((Integer) 100, <any>)", e.getMessage()); + assertContains("withLongAndInt((Integer) 100, <any>", e.getMessage()); } }

train

train

alexo

train

mockito/mockito/157_158

mockito/mockito

mockito/mockito/157

mockito/mockito/158

fff76563d9e0ed412dc828c53cfdc7d142997a31

d645862386143a8ae7d6bd122d0fcfa71c02e339

Source files should not be put in binary JAR

Source files (`*.java`) should not be put into binary `mockito-core.jar`. It stupefies Idea to show decompiled file even when source jar is available.

diff --git a/build.gradle b/build.gradle index 94ebdaf3cc..3ed8f310c0 100644 --- a/build.gradle +++ b/build.gradle @@ -71,7 +71,7 @@ def licenseFiles = copySpec { jar { baseName = 'mockito-core' - from(sourceSets.main.allSource) + from(sourceSets.main.output) from(zipTree("lib/repackaged/cglib-and-asm-1.0.jar")) { exclude 'META-INF/MANIFEST.MF' }

train

train

szpak

train

mockito/mockito/172_175

mockito/mockito

mockito/mockito/172

mockito/mockito/175

44fbd4985cb7448b727df60df398c1b7705b7602

9943c7c00d1480f3d778c6ca8b990c039d5c533c

Update hamcrest-core to version 1.3

Hi there, It would be nice if mockito-core would depend on hamcrest-core 1.3 instead of 1.1 so that both mockito and junit [latest versions] would depend on the same 3rd party library. Thanks in advance!

diff --git a/build.gradle b/build.gradle index 66145a4d0e..0ec718a1a5 100644 --- a/build.gradle +++ b/build.gradle @@ -61,7 +61,7 @@ tasks.withType(JavaCompile) { //TODO we should remove all dependencies to checked-in jars dependencies { provided "junit:junit:4.10" - compile "org.hamcrest:hamcrest-core:1.1", "org.objenesis:objenesis:2.1" + compile "org.hamcrest:hamcrest-core:1.3", "org.objenesis:objenesis:2.1" compile fileTree('lib/repackaged') { exclude '*.txt'} testCompile fileTree("lib/test") diff --git a/src/org/mockito/internal/matchers/LocalizedMatcher.java b/src/org/mockito/internal/matchers/LocalizedMatcher.java index b19cdf5133..d770103286 100644 --- a/src/org/mockito/internal/matchers/LocalizedMatcher.java +++ b/src/org/mockito/internal/matchers/LocalizedMatcher.java @@ -64,6 +64,10 @@ public void captureFrom(Object argument) { } } + public void describeMismatch(Object argument, Description description) { + actualMatcher.describeMismatch(argument, description); + } + //TODO: refactor other 'delegated interfaces' to use the MatcherDecorator feature public Matcher getActualMatcher() { return actualMatcher;

diff --git a/test/org/mockito/internal/runners/RunnerFactoryTest.java b/test/org/mockito/internal/runners/RunnerFactoryTest.java index 02c7abdd3b..e012bbdeef 100644 --- a/test/org/mockito/internal/runners/RunnerFactoryTest.java +++ b/test/org/mockito/internal/runners/RunnerFactoryTest.java @@ -1,7 +1,7 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ +/* + * Copyright (c) 2007 Mockito contributors + * This program is made available under the terms of the MIT License. + */ package org.mockito.internal.runners; import static org.hamcrest.CoreMatchers.*; @@ -37,7 +37,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit44RunnerImpl.class)); + assertThat(runner, instanceOf(JUnit44RunnerImpl.class)); } @Test @@ -54,7 +54,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit45AndHigherRunnerImpl.class)); + assertThat(runner, instanceOf(JUnit45AndHigherRunnerImpl.class)); } @Test diff --git a/test/org/mockitousage/basicapi/MocksCreationTest.java b/test/org/mockitousage/basicapi/MocksCreationTest.java index 533826a6f4..e2e532de86 100644 --- a/test/org/mockitousage/basicapi/MocksCreationTest.java +++ b/test/org/mockitousage/basicapi/MocksCreationTest.java @@ -16,7 +16,7 @@ import java.util.List; import java.util.Set; -import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.instanceOf; import static org.mockito.Mockito.*; @SuppressWarnings("unchecked") @@ -62,7 +62,7 @@ public void shouldCombineMockNameAndExtraInterfaces() { //then assertContains("great mockie", name); //and - assertThat(mock, is(List.class)); + assertThat(mock, instanceOf(List.class)); } @Test diff --git a/test/org/mockitoutil/ExtraMatchers.java b/test/org/mockitoutil/ExtraMatchers.java index bd0fe349ec..eb3e94bb9a 100644 --- a/test/org/mockitoutil/ExtraMatchers.java +++ b/test/org/mockitoutil/ExtraMatchers.java @@ -133,7 +133,7 @@ public void assertValue(Collection value) { }; } - public static org.hamcrest.Matcher<java.lang.Object> clazz(java.lang.Class<?> type) { + public static <T> org.hamcrest.Matcher<T> clazz(java.lang.Class<T> type) { return CoreMatchers.is(type); }

val

train

ghost

train

mockito/mockito/200_201

mockito/mockito

mockito/mockito/200

mockito/mockito/201

d3fd493288ccbdf1bf54d7d1ea0bb6c96ddc6d57

4a34cbe64cf93f2a275559e3613c5b2f074b235d

ArgumentCaptor.fromClass's return type should match a parameterized type

`ArgumentCaptor.fromClass`'s return type should match a parameterized type. I.e. the expression `ArgumentCaptor.fromClass(Class<S>)` should be of type `ArgumentCaptor<U>` where `S` is a subtype of `U`. For example: ``` ArgumentCaptor<Consumer<String>> captor = ArgumentCaptor.fromClass(Consumer.class) ``` does not type check (i.e. it is a compile time error). It should type check. The reasons that it is desirable for `ArgumentCaptor.fromClass` to allow expressions such as the example above to type check are: 1) `ArgumentCaptor.fromClass` is intended to be a convenience method to allow the user to construct an ArgumentCaptor without casting the returned value. Currently, the user can devise a workaround such as: ``` ArgumentCaptor<? extends Consumer<String>> captor = ArgumentCaptor.fromClass(Consumer.class) ``` This workaround is inconvenient, and so contrary to `ArgumentCaptor.fromClass` being a convenience method. 2) It is inconsistent with `@Captor`, which can be applied to a field with a paramterized type. I.e. ``` @Captor ArgumentCaptor<Consumer<String>> captor ``` type checks.

diff --git a/src/org/mockito/ArgumentCaptor.java b/src/org/mockito/ArgumentCaptor.java index 0efe061cf7..78c41c89f9 100644 --- a/src/org/mockito/ArgumentCaptor.java +++ b/src/org/mockito/ArgumentCaptor.java @@ -65,7 +65,7 @@ public class ArgumentCaptor<T> { HandyReturnValues handyReturnValues = new HandyReturnValues(); private final CapturingMatcher<T> capturingMatcher = new CapturingMatcher<T>(); - private final Class<T> clazz; + private final Class<? extends T> clazz; /** * @deprecated @@ -87,7 +87,7 @@ public ArgumentCaptor() { this.clazz = null; } - ArgumentCaptor(Class<T> clazz) { + private ArgumentCaptor(Class<? extends T> clazz) { this.clazz = clazz; } @@ -163,10 +163,11 @@ public List<T> getAllValues() { * future major release. * * @param clazz Type matching the parameter to be captured. - * @param <T> Type of clazz + * @param <S> Type of clazz + * @param <U> Type of object captured by the newly built ArgumentCaptor * @return A new ArgumentCaptor */ - public static <T> ArgumentCaptor<T> forClass(Class<T> clazz) { - return new ArgumentCaptor<T>(clazz); + public static <U,S extends U> ArgumentCaptor<U> forClass(Class<S> clazz) { + return new ArgumentCaptor<U>(clazz); } } \ No newline at end of file

diff --git a/test/org/mockitousage/matchers/CapturingArgumentsTest.java b/test/org/mockitousage/matchers/CapturingArgumentsTest.java index 44c8d87b50..d833e681e2 100644 --- a/test/org/mockitousage/matchers/CapturingArgumentsTest.java +++ b/test/org/mockitousage/matchers/CapturingArgumentsTest.java @@ -14,6 +14,7 @@ import org.mockitousage.IMethods; import org.mockitoutil.TestBase; +import java.util.ArrayList; import java.util.List; import static org.mockito.Matchers.any; @@ -124,6 +125,18 @@ public void should_allow_assertions_on_captured_null() { verify(emailService).sendEmailTo(argument.capture()); assertEquals(null, argument.getValue()); } + + @Test + public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way() { + //the test passes if this expression compiles + ArgumentCaptor<List<Person>> argument = ArgumentCaptor.forClass(List.class); + } + + @Test + public void should_allow_construction_of_captor_for_a_more_specific_type() { + //the test passes if this expression compiles + ArgumentCaptor<List> argument = ArgumentCaptor.forClass(ArrayList.class); + } @Test public void should_allow_capturing_for_stubbing() {

train

train

bruceeddy

train

mockito/mockito/187_202

mockito/mockito

mockito/mockito/187

mockito/mockito/202

4b5a03d1516778084e669f2f74ffbb9f9fc086f1

85fcbcb773ef8fd48105f18349d289b99591ba76

java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.String

Exception throws on verifyZeroInteractions when using mock with default answer. checked on versions 1.10.5-2.0.5 all ok on 1.9.5

diff --git a/src/org/mockito/exceptions/Reporter.java b/src/org/mockito/exceptions/Reporter.java index 7ae75886c0..e0b1105daf 100644 --- a/src/org/mockito/exceptions/Reporter.java +++ b/src/org/mockito/exceptions/Reporter.java @@ -8,7 +8,13 @@ import org.mockito.exceptions.base.MockitoAssertionError; import org.mockito.exceptions.base.MockitoException; import org.mockito.exceptions.misusing.*; -import org.mockito.exceptions.verification.*; +import org.mockito.exceptions.verification.NeverWantedButInvoked; +import org.mockito.exceptions.verification.NoInteractionsWanted; +import org.mockito.exceptions.verification.SmartNullPointerException; +import org.mockito.exceptions.verification.TooLittleActualInvocations; +import org.mockito.exceptions.verification.TooManyActualInvocations; +import org.mockito.exceptions.verification.VerificationInOrderFailure; +import org.mockito.exceptions.verification.WantedButNotInvoked; import org.mockito.internal.debugging.LocationImpl; import org.mockito.internal.exceptions.MockitoLimitations; import org.mockito.internal.exceptions.VerificationAwareInvocation; @@ -22,6 +28,7 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.invocation.Location; import org.mockito.listeners.InvocationListener; +import org.mockito.mock.MockName; import org.mockito.mock.SerializableMode; import java.lang.reflect.Field; @@ -231,7 +238,7 @@ public void inOrderRequiresFamiliarMock() { public void invalidUseOfMatchers(int expectedMatchersCount, List<LocalizedMatcher> recordedMatchers) { throw new InvalidUseOfMatchersException(join( "Invalid use of argument matchers!", - expectedMatchersCount + " matchers expected, " + recordedMatchers.size()+ " recorded:" + + expectedMatchersCount + " matchers expected, " + recordedMatchers.size() + " recorded:" + locationsOf(recordedMatchers), "", "This exception may occur if matchers are combined with raw values:", @@ -387,7 +394,7 @@ public void tooManyActualInvocationsInOrder(int wantedCount, int actualCount, De private String createTooLittleInvocationsMessage(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, Location lastActualInvocation) { String ending = - (lastActualInvocation != null)? lastActualInvocation + "\n" : "\n"; + (lastActualInvocation != null) ? lastActualInvocation + "\n" : "\n"; String message = join( wanted.toString(), @@ -420,7 +427,7 @@ public void noMoreInteractionsWanted(Invocation undesired, List<VerificationAwar throw new NoInteractionsWanted(join( "No interactions wanted here:", new LocationImpl(), - "But found this interaction on mock '" + undesired.getMock() + "':", + "But found this interaction on mock '" + safelyGetMockName(undesired.getMock()) + "':", undesired.getLocation(), scenario )); @@ -430,7 +437,7 @@ public void noMoreInteractionsWantedInOrder(Invocation undesired) { throw new VerificationInOrderFailure(join( "No interactions wanted here:", new LocationImpl(), - "But found this interaction on mock '" + undesired.getMock() + "':", + "But found this interaction on mock '" + safelyGetMockName(undesired.getMock()) + "':", undesired.getLocation() )); } @@ -489,6 +496,18 @@ public void wrongTypeOfReturnValue(String expectedType, String actualType, Strin )); } + public void wrongTypeReturnedByDefaultAnswer(Object mock, String expectedType, String actualType, String methodName) { + throw new WrongTypeOfReturnValue(join( + "Default answer returned a result with the wrong type:", + actualType + " cannot be returned by " + methodName + "()", + methodName + "() should return " + expectedType, + "", + "The default answer of " + safelyGetMockName(mock) + " that was configured on the mock is probably incorrectly implemented.", + "" + )); + } + + public void wantedAtMostX(int maxNumberOfInvocations, int foundSize) { throw new MockitoAssertionError(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize)); } @@ -641,7 +660,7 @@ public void atMostAndNeverShouldNotBeUsedWithTimeout() { public void fieldInitialisationThrewException(Field field, Throwable details) { throw new MockitoException(join( - "Cannot instantiate @InjectMocks field named '" + field.getName() + "' of type '" + field.getType() + "'.", + "Cannot instantiate @InjectMocks field named '" + field.getName() + "' of type '" + field.getType() + "'.", "You haven't provided the instance at field declaration so I tried to construct the instance.", "However the constructor or the initialization block threw an exception : " + details.getMessage(), ""), details); @@ -664,14 +683,21 @@ public void invocationListenerThrewException(InvocationListener listener, Throwa public void cannotInjectDependency(Field field, Object matchingMock, Exception details) { throw new MockitoException(join( - "Mockito couldn't inject mock dependency '" + new MockUtil().getMockName(matchingMock) + "' on field ", + "Mockito couldn't inject mock dependency '" + safelyGetMockName(matchingMock) + "' on field ", "'" + field + "'", "whose type '" + field.getDeclaringClass().getCanonicalName() + "' was annotated by @InjectMocks in your test.", - "Also I failed because: " + details.getCause().getMessage(), + "Also I failed because: " + exceptionCauseMessageIfAvailable(details), "" ), details); } + private String exceptionCauseMessageIfAvailable(Exception details) { + if (details.getCause() == null) { + return details.getMessage(); + } + return details.getCause().getMessage(); + } + public void mockedTypeIsInconsistentWithDelegatedInstanceType(Class mockedType, Object delegatedInstance) { throw new MockitoException(join( "Mocked type must be the same as the type of your delegated instance.", @@ -686,7 +712,7 @@ public void mockedTypeIsInconsistentWithDelegatedInstanceType(Class mockedType, public void spyAndDelegateAreMutuallyExclusive() { throw new MockitoException(join( "Settings should not define a spy instance and a delegated instance at the same time." - )) ; + )); } public void invalidArgumentRangeAtIdentityAnswerCreationTime() { @@ -699,7 +725,7 @@ public void invalidArgumentRangeAtIdentityAnswerCreationTime() { public int invalidArgumentPositionRangeAtInvocationTime(InvocationOnMock invocation, boolean willReturnLastParameter, int argumentIndex) { throw new MockitoException( join("Invalid argument index for the current invocation of method : ", - " -> " + new MockUtil().getMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()", + " -> " + safelyGetMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()", "", (willReturnLastParameter ? "Last parameter wanted" : @@ -732,7 +758,7 @@ public void wrongTypeOfArgumentToReturn(InvocationOnMock invocation, String expe throw new WrongTypeOfReturnValue(join( "The argument of type '" + actualType.getSimpleName() + "' cannot be returned because the following ", "method should return the type '" + expectedType + "'", - " -> " + new MockUtil().getMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()", + " -> " + safelyGetMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()", "", "The reason for this error can be :", "1. The wanted argument position is incorrect.", @@ -765,28 +791,32 @@ public void serializableWontWorkForObjectsThatDontImplementSerializable(Class cl "" )); } - + public void delegatedMethodHasWrongReturnType(Method mockMethod, Method delegateMethod, Object mock, Object delegate) { - throw new MockitoException(join( - "Methods called on delegated instance must have compatible return types with the mock.", - "When calling: " + mockMethod + " on mock: " + new MockUtil().getMockName(mock), - "return type should be: " + mockMethod.getReturnType().getSimpleName() + ", but was: " + delegateMethod.getReturnType().getSimpleName(), - "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods", - "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")" - )); - } - - public void delegatedMethodDoesNotExistOnDelegate(Method mockMethod, Object mock, Object delegate) { - throw new MockitoException(join( - "Methods called on mock must exist in delegated instance.", - "When calling: " + mockMethod + " on mock: " + new MockUtil().getMockName(mock), - "no such method was found.", - "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods", - "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")" - )); - } + throw new MockitoException(join( + "Methods called on delegated instance must have compatible return types with the mock.", + "When calling: " + mockMethod + " on mock: " + safelyGetMockName(mock), + "return type should be: " + mockMethod.getReturnType().getSimpleName() + ", but was: " + delegateMethod.getReturnType().getSimpleName(), + "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods", + "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")" + )); + } + + public void delegatedMethodDoesNotExistOnDelegate(Method mockMethod, Object mock, Object delegate) { + throw new MockitoException(join( + "Methods called on mock must exist in delegated instance.", + "When calling: " + mockMethod + " on mock: " + safelyGetMockName(mock), + "no such method was found.", + "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods", + "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")" + )); + } public void usingConstructorWithFancySerializable(SerializableMode mode) { throw new MockitoException("Mocks instantiated with constructor cannot be combined with " + mode + " serialization mode."); } + + private MockName safelyGetMockName(Object mock) { + return new MockUtil().getMockName(mock); + } } diff --git a/src/org/mockito/internal/handler/MockHandlerImpl.java b/src/org/mockito/internal/handler/MockHandlerImpl.java index a49c1a98b7..00766a0d0d 100644 --- a/src/org/mockito/internal/handler/MockHandlerImpl.java +++ b/src/org/mockito/internal/handler/MockHandlerImpl.java @@ -10,7 +10,12 @@ import org.mockito.internal.invocation.MatchersBinder; import org.mockito.internal.progress.MockingProgress; import org.mockito.internal.progress.ThreadSafeMockingProgress; -import org.mockito.internal.stubbing.*; +import org.mockito.internal.stubbing.InvocationContainer; +import org.mockito.internal.stubbing.InvocationContainerImpl; +import org.mockito.internal.stubbing.OngoingStubbingImpl; +import org.mockito.internal.stubbing.StubbedInvocationMatcher; +import org.mockito.internal.stubbing.VoidMethodStubbableImpl; +import org.mockito.internal.stubbing.answers.AnswersValidator; import org.mockito.internal.verification.MockAwareVerificationMode; import org.mockito.internal.verification.VerificationDataImpl; import org.mockito.invocation.Invocation; @@ -23,9 +28,8 @@ /** * Invocation handler set on mock objects. - * - * @param <T> - * type of mock object to handle + * + * @param <T> type of mock object to handle */ class MockHandlerImpl<T> implements InternalMockHandler<T> { @@ -45,7 +49,7 @@ public MockHandlerImpl(MockCreationSettings mockSettings) { } public Object handle(Invocation invocation) throws Throwable { - if (invocationContainerImpl.hasAnswersForStubbing()) { + if (invocationContainerImpl.hasAnswersForStubbing()) { // stubbing voids with stubVoid() or doAnswer() style InvocationMatcher invocationMatcher = matchersBinder.bindMatchers( mockingProgress.getArgumentMatcherStorage(), @@ -90,7 +94,8 @@ public Object handle(Invocation invocation) throws Throwable { stubbedInvocation.captureArgumentsFrom(invocation); return stubbedInvocation.answer(invocation); } else { - Object ret = mockSettings.getDefaultAnswer().answer(invocation); + Object ret = mockSettings.getDefaultAnswer().answer(invocation); + new AnswersValidator().validateDefaultAnswerReturnedValue(invocation, ret); // redo setting invocation for potential stubbing in case of partial // mocks / spies. @@ -100,7 +105,7 @@ public Object handle(Invocation invocation) throws Throwable { invocationContainerImpl.resetInvocationForPotentialStubbing(invocationMatcher); return ret; } - } + } public VoidMethodStubbable<T> voidMethodStubbable(T mock) { return new VoidMethodStubbableImpl<T>(mock, invocationContainerImpl); diff --git a/src/org/mockito/internal/invocation/InvocationImpl.java b/src/org/mockito/internal/invocation/InvocationImpl.java index 19193fa165..dc77a57e25 100644 --- a/src/org/mockito/internal/invocation/InvocationImpl.java +++ b/src/org/mockito/internal/invocation/InvocationImpl.java @@ -105,6 +105,10 @@ public Object[] getRawArguments() { return this.rawArguments; } + public Class<?> getRawReturnType() { + return method.getReturnType(); + } + public Object callRealMethod() throws Throwable { if (method.isAbstract()) { new Reporter().cannotCallAbstractRealMethod(); @@ -131,4 +135,4 @@ public boolean isIgnoredForVerification() { public void ignoreForVerification() { isIgnoredForVerification = true; } -} \ No newline at end of file +} diff --git a/src/org/mockito/internal/stubbing/answers/AnswersValidator.java b/src/org/mockito/internal/stubbing/answers/AnswersValidator.java index 57adb3881c..66bbf54c58 100644 --- a/src/org/mockito/internal/stubbing/answers/AnswersValidator.java +++ b/src/org/mockito/internal/stubbing/answers/AnswersValidator.java @@ -11,21 +11,21 @@ public class AnswersValidator { private final Reporter reporter = new Reporter(); - + public void validate(Answer<?> answer, Invocation invocation) { MethodInfo methodInfo = new MethodInfo(invocation); if (answer instanceof ThrowsException) { validateException((ThrowsException) answer, methodInfo); } - + if (answer instanceof Returns) { validateReturnValue((Returns) answer, methodInfo); } - + if (answer instanceof DoesNothing) { validateDoNothing((DoesNothing) answer, methodInfo); } - + if (answer instanceof CallsRealMethods) { validateMockingConcreteClass((CallsRealMethods) answer, methodInfo); } @@ -42,8 +42,8 @@ private void validateReturnArgIdentity(ReturnsArgumentAt returnsArgumentAt, Invo MethodInfo methodInfo = new MethodInfo(invocation); if (!methodInfo.isValidReturnType(returnsArgumentAt.returnedTypeOnSignature(invocation))) { new Reporter().wrongTypeOfArgumentToReturn(invocation, methodInfo.printMethodReturnType(), - returnsArgumentAt.returnedTypeOnSignature(invocation), - returnsArgumentAt.wantedArgumentPosition()); + returnsArgumentAt.returnedTypeOnSignature(invocation), + returnsArgumentAt.wantedArgumentPosition()); } } @@ -64,10 +64,10 @@ private void validateReturnValue(Returns answer, MethodInfo methodInfo) { if (methodInfo.isVoid()) { reporter.cannotStubVoidMethodWithAReturnValue(methodInfo.getMethodName()); } - + if (answer.returnsNull() && methodInfo.returnsPrimitive()) { reporter.wrongTypeOfReturnValue(methodInfo.printMethodReturnType(), "null", methodInfo.getMethodName()); - } + } if (!answer.returnsNull() && !methodInfo.isValidReturnType(answer.getReturnType())) { reporter.wrongTypeOfReturnValue(methodInfo.printMethodReturnType(), answer.printReturnType(), methodInfo.getMethodName()); @@ -79,13 +79,24 @@ private void validateException(ThrowsException answer, MethodInfo methodInfo) { if (throwable == null) { reporter.cannotStubWithNullThrowable(); } - + if (throwable instanceof RuntimeException || throwable instanceof Error) { return; } - + if (!methodInfo.isValidException(throwable)) { reporter.checkedExceptionInvalid(throwable); } } -} \ No newline at end of file + + public void validateDefaultAnswerReturnedValue(Invocation invocation, Object returnedValue) { + MethodInfo methodInfo = new MethodInfo(invocation); + if (returnedValue != null && !methodInfo.isValidReturnType(returnedValue.getClass())) { + reporter.wrongTypeReturnedByDefaultAnswer( + invocation.getMock(), + methodInfo.printMethodReturnType(), + returnedValue.getClass().getSimpleName(), + methodInfo.getMethodName()); + } + } +} diff --git a/src/org/mockito/invocation/Invocation.java b/src/org/mockito/invocation/Invocation.java index 0146697309..7c1bdd5576 100644 --- a/src/org/mockito/invocation/Invocation.java +++ b/src/org/mockito/invocation/Invocation.java @@ -41,6 +41,14 @@ public interface Invocation extends InvocationOnMock, DescribedInvocation { */ Object[] getRawArguments(); + /** + * Returns unprocessed arguments whereas {@link #getArguments()} returns + * arguments already processed (e.g. varargs expended, etc.). + * + * @return unprocessed arguments, exactly as provided to this invocation. + */ + Class getRawReturnType(); + /** * Marks this invocation as verified so that it will not cause verification error at * {@link org.mockito.Mockito#verifyNoMoreInteractions(Object...)}

diff --git a/test/org/mockito/exceptions/ReporterTest.java b/test/org/mockito/exceptions/ReporterTest.java index e006852784..3253ad819d 100644 --- a/test/org/mockito/exceptions/ReporterTest.java +++ b/test/org/mockito/exceptions/ReporterTest.java @@ -6,21 +6,81 @@ package org.mockito.exceptions; import org.junit.Test; +import org.mockito.Mockito; import org.mockito.exceptions.base.MockitoException; +import org.mockito.exceptions.verification.NoInteractionsWanted; import org.mockito.exceptions.verification.TooLittleActualInvocations; +import org.mockito.exceptions.verification.VerificationInOrderFailure; +import org.mockito.internal.exceptions.VerificationAwareInvocation; import org.mockito.internal.invocation.InvocationBuilder; -import org.mockito.internal.reporting.*; +import org.mockito.internal.stubbing.answers.Returns; +import org.mockito.invocation.Invocation; +import org.mockitousage.IMethods; import org.mockitoutil.TestBase; +import java.lang.reflect.Field; +import java.util.Collections; + +import static org.mockito.Mockito.mock; + public class ReporterTest extends TestBase { - @Test(expected=TooLittleActualInvocations.class) - public void shouldLetPassingNullLastActualStackTrace() throws Exception { + @Test(expected = TooLittleActualInvocations.class) + public void should_let_passing_null_last_actual_stack_trace() throws Exception { new Reporter().tooLittleActualInvocations(new org.mockito.internal.reporting.Discrepancy(1, 2), new InvocationBuilder().toInvocation(), null); } - - @Test(expected=MockitoException.class) - public void shouldThrowCorrectExceptionForNullInvocationListener() throws Exception { - new Reporter().invocationListenerDoesNotAcceptNullParameters(); + + @Test(expected = MockitoException.class) + public void should_throw_correct_exception_for_null_invocation_listener() throws Exception { + new Reporter().invocationListenerDoesNotAcceptNullParameters(); + } + + @Test(expected = NoInteractionsWanted.class) + public void can_use_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted() throws Exception { + Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation(); + new Reporter().noMoreInteractionsWanted(invocation_with_bogus_default_answer, Collections.<VerificationAwareInvocation>emptyList()); + } + + @Test(expected = VerificationInOrderFailure.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted_in_order() throws Exception { + Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation(); + new Reporter().noMoreInteractionsWantedInOrder(invocation_with_bogus_default_answer); + } + + @Test(expected = MockitoException.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_invalid_argument_position() throws Exception { + Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation(); + new Reporter().invalidArgumentPositionRangeAtInvocationTime(invocation_with_bogus_default_answer, true, 0); + } + + @Test(expected = MockitoException.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_wrong_argument_to_return() throws Exception { + Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation(); + new Reporter().wrongTypeOfArgumentToReturn(invocation_with_bogus_default_answer, "", String.class, 0); + } + + @Test(expected = MockitoException.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_dont_exists() throws Exception { + Invocation dumb_invocation = new InvocationBuilder().toInvocation(); + IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false)); + new Reporter().delegatedMethodDoesNotExistOnDelegate(dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class); + } + + @Test(expected = MockitoException.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_has_wrong_return_type() throws Exception { + Invocation dumb_invocation = new InvocationBuilder().toInvocation(); + IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false)); + new Reporter().delegatedMethodHasWrongReturnType(dumb_invocation.getMethod(), dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class); } + + @Test(expected = MockitoException.class) + public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_injection_failure() throws Exception { + IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false)); + new Reporter().cannotInjectDependency(someField(), mock_with_bogus_default_answer, new Exception()); + } + + private Field someField() { + return Mockito.class.getDeclaredFields()[0]; + } + } diff --git a/test/org/mockito/internal/handler/MockHandlerImplTest.java b/test/org/mockito/internal/handler/MockHandlerImplTest.java index 8999fb4e55..104c4be6b5 100644 --- a/test/org/mockito/internal/handler/MockHandlerImplTest.java +++ b/test/org/mockito/internal/handler/MockHandlerImplTest.java @@ -8,6 +8,7 @@ import org.junit.Test; import org.mockito.exceptions.base.MockitoException; import org.mockito.exceptions.misusing.InvalidUseOfMatchersException; +import org.mockito.exceptions.misusing.WrongTypeOfReturnValue; import org.mockito.internal.creation.MockSettingsImpl; import org.mockito.internal.invocation.InvocationBuilder; import org.mockito.internal.invocation.InvocationImpl; @@ -16,6 +17,7 @@ import org.mockito.internal.progress.ArgumentMatcherStorage; import org.mockito.internal.stubbing.InvocationContainerImpl; import org.mockito.internal.stubbing.StubbedInvocationMatcher; +import org.mockito.internal.stubbing.answers.Returns; import org.mockito.internal.verification.VerificationModeFactory; import org.mockito.invocation.Invocation; import org.mockito.listeners.InvocationListener; @@ -29,79 +31,88 @@ import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; -@SuppressWarnings({ "unchecked", "serial" }) +@SuppressWarnings({"unchecked", "serial"}) public class MockHandlerImplTest extends TestBase { - private StubbedInvocationMatcher stubbedInvocationMatcher = mock(StubbedInvocationMatcher.class); - private Invocation invocation = mock(InvocationImpl.class); + private StubbedInvocationMatcher stubbedInvocationMatcher = mock(StubbedInvocationMatcher.class); + private Invocation invocation = mock(InvocationImpl.class); - @Test - public void shouldRemoveVerificationModeEvenWhenInvalidMatchers() throws Throwable { - // given - Invocation invocation = new InvocationBuilder().toInvocation(); - @SuppressWarnings("rawtypes") + @Test + public void should_remove_verification_mode_even_when_invalid_matchers() throws Throwable { + // given + Invocation invocation = new InvocationBuilder().toInvocation(); + @SuppressWarnings("rawtypes") MockHandlerImpl<?> handler = new MockHandlerImpl(new MockSettingsImpl()); - handler.mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce()); - handler.matchersBinder = new MatchersBinder() { - public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) { - throw new InvalidUseOfMatchersException(); - } - }; - - try { - // when - handler.handle(invocation); - - // then - fail(); - } catch (InvalidUseOfMatchersException e) { - } - - assertNull(handler.mockingProgress.pullVerificationMode()); - } - - - - - @Test(expected = MockitoException.class) - public void shouldThrowMockitoExceptionWhenInvocationHandlerThrowsAnything() throws Throwable { - // given - InvocationListener throwingListener = mock(InvocationListener.class); - doThrow(new Throwable()).when(throwingListener).reportInvocation(any(MethodInvocationReport.class)); - MockHandlerImpl<?> handler = createCorrectlyStubbedHandler(throwingListener); - - // when - handler.handle(invocation); - } - - - - private MockHandlerImpl<?> createCorrectlyStubbedHandler(InvocationListener throwingListener) { - MockHandlerImpl<?> handler = createHandlerWithListeners(throwingListener); - stubOrdinaryInvocationWithGivenReturnValue(handler); - return handler; - } - - private void stubOrdinaryInvocationWithGivenReturnValue(MockHandlerImpl<?> handler) { - stubOrdinaryInvocationWithInvocationMatcher(handler, stubbedInvocationMatcher); - } - - - - private void stubOrdinaryInvocationWithInvocationMatcher(MockHandlerImpl<?> handler, StubbedInvocationMatcher value) { - handler.invocationContainerImpl = mock(InvocationContainerImpl.class); - given(handler.invocationContainerImpl.findAnswerFor(any(InvocationImpl.class))).willReturn(value); - } - - - - - private MockHandlerImpl<?> createHandlerWithListeners(InvocationListener... listener) { - @SuppressWarnings("rawtypes") + handler.mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce()); + handler.matchersBinder = new MatchersBinder() { + public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) { + throw new InvalidUseOfMatchersException(); + } + }; + + try { + // when + handler.handle(invocation); + + // then + fail(); + } catch (InvalidUseOfMatchersException ignored) { + } + + assertNull(handler.mockingProgress.pullVerificationMode()); + } + + + @Test(expected = MockitoException.class) + public void should_throw_mockito_exception_when_invocation_handler_throws_anything() throws Throwable { + // given + InvocationListener throwingListener = mock(InvocationListener.class); + doThrow(new Throwable()).when(throwingListener).reportInvocation(any(MethodInvocationReport.class)); + MockHandlerImpl<?> handler = create_correctly_stubbed_handler(throwingListener); + + // when + handler.handle(invocation); + } + + @Test(expected = WrongTypeOfReturnValue.class) + public void should_report_bogus_default_answer() throws Throwable { + MockSettingsImpl mockSettings = mock(MockSettingsImpl.class); + MockHandlerImpl<?> handler = new MockHandlerImpl(mockSettings); + given(mockSettings.getDefaultAnswer()).willReturn(new Returns(AWrongType.WRONG_TYPE)); + + @SuppressWarnings("unused") // otherwise cast is not done + String there_should_not_be_a_CCE_here = (String) handler.handle( + new InvocationBuilder().method(Object.class.getDeclaredMethod("toString")).toInvocation() + ); + } + + private MockHandlerImpl<?> create_correctly_stubbed_handler(InvocationListener throwingListener) { + MockHandlerImpl<?> handler = create_handler_with_listeners(throwingListener); + stub_ordinary_invocation_with_given_return_value(handler); + return handler; + } + + private void stub_ordinary_invocation_with_given_return_value(MockHandlerImpl<?> handler) { + stub_ordinary_invocation_with_invocation_matcher(handler, stubbedInvocationMatcher); + } + + + private void stub_ordinary_invocation_with_invocation_matcher(MockHandlerImpl<?> handler, StubbedInvocationMatcher value) { + handler.invocationContainerImpl = mock(InvocationContainerImpl.class); + given(handler.invocationContainerImpl.findAnswerFor(any(InvocationImpl.class))).willReturn(value); + } + + + private MockHandlerImpl<?> create_handler_with_listeners(InvocationListener... listener) { + @SuppressWarnings("rawtypes") MockHandlerImpl<?> handler = new MockHandlerImpl(mock(MockSettingsImpl.class)); - handler.matchersBinder = mock(MatchersBinder.class); - given(handler.getMockSettings().getInvocationListeners()).willReturn(Arrays.asList(listener)); - return handler; - } + handler.matchersBinder = mock(MatchersBinder.class); + given(handler.getMockSettings().getInvocationListeners()).willReturn(Arrays.asList(listener)); + return handler; + } + + private static class AWrongType { + public static final AWrongType WRONG_TYPE = new AWrongType(); + } } diff --git a/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java b/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java index 914535fbb8..04b5917575 100644 --- a/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java +++ b/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java @@ -1,7 +1,7 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ +/* + * Copyright (c) 2007 Mockito contributors + * This program is made available under the terms of the MIT License. + */ package org.mockito.internal.stubbing.answers; import org.junit.Test; @@ -30,7 +30,7 @@ public void should_validate_null_throwable() throws Throwable { try { validator.validate(new ThrowsException(null), new InvocationBuilder().toInvocation()); fail(); - } catch (MockitoException e) {} + } catch (MockitoException expected) {} } @Test @@ -42,28 +42,28 @@ public void should_pass_proper_checked_exception() throws Throwable { public void should_fail_invalid_checked_exception() throws Throwable { validator.validate(new ThrowsException(new IOException()), invocation); } - + @Test public void should_pass_RuntimeExceptions() throws Throwable { validator.validate(new ThrowsException(new Error()), invocation); validator.validate(new ThrowsException(new RuntimeException()), invocation); } - + @Test(expected = MockitoException.class) public void should_fail_when_return_Value_is_set_for_void_method() throws Throwable { validator.validate(new Returns("one"), new InvocationBuilder().method("voidMethod").toInvocation()); } - + @Test(expected = MockitoException.class) public void should_fail_when_non_void_method_does_nothing() throws Throwable { validator.validate(new DoesNothing(), new InvocationBuilder().simpleMethod().toInvocation()); } - + @Test public void should_allow_void_return_for_void_method() throws Throwable { validator.validate(new DoesNothing(), new InvocationBuilder().method("voidMethod").toInvocation()); } - + @Test public void should_allow_correct_type_of_return_value() throws Throwable { validator.validate(new Returns("one"), new InvocationBuilder().simpleMethod().toInvocation()); @@ -75,12 +75,12 @@ public void should_allow_correct_type_of_return_value() throws Throwable { validator.validate(new Returns(null), new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation()); validator.validate(new Returns(1), new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation()); } - + @Test(expected = MockitoException.class) public void should_fail_on_return_type_mismatch() throws Throwable { validator.validate(new Returns("String"), new InvocationBuilder().method("booleanReturningMethod").toInvocation()); } - + @Test(expected = MockitoException.class) public void should_fail_on_wrong_primitive() throws Throwable { validator.validate(new Returns(1), new InvocationBuilder().method("doubleReturningMethod").toInvocation()); @@ -90,7 +90,7 @@ public void should_fail_on_wrong_primitive() throws Throwable { public void should_fail_on_null_with_primitive() throws Throwable { validator.validate(new Returns(null), new InvocationBuilder().method("booleanReturningMethod").toInvocation()); } - + @Test public void should_fail_when_calling_real_method_on_interface() throws Throwable { //given @@ -100,9 +100,9 @@ public void should_fail_when_calling_real_method_on_interface() throws Throwable validator.validate(new CallsRealMethods(), invocationOnInterface); //then fail(); - } catch (MockitoException e) {} + } catch (MockitoException expected) {} } - + @Test public void should_be_OK_when_calling_real_method_on_concrete_class() throws Throwable { //given @@ -194,4 +194,31 @@ public void should_fail_if_argument_type_of_signature_is_incompatible_with_retur } } -} \ No newline at end of file + @Test + public void should_fail_if_returned_value_of_answer_is_incompatible_with_return_type() throws Throwable { + try { + validator.validateDefaultAnswerReturnedValue( + new InvocationBuilder().method("toString").toInvocation(), + AWrongType.WRONG_TYPE + ); + fail(); + } catch (WrongTypeOfReturnValue e) { + assertThat(e.getMessage()) + .containsIgnoringCase("Default answer returned a result with the wrong type") + .containsIgnoringCase("AWrongType cannot be returned by toString()") + .containsIgnoringCase("toString() should return String"); + } + } + + @Test + public void should_not_fail_if_returned_value_of_answer_is_null() throws Throwable { + validator.validateDefaultAnswerReturnedValue( + new InvocationBuilder().method("toString").toInvocation(), + null + ); + } + + private static class AWrongType { + public static final AWrongType WRONG_TYPE = new AWrongType(); + } +} diff --git a/test/org/mockito/internal/verification/NoMoreInteractionsTest.java b/test/org/mockito/internal/verification/NoMoreInteractionsTest.java index 4b52575d6e..e8c9303075 100644 --- a/test/org/mockito/internal/verification/NoMoreInteractionsTest.java +++ b/test/org/mockito/internal/verification/NoMoreInteractionsTest.java @@ -1,35 +1,37 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ +/* + * Copyright (c) 2007 Mockito contributors + * This program is made available under the terms of the MIT License. + */ package org.mockito.internal.verification; -import static java.util.Arrays.*; - -import org.fest.assertions.Assertions; +import org.fest.assertions.Assertions; import org.junit.Test; -import org.mockito.exceptions.verification.NoInteractionsWanted; +import org.mockito.exceptions.verification.NoInteractionsWanted; import org.mockito.exceptions.verification.VerificationInOrderFailure; -import org.mockito.internal.creation.MockSettingsImpl; +import org.mockito.internal.creation.MockSettingsImpl; import org.mockito.internal.invocation.InvocationBuilder; -import org.mockito.internal.invocation.InvocationMatcher; -import org.mockito.internal.progress.ThreadSafeMockingProgress; -import org.mockito.internal.stubbing.InvocationContainerImpl; +import org.mockito.internal.invocation.InvocationMatcher; +import org.mockito.internal.progress.ThreadSafeMockingProgress; +import org.mockito.internal.stubbing.InvocationContainerImpl; import org.mockito.internal.verification.api.VerificationDataInOrderImpl; import org.mockito.invocation.Invocation; +import org.mockitousage.IMethods; import org.mockitoutil.TestBase; +import static java.util.Arrays.asList; +import static org.mockito.Mockito.mock; + public class NoMoreInteractionsTest extends TestBase { InOrderContextImpl context = new InOrderContextImpl(); - + @Test public void shouldVerifyInOrder() { //given NoMoreInteractions n = new NoMoreInteractions(); Invocation i = new InvocationBuilder().toInvocation(); assertFalse(context.isVerified(i)); - + try { //when n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null)); @@ -37,7 +39,7 @@ public void shouldVerifyInOrder() { fail(); } catch(VerificationInOrderFailure e) {} } - + @Test public void shouldVerifyInOrderAndPass() { //given @@ -45,12 +47,12 @@ public void shouldVerifyInOrderAndPass() { Invocation i = new InvocationBuilder().toInvocation(); context.markVerified(i); assertTrue(context.isVerified(i)); - + //when n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null)); //then no exception is thrown } - + @Test public void shouldVerifyInOrderMultipleInvoctions() { //given @@ -77,43 +79,43 @@ public void shouldVerifyInOrderMultipleInvoctionsAndThrow() { n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i, i2), null)); fail(); } catch (VerificationInOrderFailure e) {} - } - - @Test - public void noMoreInteractionsExceptionMessageShouldDescribeMock() { - //given - NoMoreInteractions n = new NoMoreInteractions(); - String mock = "a mock"; - InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher(); - - InvocationContainerImpl invocations = - new InvocationContainerImpl(new ThreadSafeMockingProgress(), new MockSettingsImpl()); - invocations.setInvocationForPotentialStubbing(i); - - try { - //when - n.verify(new VerificationDataImpl(invocations, null)); - //then - fail(); - } catch (NoInteractionsWanted e) { - Assertions.assertThat(e.toString()).contains(mock.toString()); - } - } - - @Test - public void noMoreInteractionsInOrderExceptionMessageShouldDescribeMock() { - //given - NoMoreInteractions n = new NoMoreInteractions(); - String mock = "a mock"; - Invocation i = new InvocationBuilder().mock(mock).toInvocation(); - - try { - //when - n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null)); - //then - fail(); - } catch (VerificationInOrderFailure e) { - Assertions.assertThat(e.toString()).contains(mock.toString()); - } } -} \ No newline at end of file + + @Test + public void noMoreInteractionsExceptionMessageShouldDescribeMock() { + //given + NoMoreInteractions n = new NoMoreInteractions(); + IMethods mock = mock(IMethods.class, "a mock"); + InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher(); + + InvocationContainerImpl invocations = + new InvocationContainerImpl(new ThreadSafeMockingProgress(), new MockSettingsImpl()); + invocations.setInvocationForPotentialStubbing(i); + + try { + //when + n.verify(new VerificationDataImpl(invocations, null)); + //then + fail(); + } catch (NoInteractionsWanted e) { + Assertions.assertThat(e.toString()).contains(mock.toString()); + } + } + + @Test + public void noMoreInteractionsInOrderExceptionMessageShouldDescribeMock() { + //given + NoMoreInteractions n = new NoMoreInteractions(); + IMethods mock = mock(IMethods.class, "a mock"); + Invocation i = new InvocationBuilder().mock(mock).toInvocation(); + + try { + //when + n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null)); + //then + fail(); + } catch (VerificationInOrderFailure e) { + Assertions.assertThat(e.toString()).contains(mock.toString()); + } + } +} diff --git a/test/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java b/test/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java new file mode 100644 index 0000000000..6b6cc85395 --- /dev/null +++ b/test/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java @@ -0,0 +1,38 @@ +package org.mockitousage.bugs; + +import org.junit.Test; +import org.mockito.exceptions.misusing.WrongTypeOfReturnValue; +import org.mockito.exceptions.verification.NoInteractionsWanted; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyZeroInteractions; + +public class ClassCastExOnVerifyZeroInteractionsTest { + public interface TestMock { + boolean m1(); + } + + @Test(expected = NoInteractionsWanted.class) + public void should_not_throw_ClassCastException_when_mock_verification_fails() { + TestMock test = mock(TestMock.class, new Answer() { + public Object answer(InvocationOnMock invocation) throws Throwable { + return false; + } + }); + test.m1(); + verifyZeroInteractions(test); + } + + @Test(expected = WrongTypeOfReturnValue.class) + public void should_report_bogus_default_answer() throws Exception { + TestMock test = mock(TestMock.class, new Answer() { + public Object answer(InvocationOnMock invocation) throws Throwable { + return false; + } + }); + + test.toString(); + } +} diff --git a/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index 44a074ef5c..f30540edbf 100644 --- a/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/test/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -33,7 +33,7 @@ public class DescriptiveMessagesWhenVerificationFailsTest extends TestBase { @Before public void setup() { - mock = Mockito.mock(IMethods.class); + mock = Mockito.mock(IMethods.class, "iMethods"); } @Test @@ -85,8 +85,8 @@ public void should_print_actual_and_wanted_in_line() { "iMethods.varargs(1, 1000);"; assertContains(wanted, e.getMessage()); - - String actual = + + String actual = "\n" + "Actual invocation has different arguments:" + "\n" + @@ -95,7 +95,7 @@ public void should_print_actual_and_wanted_in_line() { assertContains(actual, e.getMessage()); } } - + @Test public void should_print_actual_and_wanted_in_multiple_lines() { mock.varargs("this is very long string", "this is another very long string"); @@ -296,11 +296,11 @@ public void should_print_null_arguments() throws Exception { assertContains("simpleMethod(null, null);", e.getMessage()); } } - + @Test public void should_say_never_wanted_but_invoked() throws Exception { mock.simpleMethod(1); - + verify(mock, never()).simpleMethod(2); try { verify(mock, never()).simpleMethod(1); @@ -310,12 +310,12 @@ public void should_say_never_wanted_but_invoked() throws Exception { assertContains("But invoked here:", e.getMessage()); } } - + @Test public void should_show_right_actual_method() throws Exception { mock.simpleMethod(9191); mock.simpleMethod("foo"); - + try { verify(mock).simpleMethod("bar"); fail(); @@ -326,11 +326,11 @@ public void should_show_right_actual_method() throws Exception { } @Mock private IMethods iHavefunkyName; - + @Test public void should_print_field_name_when_annotations_used() throws Exception { iHavefunkyName.simpleMethod(10); - + try { verify(iHavefunkyName).simpleMethod(20); fail(); @@ -339,12 +339,12 @@ public void should_print_field_name_when_annotations_used() throws Exception { assertContains("iHavefunkyName.simpleMethod(10)", e.getMessage()); } } - + @Test public void should_print_interactions_on_mock_when_ordinary_verification_fail() throws Exception { mock.otherMethod(); mock.booleanReturningMethod(); - + try { verify(mock).simpleMethod(); fail(); @@ -353,8 +353,8 @@ public void should_print_interactions_on_mock_when_ordinary_verification_fail() } } - @Mock private IMethods veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock; - + @Mock private IMethods veeeeeeeeeeeeeeeeeeeeeeeerylongNameMock; + @Test public void should_never_break_method_string_when_no_args_in_method() throws Exception { try { @@ -430,5 +430,4 @@ public void test2() { public interface AnInterface { void foo(int i); } - -} \ No newline at end of file +}

train

train

mktitov

train

mockito/mockito/197_207

mockito/mockito

mockito/mockito/197

mockito/mockito/207

d30450fa1172d79cc051b2fe8064744c2ac7a003

45aa5bf2c266268d209aabf17053e975e2634da1

Mockito.after() method accepts negative timeperiods and subsequent verifications always pass

e.g. ``` Runnable runnable = Mockito.mock(Runnable.class); Mockito.verify(runnable, Mockito.never()).run(); // passes as expected Mockito.verify(runnable, Mockito.after(1000).never()).run(); // passes as expected Mockito.verify(runnable, Mockito.after(-1000).atLeastOnce()).run(); // passes incorrectly ```

diff --git a/src/org/mockito/exceptions/Reporter.java b/src/org/mockito/exceptions/Reporter.java index e0b1105daf..6e0b3bd157 100644 --- a/src/org/mockito/exceptions/Reporter.java +++ b/src/org/mockito/exceptions/Reporter.java @@ -816,6 +816,15 @@ public void usingConstructorWithFancySerializable(SerializableMode mode) { throw new MockitoException("Mocks instantiated with constructor cannot be combined with " + mode + " serialization mode."); } + public void cannotCreateTimerWithNegativeDurationTime(long durationMillis) { + throw new FriendlyReminderException(join("", + "Don't panic! I'm just a friendly reminder!", + "It is impossible for time to go backward, therefore...", + "You cannot put negative value of duration: (" + durationMillis + ")", + "as argument of timer methods (after(), timeout())", + "")); + } + private MockName safelyGetMockName(Object mock) { return new MockUtil().getMockName(mock); } diff --git a/src/org/mockito/internal/util/Timer.java b/src/org/mockito/internal/util/Timer.java index b71e4fdd8f..9f4829749f 100644 --- a/src/org/mockito/internal/util/Timer.java +++ b/src/org/mockito/internal/util/Timer.java @@ -1,11 +1,14 @@ package org.mockito.internal.util; +import org.mockito.exceptions.Reporter; + public class Timer { private final long durationMillis; private long startTime = -1; public Timer(long durationMillis) { + validateInput(durationMillis); this.durationMillis = durationMillis; } @@ -23,4 +26,14 @@ public boolean isCounting() { public void start() { startTime = System.currentTimeMillis(); } + + private void validateInput(long durationMillis) { + if (durationMillis < 0) { + new Reporter().cannotCreateTimerWithNegativeDurationTime(durationMillis); + } + } + + public long duration() { + return durationMillis; + } } diff --git a/src/org/mockito/internal/verification/VerificationOverTimeImpl.java b/src/org/mockito/internal/verification/VerificationOverTimeImpl.java index 4ea2463adc..e719cb402b 100644 --- a/src/org/mockito/internal/verification/VerificationOverTimeImpl.java +++ b/src/org/mockito/internal/verification/VerificationOverTimeImpl.java @@ -17,7 +17,6 @@ public class VerificationOverTimeImpl implements VerificationMode { private final long pollingPeriodMillis; - private final long durationMillis; private final VerificationMode delegate; private final boolean returnOnSuccess; private final Timer timer; @@ -34,14 +33,13 @@ public class VerificationOverTimeImpl implements VerificationMode { * {@link org.mockito.verification.VerificationAfterDelay}). */ public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, VerificationMode delegate, boolean returnOnSuccess) { - this(pollingPeriodMillis, durationMillis, delegate, returnOnSuccess, new Timer(durationMillis)); + this(pollingPeriodMillis, delegate, returnOnSuccess, new Timer(durationMillis)); } /** * Create this verification mode, to be used to verify invocation ongoing data later. * * @param pollingPeriodMillis The frequency to poll delegate.verify(), to check whether the delegate has been satisfied - * @param durationMillis The max time to wait (in millis) for the delegate verification mode to be satisfied * @param delegate The verification mode to delegate overall success or failure to * @param returnOnSuccess Whether to immediately return successfully once the delegate is satisfied (as in * {@link org.mockito.verification.VerificationWithTimeout}, or to only return once @@ -49,9 +47,8 @@ public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, V * {@link org.mockito.verification.VerificationAfterDelay}). * @param timer Checker of whether the duration of the verification is still acceptable */ - public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, VerificationMode delegate, boolean returnOnSuccess, Timer timer) { + public VerificationOverTimeImpl(long pollingPeriodMillis, VerificationMode delegate, boolean returnOnSuccess, Timer timer) { this.pollingPeriodMillis = pollingPeriodMillis; - this.durationMillis = durationMillis; this.delegate = delegate; this.returnOnSuccess = returnOnSuccess; this.timer = timer; @@ -111,24 +108,15 @@ protected boolean canRecoverFromFailure(VerificationMode verificationMode) { return !(verificationMode instanceof AtMost || verificationMode instanceof NoMoreInteractions); } + public VerificationOverTimeImpl copyWithVerificationMode(VerificationMode verificationMode) { + return new VerificationOverTimeImpl(pollingPeriodMillis, timer.duration(), verificationMode, returnOnSuccess); + } + private void sleep(long sleep) { try { Thread.sleep(sleep); } catch (InterruptedException ie) { - // oups. not much luck. + throw new RuntimeException("Thread sleep has been interrupted", ie); } } - - public long getPollingPeriod() { - return pollingPeriodMillis; - } - - public long getDuration() { - return durationMillis; - } - - public VerificationMode getDelegate() { - return delegate; - } - } diff --git a/src/org/mockito/verification/After.java b/src/org/mockito/verification/After.java index 07d312232a..8d203581b7 100644 --- a/src/org/mockito/verification/After.java +++ b/src/org/mockito/verification/After.java @@ -20,13 +20,17 @@ public After(long delayMillis, VerificationMode verificationMode) { this(10, delayMillis, verificationMode); } - public After(long pollingPeriod, long delayMillis, VerificationMode verificationMode) { - super(new VerificationOverTimeImpl(pollingPeriod, delayMillis, verificationMode, false)); + After(long pollingPeriod, long delayMillis, VerificationMode verificationMode) { + this(new VerificationOverTimeImpl(pollingPeriod, delayMillis, verificationMode, false)); } - + + After(VerificationOverTimeImpl verificationOverTime) { + super(verificationOverTime); + } + @Override protected VerificationMode copySelfWithNewVerificationMode(VerificationMode verificationMode) { - return new After(wrappedVerification.getPollingPeriod(), wrappedVerification.getDuration(), verificationMode); + return new After(wrappedVerification.copyWithVerificationMode(verificationMode)); } } diff --git a/src/org/mockito/verification/Timeout.java b/src/org/mockito/verification/Timeout.java index d8e87ba448..9cfcdad69b 100644 --- a/src/org/mockito/verification/Timeout.java +++ b/src/org/mockito/verification/Timeout.java @@ -29,21 +29,25 @@ public Timeout(long millis, VerificationMode delegate) { * See the javadoc for {@link VerificationWithTimeout} */ Timeout(long pollingPeriodMillis, long millis, VerificationMode delegate) { - super(new VerificationOverTimeImpl(pollingPeriodMillis, millis, delegate, true)); + this(new VerificationOverTimeImpl(pollingPeriodMillis, millis, delegate, true)); } /** * See the javadoc for {@link VerificationWithTimeout} */ - Timeout(long pollingPeriodMillis, long millis, VerificationMode delegate, Timer timer) { - super(new VerificationOverTimeImpl(pollingPeriodMillis, millis, delegate, true, timer)); + Timeout(long pollingPeriodMillis, VerificationMode delegate, Timer timer) { + this(new VerificationOverTimeImpl(pollingPeriodMillis, delegate, true, timer)); } - + + Timeout(VerificationOverTimeImpl verificationOverTime) { + super(verificationOverTime); + } + @Override protected VerificationMode copySelfWithNewVerificationMode(VerificationMode newVerificationMode) { - return new Timeout(wrappedVerification.getPollingPeriod(), wrappedVerification.getDuration(), newVerificationMode); + return new Timeout(wrappedVerification.copyWithVerificationMode(newVerificationMode)); } - + public VerificationMode atMost(int maxNumberOfInvocations) { new Reporter().atMostAndNeverShouldNotBeUsedWithTimeout(); return null; @@ -53,5 +57,4 @@ public VerificationMode never() { new Reporter().atMostAndNeverShouldNotBeUsedWithTimeout(); return null; } - } \ No newline at end of file

diff --git a/test/org/mockito/internal/util/TimerTest.java b/test/org/mockito/internal/util/TimerTest.java index 5e5f0f7841..e1156688c1 100644 --- a/test/org/mockito/internal/util/TimerTest.java +++ b/test/org/mockito/internal/util/TimerTest.java @@ -1,6 +1,8 @@ package org.mockito.internal.util; +import org.junit.Assert; import org.junit.Test; +import org.mockito.exceptions.misusing.FriendlyReminderException; import org.mockitoutil.TestBase; import static org.hamcrest.CoreMatchers.is; @@ -15,22 +17,35 @@ public void should_return_true_if_task_is_in_acceptable_time_bounds() { //when timer.start(); - boolean stillCounting = timer.isCounting(); //then - assertThat(stillCounting, is(true)); + assertThat(timer.isCounting(), is(true)); } @Test - public void should_return_false_if_task_is_outside_the_acceptable_time_bounds() { + public void should_return_false_when_time_run_out() throws Exception { //given - Timer timer = new Timer(-1); + Timer timer = new Timer(0); timer.start(); //when - boolean stillCounting = timer.isCounting(); + oneMillisecondPasses(); //then assertThat(timer.isCounting(), is(false)); } + + @Test + public void should_throw_friendly_reminder_exception_when_duration_is_negative() { + try { + new Timer(-1); + Assert.fail("It is forbidden to create timer with negative value of timer's duration."); + } catch (FriendlyReminderException e) { + Assert.assertTrue(true); + } + } + + private void oneMillisecondPasses() throws InterruptedException { + Thread.sleep(1); + } } diff --git a/test/org/mockito/verification/NegativeDurationTest.java b/test/org/mockito/verification/NegativeDurationTest.java new file mode 100644 index 0000000000..fbb2480342 --- /dev/null +++ b/test/org/mockito/verification/NegativeDurationTest.java @@ -0,0 +1,29 @@ +package org.mockito.verification; + +import org.junit.Assert; +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.exceptions.misusing.FriendlyReminderException; + +public class NegativeDurationTest { + + @Test + public void should_throw_exception_when_duration_is_negative_for_timeout_method() { + try { + Mockito.timeout(-1); + Assert.fail("It is forbidden to invoke Mockito.timeout() with negative value."); + } catch (FriendlyReminderException e) { + Assert.assertTrue(true); + } + } + + @Test + public void should_throw_exception_when_duration_is_negative_for_after_method() { + try { + Mockito.after(-1); + Assert.fail("It is forbidden to invoke Mockito.after() with negative value."); + } catch (FriendlyReminderException e) { + Assert.assertTrue(true); + } + } +} diff --git a/test/org/mockito/verification/TimeoutTest.java b/test/org/mockito/verification/TimeoutTest.java index ecd1b63ad8..1272ac0e99 100644 --- a/test/org/mockito/verification/TimeoutTest.java +++ b/test/org/mockito/verification/TimeoutTest.java @@ -9,9 +9,6 @@ import org.mockito.Mock; import org.mockito.exceptions.base.MockitoAssertionError; import org.mockito.internal.util.Timer; -import org.mockito.internal.verification.AtLeast; -import org.mockito.internal.verification.Only; -import org.mockito.internal.verification.Times; import org.mockito.internal.verification.VerificationDataImpl; import org.mockitoutil.TestBase; @@ -27,7 +24,7 @@ public class TimeoutTest extends TestBase { @Test public void should_pass_when_verification_passes() { - Timeout t = new Timeout(1, 3, mode, timer); + Timeout t = new Timeout(1, mode, timer); when(timer.isCounting()).thenReturn(true); doNothing().when(mode).verify(data); @@ -41,7 +38,7 @@ public void should_pass_when_verification_passes() { @Test public void should_fail_because_verification_fails() { - Timeout t = new Timeout(1, 2, mode, timer); + Timeout t = new Timeout(1, mode, timer); when(timer.isCounting()).thenReturn(true, true, true, false); doThrow(error). @@ -59,7 +56,7 @@ public void should_fail_because_verification_fails() { @Test public void should_pass_even_if_first_verification_fails() { - Timeout t = new Timeout(1, 5, mode, timer); + Timeout t = new Timeout(1, mode, timer); when(timer.isCounting()).thenReturn(true, true, true, false); doThrow(error). @@ -73,7 +70,7 @@ public void should_pass_even_if_first_verification_fails() { @Test public void should_try_to_verify_correct_number_of_times() { - Timeout t = new Timeout(10, 50, mode, timer); + Timeout t = new Timeout(10, mode, timer); doThrow(error).when(mode).verify(data); when(timer.isCounting()).thenReturn(true, true, true, true, true, false); @@ -85,21 +82,5 @@ public void should_try_to_verify_correct_number_of_times() { verify(mode, times(5)).verify(data); } - - @Test - public void should_create_correctly_configured_timeout() { - Timeout t = new Timeout(25, 50, mode, timer); - - assertTimeoutCorrectlyConfigured(t.atLeastOnce(), Timeout.class, 50, 25, AtLeast.class); - assertTimeoutCorrectlyConfigured(t.atLeast(5), Timeout.class, 50, 25, AtLeast.class); - assertTimeoutCorrectlyConfigured(t.times(5), Timeout.class, 50, 25, Times.class); - assertTimeoutCorrectlyConfigured(t.only(), Timeout.class, 50, 25, Only.class); - } - - private void assertTimeoutCorrectlyConfigured(VerificationMode t, Class<?> expectedType, long expectedTimeout, long expectedPollingPeriod, Class<?> expectedDelegateType) { - assertEquals(expectedType, t.getClass()); - assertEquals(expectedTimeout, ((Timeout) t).wrappedVerification.getDuration()); - assertEquals(expectedPollingPeriod, ((Timeout) t).wrappedVerification.getPollingPeriod()); - assertEquals(expectedDelegateType, ((Timeout) t).wrappedVerification.getDelegate().getClass()); - } + } \ No newline at end of file

train

train

nathanmbrown

train

mockito/mockito/188_211

mockito/mockito

mockito/mockito/188

mockito/mockito/211

0cd01b9d9719ef952035a426eef8272561f35d54

30e16ddddae1710ad096356f5a421fe22596c4de

ArgumentCaptor no longer working for varargs

I ran into the issue described here: http://stackoverflow.com/questions/27303562/why-does-upgrading-mockito-from-1-9-5-to-1-10-8-break-this-captor

diff --git a/src/org/mockito/internal/invocation/CapturesArgumensFromInvocation.java b/src/org/mockito/internal/invocation/CapturesArgumentsFromInvocation.java similarity index 83% rename from src/org/mockito/internal/invocation/CapturesArgumensFromInvocation.java rename to src/org/mockito/internal/invocation/CapturesArgumentsFromInvocation.java index cc58b802db..ef7bde459f 100644 --- a/src/org/mockito/internal/invocation/CapturesArgumensFromInvocation.java +++ b/src/org/mockito/internal/invocation/CapturesArgumentsFromInvocation.java @@ -7,7 +7,7 @@ import org.mockito.invocation.Invocation; -public interface CapturesArgumensFromInvocation { +public interface CapturesArgumentsFromInvocation { void captureArgumentsFrom(Invocation i); diff --git a/src/org/mockito/internal/invocation/InvocationMarker.java b/src/org/mockito/internal/invocation/InvocationMarker.java index 304fdb2ec5..d44cf9f0cd 100644 --- a/src/org/mockito/internal/invocation/InvocationMarker.java +++ b/src/org/mockito/internal/invocation/InvocationMarker.java @@ -11,18 +11,18 @@ public class InvocationMarker { - public void markVerified(List<Invocation> invocations, CapturesArgumensFromInvocation wanted) { + public void markVerified(List<Invocation> invocations, CapturesArgumentsFromInvocation wanted) { for (Invocation invocation : invocations) { markVerified(invocation, wanted); } } - public void markVerified(Invocation invocation, CapturesArgumensFromInvocation wanted) { - invocation.markVerified(); - wanted.captureArgumentsFrom(invocation); - } + public void markVerified(Invocation invocation, CapturesArgumentsFromInvocation wanted) { + invocation.markVerified(); + wanted.captureArgumentsFrom(invocation); + } - public void markVerifiedInOrder(List<Invocation> chunk, CapturesArgumensFromInvocation wanted, InOrderContext context) { + public void markVerifiedInOrder(List<Invocation> chunk, CapturesArgumentsFromInvocation wanted, InOrderContext context) { markVerified(chunk, wanted); for (Invocation i : chunk) { diff --git a/src/org/mockito/internal/invocation/InvocationMatcher.java b/src/org/mockito/internal/invocation/InvocationMatcher.java index f1b7b9421f..0e562a0129 100644 --- a/src/org/mockito/internal/invocation/InvocationMatcher.java +++ b/src/org/mockito/internal/invocation/InvocationMatcher.java @@ -8,20 +8,18 @@ import java.io.Serializable; import java.lang.reflect.Array; import java.lang.reflect.Method; -import java.util.Collections; -import java.util.LinkedList; -import java.util.List; +import java.util.*; + import org.hamcrest.Matcher; import org.mockito.internal.matchers.CapturesArguments; import org.mockito.internal.matchers.MatcherDecorator; -import org.mockito.internal.matchers.VarargMatcher; import org.mockito.internal.reporting.PrintSettings; import org.mockito.invocation.DescribedInvocation; import org.mockito.invocation.Invocation; import org.mockito.invocation.Location; @SuppressWarnings("unchecked") -public class InvocationMatcher implements DescribedInvocation, CapturesArgumensFromInvocation, Serializable { +public class InvocationMatcher implements DescribedInvocation, CapturesArgumentsFromInvocation, Serializable { private static final long serialVersionUID = -3047126096857467610L; private final Invocation invocation; @@ -99,16 +97,16 @@ public boolean hasSameMethod(Invocation candidate) { Method m2 = candidate.getMethod(); if (m1.getName() != null && m1.getName().equals(m2.getName())) { - /* Avoid unnecessary cloning */ - Class[] params1 = m1.getParameterTypes(); - Class[] params2 = m2.getParameterTypes(); - if (params1.length == params2.length) { - for (int i = 0; i < params1.length; i++) { - if (params1[i] != params2[i]) - return false; - } - return true; - } + /* Avoid unnecessary cloning */ + Class[] params1 = m1.getParameterTypes(); + Class[] params2 = m2.getParameterTypes(); + if (params1.length == params2.length) { + for (int i = 0; i < params1.length; i++) { + if (params1[i] != params2[i]) + return false; + } + return true; + } } return false; } @@ -118,46 +116,55 @@ public Location getLocation() { } public void captureArgumentsFrom(Invocation invocation) { - for (int position = 0; position < matchers.size(); position++) { + captureArguments(invocation); + if (invocation.getMethod().isVarArgs()) { + captureVarargsPart(invocation); + } + } + + private void captureArguments(Invocation invocation) { + for (int position = 0; position < regularArgumentsSize(invocation); position++) { Matcher m = matchers.get(position); - if (m instanceof CapturesArguments && invocation.getRawArguments().length > position) { - //TODO SF - this whole lot can be moved captureFrom implementation - if(isVariableArgument(invocation, position) && isVarargMatcher(m)) { - Object array = invocation.getRawArguments()[position]; - for (int i = 0; i < Array.getLength(array); i++) { - ((CapturesArguments) m).captureFrom(Array.get(array, i)); - } - //since we've captured all varargs already, it does not make sense to process other matchers. - return; - } else { - ((CapturesArguments) m).captureFrom(invocation.getRawArguments()[position]); - } + if (m instanceof CapturesArguments) { + ((CapturesArguments) m).captureFrom(invocation.getArgumentAt(position, Object.class)); } } } - private boolean isVarargMatcher(Matcher matcher) { - Matcher actualMatcher = matcher; - if (actualMatcher instanceof MatcherDecorator) { - actualMatcher = ((MatcherDecorator) actualMatcher).getActualMatcher(); + private void captureVarargsPart(Invocation invocation) { + int indexOfVararg = invocation.getRawArguments().length - 1; + for (Matcher m : uniqueMatcherSet(indexOfVararg)) { + if (m instanceof CapturesArguments) { + Object rawArgument = invocation.getRawArguments()[indexOfVararg]; + for (int i = 0; i < Array.getLength(rawArgument); i++) { + ((CapturesArguments) m).captureFrom(Array.get(rawArgument, i)); + } + } } - return actualMatcher instanceof VarargMatcher; } - private boolean isVariableArgument(Invocation invocation, int position) { - return invocation.getRawArguments().length - 1 == position - && invocation.getRawArguments()[position] != null - && invocation.getRawArguments()[position].getClass().isArray() - && invocation.getMethod().isVarArgs(); + private int regularArgumentsSize(Invocation invocation) { + return invocation.getMethod().isVarArgs() ? invocation.getRawArguments().length - 1 : matchers.size(); + } + + private Set<Matcher> uniqueMatcherSet(int indexOfVararg) { + HashSet<Matcher> set = new HashSet<Matcher>(); + for (int position = indexOfVararg; position < matchers.size(); position++) { + Matcher matcher = matchers.get(position); + if(matcher instanceof MatcherDecorator) { + set.add(((MatcherDecorator) matcher).getActualMatcher()); + } else { + set.add(matcher); + } + } + return set; } public static List<InvocationMatcher> createFrom(List<Invocation> invocations) { LinkedList<InvocationMatcher> out = new LinkedList<InvocationMatcher>(); - for (Invocation i : invocations) { out.add(new InvocationMatcher(i)); } - return out; } }

diff --git a/test/org/mockito/internal/invocation/InvocationMarkerTest.java b/test/org/mockito/internal/invocation/InvocationMarkerTest.java index 085b9a808b..d85320c485 100644 --- a/test/org/mockito/internal/invocation/InvocationMarkerTest.java +++ b/test/org/mockito/internal/invocation/InvocationMarkerTest.java @@ -35,7 +35,7 @@ public void shouldCaptureArguments() { InvocationMarker marker = new InvocationMarker(); Invocation i = new InvocationBuilder().toInvocation(); final ObjectBox box = new ObjectBox(); - CapturesArgumensFromInvocation c = new CapturesArgumensFromInvocation() { + CapturesArgumentsFromInvocation c = new CapturesArgumentsFromInvocation() { public void captureArgumentsFrom(Invocation i) { box.put(i); }}; diff --git a/test/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java b/test/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java index f067708f93..9dfb7ca1c7 100644 --- a/test/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java +++ b/test/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java @@ -28,6 +28,6 @@ public void shouldMarkActualInvocationsAsVerified() { c.check(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1); //then - Mockito.verify(c.invocationMarker).markVerified(eq(asList(invocation)), any(CapturesArgumensFromInvocation.class)); + Mockito.verify(c.invocationMarker).markVerified(eq(asList(invocation)), any(CapturesArgumentsFromInvocation.class)); } } diff --git a/test/org/mockitousage/matchers/CapturingArgumentsTest.java b/test/org/mockitousage/matchers/CapturingArgumentsTest.java index d833e681e2..553e913dd7 100644 --- a/test/org/mockitousage/matchers/CapturingArgumentsTest.java +++ b/test/org/mockitousage/matchers/CapturingArgumentsTest.java @@ -5,10 +5,10 @@ package org.mockitousage.matchers; +import org.junit.Assert; import org.fest.assertions.Assertions; import org.junit.Test; import org.mockito.ArgumentCaptor; -import org.mockito.Mock; import org.mockito.exceptions.base.MockitoException; import org.mockito.exceptions.verification.WantedButNotInvoked; import org.mockitousage.IMethods; @@ -23,8 +23,6 @@ public class CapturingArgumentsTest extends TestBase { - @Mock IMethods mock; - class Person { private final Integer age; @@ -37,12 +35,12 @@ public int getAge() { return age; } } - - class Emailer { - + + class BulkEmailService { + private EmailService service; - - public Emailer(EmailService service) { + + public BulkEmailService(EmailService service) { this.service = service; } @@ -53,50 +51,53 @@ public void email(Integer ... personId) { } } } - + interface EmailService { boolean sendEmailTo(Person person); } EmailService emailService = mock(EmailService.class); - Emailer emailer = new Emailer(emailService); + BulkEmailService bulkEmailService = new BulkEmailService(emailService); + IMethods mock = mock(IMethods.class); @SuppressWarnings("deprecation") @Test public void should_allow_assertions_on_captured_argument() { + //given + ArgumentCaptor<Person> argument = new ArgumentCaptor<Person>(); + //when - emailer.email(12); - + bulkEmailService.email(12); + //then - ArgumentCaptor<Person> argument = new ArgumentCaptor<Person>(); verify(emailService).sendEmailTo(argument.capture()); - assertEquals(12, argument.getValue().getAge()); } @Test public void should_allow_assertions_on_all_captured_arguments() { + //given + ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); + //when - emailer.email(11, 12); - + bulkEmailService.email(11, 12); + //then - ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); - verify(emailService, atLeastOnce()).sendEmailTo(argument.capture()); - List<Person> allValues = argument.getAllValues(); - - assertEquals(11, allValues.get(0).getAge()); - assertEquals(12, allValues.get(1).getAge()); + verify(emailService, times(2)).sendEmailTo(argument.capture()); + assertEquals(11, argument.getAllValues().get(0).getAge()); + assertEquals(12, argument.getAllValues().get(1).getAge()); } @Test public void should_allow_assertions_on_last_argument() { + //given + ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); + //when - emailer.email(11, 12, 13); - + bulkEmailService.email(11, 12, 13); + //then - ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); - verify(emailService, atLeastOnce()).sendEmailTo(argument.capture()); - + verify(emailService, times(3)).sendEmailTo(argument.capture()); assertEquals(13, argument.getValue().getAge()); } @@ -117,11 +118,13 @@ public void should_print_captor_matcher() { @Test public void should_allow_assertions_on_captured_null() { + //given + ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); + //when emailService.sendEmailTo(null); - + //then - ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); verify(emailService).sendEmailTo(argument.capture()); assertEquals(null, argument.getValue()); } @@ -130,12 +133,14 @@ public void should_allow_assertions_on_captured_null() { public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way() { //the test passes if this expression compiles ArgumentCaptor<List<Person>> argument = ArgumentCaptor.forClass(List.class); + assertNotNull(argument); } @Test public void should_allow_construction_of_captor_for_a_more_specific_type() { //the test passes if this expression compiles ArgumentCaptor<List> argument = ArgumentCaptor.forClass(ArrayList.class); + assertNotNull(argument); } @Test @@ -171,20 +176,22 @@ public void should_say_something_smart_when_misused() { try { argument.getValue(); fail(); - } catch (MockitoException e) {} + } catch (MockitoException e) { + Assert.assertTrue(true); + } } @Test public void should_capture_when_full_arg_list_matches() throws Exception { //given + ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class); + + //when mock.simpleMethod("foo", 1); mock.simpleMethod("bar", 2); - - //when - ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class); - verify(mock).simpleMethod(captor.capture(), eq(1)); - + //then + verify(mock).simpleMethod(captor.capture(), eq(1)); assertEquals(1, captor.getAllValues().size()); assertEquals("foo", captor.getValue()); } @@ -192,7 +199,6 @@ public void should_capture_when_full_arg_list_matches() throws Exception { @Test public void should_capture_int_by_creating_captor_with_primitive_wrapper() { //given - IMethods mock = mock(IMethods.class); ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(Integer.class); //when @@ -206,7 +212,6 @@ public void should_capture_int_by_creating_captor_with_primitive_wrapper() { @Test public void should_capture_int_by_creating_captor_with_primitive() throws Exception { //given - IMethods mock = mock(IMethods.class); ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(int.class); //when @@ -220,7 +225,6 @@ public void should_capture_int_by_creating_captor_with_primitive() throws Except @Test public void should_capture_byte_vararg_by_creating_captor_with_primitive() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(byte.class); // when @@ -235,7 +239,6 @@ public void should_capture_byte_vararg_by_creating_captor_with_primitive() throw @Test public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(Byte.class); // when @@ -250,7 +253,6 @@ public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper @Test public void should_capture_vararg() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class); // when @@ -264,7 +266,6 @@ public void should_capture_vararg() throws Exception { @Test public void should_capture_all_vararg() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class); // when @@ -274,14 +275,12 @@ public void should_capture_all_vararg() throws Exception { // then verify(mock, times(2)).mixedVarargs(any(), argumentCaptor.capture()); - List<String> allVarargsValues = argumentCaptor.getAllValues(); - Assertions.assertThat(allVarargsValues).containsExactly("a", "b", "c", "again ?!"); + Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c", "again ?!"); } @Test public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_method() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class); // when @@ -293,9 +292,8 @@ public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_me } @Test - public void captures_correclty_when_captor_used_multiple_times() throws Exception { + public void captures_correctly_when_captor_used_multiple_times() throws Exception { // given - IMethods mock = mock(IMethods.class); ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class); // when @@ -306,4 +304,17 @@ public void captures_correclty_when_captor_used_multiple_times() throws Exceptio verify(mock).mixedVarargs(any(), argumentCaptor.capture(), argumentCaptor.capture(), argumentCaptor.capture()); Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c"); } + + @Test + public void captures_correctly_when_captor_used_on_pure_vararg_method() throws Exception { + // given + ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class); + + // when + mock.varargs(42, "capturedValue"); + + // then + verify(mock).varargs(eq(42), argumentCaptor.capture()); + Assertions.assertThat(argumentCaptor.getValue()).contains("capturedValue"); + } } \ No newline at end of file

train

train

vadims

train

mockito/mockito/205_215

mockito/mockito

mockito/mockito/205

mockito/mockito/215

03028f0095d527ff9bd84bc929fc4931f17abf13

32ceae5e361a96641785a7c75d87e49c50505663

InjectMocks injects mock into wrong field

Using `1.10.19`. When using `@InjectMocks` on some Android `TextView`s, the mock is injected into the wrong field. We have two fields, `txtGateView` & `txtNextStep` in a class, and our test mocks out `txtNextStep`, then tried to inject. This field is injected wrong, see screenshot.  From our quick testing, the name `txtNextView` doesn't matter, that can be changed. But both `txtGateView` and `txtGateLabel` messed things up. If we mock out both fields, it works correctly. Testproject: https://github.com/SimenB/emptyandroid I don't know if it's because it's Android, but it was easiest for me to create a minimal test from existing code.

diff --git a/src/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/src/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java index 67126afd95..c17f961c5a 100644 --- a/src/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java +++ b/src/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java @@ -111,7 +111,7 @@ private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Set<Object private boolean injectMockCandidatesOnFields(Set<Object> mocks, Object instance, boolean injectionOccurred, List<Field> orderedInstanceFields) { for (Iterator<Field> it = orderedInstanceFields.iterator(); it.hasNext(); ) { Field field = it.next(); - Object injected = mockCandidateFilter.filterCandidate(mocks, field, instance).thenInject(); + Object injected = mockCandidateFilter.filterCandidate(mocks, field, orderedInstanceFields, instance).thenInject(); if (injected != null) { injectionOccurred |= true; mocks.remove(injected); diff --git a/src/org/mockito/internal/configuration/injection/filter/FinalMockCandidateFilter.java b/src/org/mockito/internal/configuration/injection/filter/FinalMockCandidateFilter.java index 7bd70735f7..aebf6f71e4 100644 --- a/src/org/mockito/internal/configuration/injection/filter/FinalMockCandidateFilter.java +++ b/src/org/mockito/internal/configuration/injection/filter/FinalMockCandidateFilter.java @@ -10,6 +10,7 @@ import java.lang.reflect.Field; import java.util.Collection; +import java.util.List; /** * This node returns an actual injecter which will be either : @@ -20,7 +21,7 @@ * </ul> */ public class FinalMockCandidateFilter implements MockCandidateFilter { - public OngoingInjecter filterCandidate(final Collection<Object> mocks, final Field field, final Object fieldInstance) { + public OngoingInjecter filterCandidate(final Collection<Object> mocks, final Field field, List<Field> fields, final Object fieldInstance) { if(mocks.size() == 1) { final Object matchingMock = mocks.iterator().next(); diff --git a/src/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java b/src/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java index 7a2c08781e..81a168b491 100644 --- a/src/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java +++ b/src/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java @@ -6,13 +6,14 @@ import java.lang.reflect.Field; import java.util.Collection; +import java.util.List; public interface MockCandidateFilter { OngoingInjecter filterCandidate( Collection<Object> mocks, Field fieldToBeInjected, - Object fieldInstance + List<Field> fields, Object instance ); } diff --git a/src/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java b/src/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java index 7023e66ba2..abc5d67b45 100644 --- a/src/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java +++ b/src/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java @@ -12,23 +12,50 @@ import java.util.List; public class NameBasedCandidateFilter implements MockCandidateFilter { - private final MockCandidateFilter next; - private final MockUtil mockUtil = new MockUtil(); + private final MockCandidateFilter next; + private final MockUtil mockUtil = new MockUtil(); - public NameBasedCandidateFilter(MockCandidateFilter next) { - this.next = next; - } + public NameBasedCandidateFilter(MockCandidateFilter next) { + this.next = next; + } - public OngoingInjecter filterCandidate(Collection<Object> mocks, Field field, Object fieldInstance) { - List<Object> mockNameMatches = new ArrayList<Object>(); - if(mocks.size() > 1) { - for (Object mock : mocks) { - if (field.getName().equals(mockUtil.getMockName(mock).toString())) { - mockNameMatches.add(mock); - } - } - return next.filterCandidate(mockNameMatches, field, fieldInstance); - } - return next.filterCandidate(mocks, field, fieldInstance); - } + public OngoingInjecter filterCandidate(Collection<Object> mocks, + Field field, List<Field> fields, Object fieldInstance) { + List<Object> mockNameMatches = new ArrayList<Object>(); + if (mocks.size() > 1) { + for (Object mock : mocks) { + if (field.getName().equals(mockUtil.getMockName(mock).toString())) { + mockNameMatches.add(mock); + } + } + return next.filterCandidate(mockNameMatches, field, fields, + fieldInstance); + /* + * In this case we have to check whether we have conflicting naming + * fields. E.g. 2 fields of the same type, but we have to make sure + * we match on the correct name. + * + * Therefore we have to go through all other fields and make sure + * whenever we find a field that does match its name with the mock + * name, we should take that field instead. + */ + } else if (mocks.size() == 1) { + String mockName = mockUtil.getMockName(mocks.iterator().next()) + .toString(); + + for (Field otherField : fields) { + if (!otherField.equals(field) + && otherField.getType().equals(field.getType()) + && otherField.getName().equals(mockName)) { + + return new OngoingInjecter() { + public Object thenInject() { + return null; + } + }; + } + } + } + return next.filterCandidate(mocks, field, fields, fieldInstance); + } } diff --git a/src/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java b/src/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java index dd79991a65..ce7a349fa7 100644 --- a/src/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java +++ b/src/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java @@ -17,7 +17,7 @@ public TypeBasedCandidateFilter(MockCandidateFilter next) { this.next = next; } - public OngoingInjecter filterCandidate(Collection<Object> mocks, Field field, Object fieldInstance) { + public OngoingInjecter filterCandidate(Collection<Object> mocks, Field field, List<Field> fields, Object fieldInstance) { List<Object> mockTypeMatches = new ArrayList<Object>(); for (Object mock : mocks) { if (field.getType().isAssignableFrom(mock.getClass())) { @@ -25,6 +25,6 @@ public OngoingInjecter filterCandidate(Collection<Object> mocks, Field field, Ob } } - return next.filterCandidate(mockTypeMatches, field, fieldInstance); + return next.filterCandidate(mockTypeMatches, field, fields, fieldInstance); } }

diff --git a/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java b/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java index bd49f3adee..c6eb915851 100644 --- a/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java +++ b/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java @@ -4,6 +4,9 @@ */ package org.mockitousage.annotation; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + import org.fest.assertions.Assertions; import org.junit.Before; import org.junit.Test; @@ -28,6 +31,7 @@ public class MockInjectionUsingSetterOrPropertyTest extends TestBase { @InjectMocks private BaseUnderTesting baseUnderTest = new BaseUnderTesting(); @InjectMocks private SubUnderTesting subUnderTest = new SubUnderTesting(); @InjectMocks private OtherBaseUnderTesting otherBaseUnderTest = new OtherBaseUnderTesting(); + @InjectMocks private OtherSuperUnderTesting otherSuperUnderTesting = new OtherSuperUnderTesting(); private BaseUnderTesting baseUnderTestingInstance = new BaseUnderTesting(); @InjectMocks private BaseUnderTesting initializedBase = baseUnderTestingInstance; @@ -40,6 +44,8 @@ public class MockInjectionUsingSetterOrPropertyTest extends TestBase { @Mock private List list; @Mock private Set histogram1; @Mock private Set histogram2; + @Mock private A candidate2; + @Spy private TreeSet searchTree = new TreeSet(); private MockUtil mockUtil = new MockUtil(); @@ -103,6 +109,13 @@ public void shouldInjectSpies() { assertSame(searchTree, otherBaseUnderTest.getSearchTree()); } + @Test + public void shouldInsertFieldWithCorrectNameWhenMultipleTypesAvailable() { + MockitoAnnotations.initMocks(this); + assertNull(otherSuperUnderTesting.candidate1); + assertNotNull(otherSuperUnderTesting.candidate2); + } + @Test public void shouldInstantiateInjectMockFieldIfPossible() throws Exception { assertNotNull(notInitializedBase); @@ -168,4 +181,15 @@ public Set getHistogram2() { return histogram2; } } + + static class OtherSuperUnderTesting { + private A candidate1; + + private A candidate2; + } + + interface A { + } + + }

train

train

SimenB

train

mockito/mockito/212_221

mockito/mockito

mockito/mockito/212

mockito/mockito/221

0cd01b9d9719ef952035a426eef8272561f35d54

01b0100e3cd3de6baa3359a8175c24b245067393

Add BDD version of verifyZeroInteractions()

Right now my tests look like: ``` java then(file).should().moveTo(directory); then(log).should().warn("Moved file")); verifyZeroInteractions(otherFile); ``` Would be great to have BDD replacement for `verifyZeroInteractions()`. Then the test would be even nicer: ``` java then(file).should().moveTo(directory); then(log).should().warn("Moved file")); then(otherFile).shouldHaveZeroInteractions(); ```

diff --git a/src/org/mockito/BDDMockito.java b/src/org/mockito/BDDMockito.java index 3d008b5516..d0e280c665 100644 --- a/src/org/mockito/BDDMockito.java +++ b/src/org/mockito/BDDMockito.java @@ -57,6 +57,7 @@ * person.ride(bike); * * then(person).should(times(2)).ride(bike); + * then(police).shouldHaveZeroInteractions(); * </code></pre> * * One of the purposes of BDDMockito is also to show how to tailor the mocking syntax to a different programming style. @@ -229,6 +230,12 @@ public static interface Then<T> { * @since 1.10.5 */ T should(VerificationMode mode); + + /** + * @see #verifyZeroInteractions(Object...) + * @since 2.0.0 + */ + void shouldHaveZeroInteractions(); } static class ThenImpl<T> implements Then<T> { @@ -254,6 +261,14 @@ public T should() { public T should(VerificationMode mode) { return verify(mock, mode); } + + /** + * @see #verifyZeroInteractions(Object...) + * @since 2.0.0 + */ + public void shouldHaveZeroInteractions() { + verifyZeroInteractions(mock); + } } /**

diff --git a/test/org/mockitousage/customization/BDDMockitoTest.java b/test/org/mockitousage/customization/BDDMockitoTest.java index 8211338b43..71b50196bc 100644 --- a/test/org/mockitousage/customization/BDDMockitoTest.java +++ b/test/org/mockitousage/customization/BDDMockitoTest.java @@ -7,6 +7,7 @@ import org.junit.Test; import org.mockito.Mock; import org.mockito.exceptions.misusing.NotAMockException; +import org.mockito.exceptions.verification.NoInteractionsWanted; import org.mockito.exceptions.verification.WantedButNotInvoked; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -222,16 +223,32 @@ public void shouldPassForExpectedBehaviorThatHappened() { then(mock).should().booleanObjectReturningMethod(); } + @Test + public void shouldValidateThatMockDidNotHaveAnyInteractions() { + + then(mock).shouldHaveZeroInteractions(); + } + + @Test(expected = NoInteractionsWanted.class) + public void shouldFailWhenMockHadUnwantedInteractions() { + + mock.booleanObjectReturningMethod(); + + then(mock).shouldHaveZeroInteractions(); + } + @Test public void shouldPassFluentBddScenario() { Bike bike = new Bike(); Person person = mock(Person.class); + Police police = mock(Police.class); person.ride(bike); person.ride(bike); then(person).should(times(2)).ride(bike); + then(police).shouldHaveZeroInteractions(); } static class Person { @@ -242,4 +259,8 @@ void ride(Bike bike) {} static class Bike { } + + static class Police { + + } }

train

train

mkordas

train

mockito/mockito/203_222

mockito/mockito

mockito/mockito/203

mockito/mockito/222

1ccd0e7bacfbc56e4e796cbde2ff3a896f71c1ad

61477c40e15480e5f00f3ea4cbffa23b34d2b1b8

Introduce BDD InOrder verification

Follow-up to the [discussion](https://groups.google.com/forum/#!topic/mockito/wr1As1fg_-U). [BDDMockito](http://site.mockito.org/mockito/docs/current/org/mockito/BDDMockito.html) is great, but right now it doesn't support InOrder verification. Here is my proposition: ##### Initialization and invocations: ``` java List firstMock = mock(List.class); List secondMock = mock(List.class); firstMock.add("was called first"); secondMock.add("was called second"); secondMock.add("was called second"); InOrder inOrder = inOrder(firstMock, secondMock); ``` ##### Current non-BDD solution: ``` java inOrder.verify(firstMock).add("was called first"); inOrder.verify(secondMock).add("was called second"); ``` ##### Proposition 1: ``` java inOrder.then(firstMock).should().add("was called first"); inOrder.then(secondMock).should(times(2)).add("was called second"); ``` ##### Proposition 2: ``` java then(firstMock).should(inOrder).add("was called first"); then(secondMock).should(inOrder, times(2)).add("was called second"); ``` I'm open to other propositions. What do you think? I can proceed with PR as soon as we will agree on API.

diff --git a/src/org/mockito/BDDMockito.java b/src/org/mockito/BDDMockito.java index d0e280c665..4ab46397d2 100644 --- a/src/org/mockito/BDDMockito.java +++ b/src/org/mockito/BDDMockito.java @@ -59,7 +59,19 @@ * then(person).should(times(2)).ride(bike); * then(police).shouldHaveZeroInteractions(); * </code></pre> + * <p> + * It is also possible to do BDD style {@link InOrder} verification: + * <pre class="code"><code class="java"> + * InOrder inOrder = inOrder(person); + * + * person.drive(car); + * person.ride(bike); + * person.ride(bike); * + * then(person).should(inOrder).drive(car); + * then(person).should(inOrder, times(2)).ride(bike); + * </code></pre> + * <p> * One of the purposes of BDDMockito is also to show how to tailor the mocking syntax to a different programming style. * * @since 1.8.0 @@ -231,9 +243,21 @@ public static interface Then<T> { */ T should(VerificationMode mode); + /** + * @see InOrder#verify(Object) + * @since 2.0 + */ + T should(InOrder inOrder); + + /** + * @see InOrder#verify(Object, VerificationMode) + * @since 2.0 + */ + T should(InOrder inOrder, VerificationMode mode); + /** * @see #verifyZeroInteractions(Object...) - * @since 2.0.0 + * @since 2.0 */ void shouldHaveZeroInteractions(); } @@ -262,9 +286,25 @@ public T should(VerificationMode mode) { return verify(mock, mode); } + /** + * @see InOrder#verify(Object) + * @since 2.0 + */ + public T should(InOrder inOrder) { + return inOrder.verify(mock); + } + + /** + * @see InOrder#verify(Object, VerificationMode) + * @since 2.0 + */ + public T should(InOrder inOrder, VerificationMode mode) { + return inOrder.verify(mock, mode); + } + /** * @see #verifyZeroInteractions(Object...) - * @since 2.0.0 + * @since 2.0 */ public void shouldHaveZeroInteractions() { verifyZeroInteractions(mock);

diff --git a/test/org/mockitousage/customization/BDDMockitoTest.java b/test/org/mockitousage/customization/BDDMockitoTest.java index 71b50196bc..8b9324cfdd 100644 --- a/test/org/mockitousage/customization/BDDMockitoTest.java +++ b/test/org/mockitousage/customization/BDDMockitoTest.java @@ -5,9 +5,11 @@ package org.mockitousage.customization; import org.junit.Test; +import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.exceptions.misusing.NotAMockException; import org.mockito.exceptions.verification.NoInteractionsWanted; +import org.mockito.exceptions.verification.VerificationInOrderFailure; import org.mockito.exceptions.verification.WantedButNotInvoked; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -237,6 +239,38 @@ public void shouldFailWhenMockHadUnwantedInteractions() { then(mock).shouldHaveZeroInteractions(); } + @Test + public void shouldPassForInteractionsThatHappenedInCorrectOrder() { + + InOrder inOrder = inOrder(mock); + + mock.booleanObjectReturningMethod(); + mock.arrayReturningMethod(); + + then(mock).should(inOrder).booleanObjectReturningMethod(); + then(mock).should(inOrder).arrayReturningMethod(); + } + + @Test(expected = VerificationInOrderFailure.class) + public void shouldFailForInteractionsThatWereInWrongOrder() { + + InOrder inOrder = inOrder(mock); + + mock.arrayReturningMethod(); + mock.booleanObjectReturningMethod(); + + then(mock).should(inOrder).booleanObjectReturningMethod(); + then(mock).should(inOrder).arrayReturningMethod(); + } + + @Test(expected = WantedButNotInvoked.class) + public void shouldFailWhenCheckingOrderOfInteractionsThatDidNotHappen() { + + InOrder inOrder = inOrder(mock); + + then(mock).should(inOrder).booleanObjectReturningMethod(); + } + @Test public void shouldPassFluentBddScenario() { @@ -251,16 +285,55 @@ public void shouldPassFluentBddScenario() { then(police).shouldHaveZeroInteractions(); } + @Test + public void shouldPassFluentBddScenarioWithOrderedVerification() { + + Bike bike = new Bike(); + Car car = new Car(); + Person person = mock(Person.class); + InOrder inOrder = inOrder(person); + + person.drive(car); + person.ride(bike); + person.ride(bike); + + then(person).should(inOrder).drive(car); + then(person).should(inOrder, times(2)).ride(bike); + } + + @Test + public void shouldPassFluentBddScenarioWithOrderedVerificationForTwoMocks() { + + Car car = new Car(); + Person person = mock(Person.class); + Police police = mock(Police.class); + InOrder inOrder = inOrder(person, police); + + person.drive(car); + person.drive(car); + police.chase(car); + + then(person).should(inOrder, times(2)).drive(car); + then(police).should(inOrder).chase(car); + } + static class Person { void ride(Bike bike) {} + + void drive(Car car) {} } static class Bike { } + static class Car { + + } + static class Police { + void chase(Car car) {} } }

test

train

mkordas

train

mockito/mockito/228_229

mockito/mockito

mockito/mockito/228

mockito/mockito/229

2a686ff33684ba12cd3d82e17bd6882588ae6a7f

b561284b7d52ed187127b89d8715ce173878e859

@Captor javadoc contains a wrong call example

In the javadoc of `@Captor`: ``` verify(mock.doStuff(captor.capture())); ``` which is incorrect.

diff --git a/src/org/mockito/Captor.java b/src/org/mockito/Captor.java index 1a081a2513..225bf700f2 100644 --- a/src/org/mockito/Captor.java +++ b/src/org/mockito/Captor.java @@ -22,7 +22,7 @@ * * &#64;Test public void shouldDoSomethingUseful() { * //... - * verify(mock.doStuff(captor.capture())); + * verify(mock).doStuff(captor.capture()); * assertEquals("foo", captor.getValue()); * } * }

test

train

eugene-ivakhno

train

mockito/mockito/231_232

mockito/mockito

mockito/mockito/231

mockito/mockito/232

6b5424acebc1bc4ebaca97d6592ade901d1fb838

3359a126b5e0a45f084820c615ae007736367121

Upgrade to Hamcrest 1.3 in pom

I know this may be a meaningless case because of #154, but if you're going to [continue to release versions of Mockito that include hamcrest as a required dependency in the pom](http://central.maven.org/maven2/org/mockito/mockito-core/2.0.13-beta/mockito-core-2.0.13-beta.pom), could you at least upgrade it to 1.3? JUnit 4.11 has been out, using Hamcrest 1.3 since 2012. [Related Stack Overflow question](http://stackoverflow.com/questions/18770943/mockito-junit-hamcrest-versioning)

diff --git a/build.gradle b/build.gradle index 8f7c9ac72f..d78688fc05 100644 --- a/build.gradle +++ b/build.gradle @@ -62,8 +62,8 @@ tasks.withType(JavaCompile) { dependencies { compile 'net.bytebuddy:byte-buddy:0.6.8' - provided "junit:junit:4.10" - compile "org.hamcrest:hamcrest-core:1.1", "org.objenesis:objenesis:2.1" + provided "junit:junit:4.11" + compile "org.hamcrest:hamcrest-core:1.3", "org.objenesis:objenesis:2.1" testCompile 'org.ow2.asm:asm:5.0.4' testCompile fileTree("lib/test") diff --git a/src/org/mockito/internal/matchers/LocalizedMatcher.java b/src/org/mockito/internal/matchers/LocalizedMatcher.java index 7aeb79a73f..7adb94fb22 100644 --- a/src/org/mockito/internal/matchers/LocalizedMatcher.java +++ b/src/org/mockito/internal/matchers/LocalizedMatcher.java @@ -31,7 +31,11 @@ public void _dont_implement_Matcher___instead_extend_BaseMatcher_() { public boolean matches(Object item) { return actualMatcher.matches(item); } - + + public void describeMismatch(Object item, Description description) { + actualMatcher.describeMismatch(item, description); + } + public void describeTo(Description description) { actualMatcher.describeTo(description); } @@ -68,4 +72,4 @@ public void captureFrom(Object argument) { public Matcher getActualMatcher() { return actualMatcher; } -} \ No newline at end of file +}

diff --git a/test/org/mockito/internal/runners/RunnerFactoryTest.java b/test/org/mockito/internal/runners/RunnerFactoryTest.java index 7620ed7197..4b8ba78074 100644 --- a/test/org/mockito/internal/runners/RunnerFactoryTest.java +++ b/test/org/mockito/internal/runners/RunnerFactoryTest.java @@ -37,7 +37,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit44RunnerImpl.class)); + assertThat(runner, isA(JUnit44RunnerImpl.class)); } @Test @@ -54,7 +54,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit45AndHigherRunnerImpl.class)); + assertThat(runner, isA(JUnit45AndHigherRunnerImpl.class)); } @Test @@ -118,4 +118,4 @@ public RunnerImpl newInstance(String runnerClassName, Class<?> constructorParam) //then catch (InvocationTargetException e) {} } -} \ No newline at end of file +} diff --git a/test/org/mockitousage/basicapi/MocksCreationTest.java b/test/org/mockitousage/basicapi/MocksCreationTest.java index 533826a6f4..732295a112 100644 --- a/test/org/mockitousage/basicapi/MocksCreationTest.java +++ b/test/org/mockitousage/basicapi/MocksCreationTest.java @@ -62,7 +62,7 @@ public void shouldCombineMockNameAndExtraInterfaces() { //then assertContains("great mockie", name); //and - assertThat(mock, is(List.class)); + assertThat(mock, isA(List.class)); } @Test @@ -100,4 +100,4 @@ public void shouldAllowInlineMockCreation() throws Exception { when(mock(Set.class).isEmpty()).thenReturn(false); } -} \ No newline at end of file +} diff --git a/test/org/mockitoutil/ExtraMatchers.java b/test/org/mockitoutil/ExtraMatchers.java index bd0fe349ec..bce921ec6e 100644 --- a/test/org/mockitoutil/ExtraMatchers.java +++ b/test/org/mockitoutil/ExtraMatchers.java @@ -134,7 +134,7 @@ public void assertValue(Collection value) { } public static org.hamcrest.Matcher<java.lang.Object> clazz(java.lang.Class<?> type) { - return CoreMatchers.is(type); + return CoreMatchers.isA(type); } public static Assertor hasMethodsInStackTrace(final String ... methods) { @@ -147,4 +147,4 @@ public void assertValue(Throwable value) { } }; } -} \ No newline at end of file +}

val

train

durron597

train

mockito/mockito/154_232

mockito/mockito

mockito/mockito/154

mockito/mockito/232

6b5424acebc1bc4ebaca97d6592ade901d1fb838

3359a126b5e0a45f084820c615ae007736367121

stop depending on hamcrest internally

In order to avoid compatibility/upgrade problems we will stop depending on hamcrest internally. Hamcrest will be an optional dependency of Mockito.

diff --git a/build.gradle b/build.gradle index 8f7c9ac72f..d78688fc05 100644 --- a/build.gradle +++ b/build.gradle @@ -62,8 +62,8 @@ tasks.withType(JavaCompile) { dependencies { compile 'net.bytebuddy:byte-buddy:0.6.8' - provided "junit:junit:4.10" - compile "org.hamcrest:hamcrest-core:1.1", "org.objenesis:objenesis:2.1" + provided "junit:junit:4.11" + compile "org.hamcrest:hamcrest-core:1.3", "org.objenesis:objenesis:2.1" testCompile 'org.ow2.asm:asm:5.0.4' testCompile fileTree("lib/test") diff --git a/src/org/mockito/internal/matchers/LocalizedMatcher.java b/src/org/mockito/internal/matchers/LocalizedMatcher.java index 7aeb79a73f..7adb94fb22 100644 --- a/src/org/mockito/internal/matchers/LocalizedMatcher.java +++ b/src/org/mockito/internal/matchers/LocalizedMatcher.java @@ -31,7 +31,11 @@ public void _dont_implement_Matcher___instead_extend_BaseMatcher_() { public boolean matches(Object item) { return actualMatcher.matches(item); } - + + public void describeMismatch(Object item, Description description) { + actualMatcher.describeMismatch(item, description); + } + public void describeTo(Description description) { actualMatcher.describeTo(description); } @@ -68,4 +72,4 @@ public void captureFrom(Object argument) { public Matcher getActualMatcher() { return actualMatcher; } -} \ No newline at end of file +}

diff --git a/test/org/mockito/internal/runners/RunnerFactoryTest.java b/test/org/mockito/internal/runners/RunnerFactoryTest.java index 7620ed7197..4b8ba78074 100644 --- a/test/org/mockito/internal/runners/RunnerFactoryTest.java +++ b/test/org/mockito/internal/runners/RunnerFactoryTest.java @@ -37,7 +37,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit44RunnerImpl.class)); + assertThat(runner, isA(JUnit44RunnerImpl.class)); } @Test @@ -54,7 +54,7 @@ public boolean isJUnit45OrHigherAvailable() { RunnerImpl runner = factory.create(RunnerFactoryTest.class); //then - assertThat(runner, is(JUnit45AndHigherRunnerImpl.class)); + assertThat(runner, isA(JUnit45AndHigherRunnerImpl.class)); } @Test @@ -118,4 +118,4 @@ public RunnerImpl newInstance(String runnerClassName, Class<?> constructorParam) //then catch (InvocationTargetException e) {} } -} \ No newline at end of file +} diff --git a/test/org/mockitousage/basicapi/MocksCreationTest.java b/test/org/mockitousage/basicapi/MocksCreationTest.java index 533826a6f4..732295a112 100644 --- a/test/org/mockitousage/basicapi/MocksCreationTest.java +++ b/test/org/mockitousage/basicapi/MocksCreationTest.java @@ -62,7 +62,7 @@ public void shouldCombineMockNameAndExtraInterfaces() { //then assertContains("great mockie", name); //and - assertThat(mock, is(List.class)); + assertThat(mock, isA(List.class)); } @Test @@ -100,4 +100,4 @@ public void shouldAllowInlineMockCreation() throws Exception { when(mock(Set.class).isEmpty()).thenReturn(false); } -} \ No newline at end of file +} diff --git a/test/org/mockitoutil/ExtraMatchers.java b/test/org/mockitoutil/ExtraMatchers.java index bd0fe349ec..bce921ec6e 100644 --- a/test/org/mockitoutil/ExtraMatchers.java +++ b/test/org/mockitoutil/ExtraMatchers.java @@ -134,7 +134,7 @@ public void assertValue(Collection value) { } public static org.hamcrest.Matcher<java.lang.Object> clazz(java.lang.Class<?> type) { - return CoreMatchers.is(type); + return CoreMatchers.isA(type); } public static Assertor hasMethodsInStackTrace(final String ... methods) { @@ -147,4 +147,4 @@ public void assertValue(Throwable value) { } }; } -} \ No newline at end of file +}

val

train

mockitoguy

train

mockito/mockito/233_234

mockito/mockito

mockito/mockito/233

mockito/mockito/234

6b5424acebc1bc4ebaca97d6592ade901d1fb838

b2de99b33959b6e49dadaaae5f627ead2a20f34f

mockito 2.0.14 fails to mock jetty httpclient

this fails: <pre> import org.eclipse.jetty.client.HttpClient; HttpClient httpClient = mock(HttpClient.class); </pre> (jetty 9.2.10.v20150310) with mockito 2.0.2-beta i can mock that class without a problem. stacktrace: <pre> java.lang.IllegalAccessError: tried to access class org.eclipse.jetty.util.component.ContainerLifeCycle$Managed from class org.eclipse.jetty.client.HttpClient$MockitoMock$362486671 at org.eclipse.jetty.client.HttpClient$MockitoMock$362486671.<clinit>(Unknown Source) at sun.reflect.GeneratedSerializationConstructorAccessor2.newInstance(Unknown Source) at java.lang.reflect.Constructor.newInstance(Constructor.java:408) at org.objenesis.instantiator.sun.SunReflectionFactoryInstantiator.newInstance(SunReflectionFactoryInstantiator.java:45) at org.objenesis.ObjenesisBase.newInstance(ObjenesisBase.java:73) at org.mockito.internal.creation.instance.ObjenesisInstantiator.newInstance(ObjenesisInstantiator.java:14) at org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:27) at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:33) at org.mockito.internal.MockitoCore.mock(MockitoCore.java:59) at org.mockito.Mockito.mock(Mockito.java:1392) at org.mockito.Mockito.mock(Mockito.java:1270) </pre>

diff --git a/build.gradle b/build.gradle index 8f7c9ac72f..939764ee4f 100644 --- a/build.gradle +++ b/build.gradle @@ -60,7 +60,7 @@ tasks.withType(JavaCompile) { //TODO we should remove all dependencies to checked-in jars dependencies { - compile 'net.bytebuddy:byte-buddy:0.6.8' + compile 'net.bytebuddy:byte-buddy-dep:0.6.10' provided "junit:junit:4.10" compile "org.hamcrest:hamcrest-core:1.1", "org.objenesis:objenesis:2.1" diff --git a/gradle/javadoc.gradle b/gradle/javadoc.gradle index 7439273357..c221c6277b 100644 --- a/gradle/javadoc.gradle +++ b/gradle/javadoc.gradle @@ -35,8 +35,8 @@ task mockitoJavadoc(type: Javadoc) { <script type="text/javascript"> var usingOldIE = \$.browser.msie && parseInt(\$.browser.version) < 9; if(!usingOldIE) { - \$("head").append("<link rel=\\"shortcut icon\\" href=\\"/favicon.ico?v=cafebabe\\">") - \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"/favicon.ico?v=cafebabe\\">") + \$("head").append("<link rel=\\"shortcut icon\\" href=\\"@{docRoot}/favicon.ico?v=cafebabe\\">") + \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"@{docRoot}/favicon.ico?v=cafebabe\\">") hljs.initHighlightingOnLoad(); injectProjectVersionForJavadocJDK6("Mockito ${project.version} API", "em#mockito-version-header-javadoc7-header", diff --git a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java index d89e4250cb..8d7c42d252 100644 --- a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java +++ b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java @@ -1,21 +1,24 @@ package org.mockito.internal.creation.bytebuddy; -import java.util.Random; -import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock; -import org.mockito.internal.creation.util.SearchingClassLoader; import net.bytebuddy.ByteBuddy; import net.bytebuddy.ClassFileVersion; -import net.bytebuddy.description.modifier.FieldManifestation; -import net.bytebuddy.description.modifier.Ownership; -import net.bytebuddy.description.modifier.Visibility; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.dynamic.loading.ClassLoadingStrategy; import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy; -import net.bytebuddy.implementation.FieldAccessor; -import net.bytebuddy.implementation.MethodDelegation; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; import net.bytebuddy.implementation.attribute.TypeAttributeAppender; -import net.bytebuddy.matcher.ElementMatchers; +import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock; +import org.mockito.internal.creation.util.SearchingClassLoader; + +import java.util.Random; + +import static net.bytebuddy.description.modifier.FieldManifestation.FINAL; +import static net.bytebuddy.description.modifier.Ownership.STATIC; +import static net.bytebuddy.description.modifier.Visibility.PRIVATE; +import static net.bytebuddy.implementation.FieldAccessor.ofBeanProperty; +import static net.bytebuddy.implementation.MethodDelegation.to; +import static net.bytebuddy.implementation.MethodDelegation.toInstanceField; +import static net.bytebuddy.matcher.ElementMatchers.*; class MockBytecodeGenerator { private final ByteBuddy byteBuddy; @@ -31,20 +34,20 @@ public MockBytecodeGenerator() { } public <T> Class<? extends T> generateMockClass(MockFeatures<T> features) { - DynamicType.Builder<T> builder = byteBuddy.subclass(features.mockedType, ConstructorStrategy.Default.IMITATE_SUPER_TYPE) - .name(nameFor(features.mockedType)) - .implement(features.interfaces.toArray(new Class<?>[features.interfaces.size()])) - .method(ElementMatchers.any()).intercept(MethodDelegation - .toInstanceField(MockMethodInterceptor.class, "mockitoInterceptor") - .filter(ElementMatchers.isDeclaredBy(MockMethodInterceptor.class))) - .implement(MockMethodInterceptor.MockAccess.class).intercept(FieldAccessor.ofBeanProperty()) - .method(ElementMatchers.isHashCode()).intercept(MethodDelegation.to(MockMethodInterceptor.ForHashCode.class)) - .method(ElementMatchers.isEquals()).intercept(MethodDelegation.to(MockMethodInterceptor.ForEquals.class)) - .defineField("serialVersionUID", long.class, Ownership.STATIC, Visibility.PRIVATE, FieldManifestation.FINAL).value(42L); - if (features.crossClassLoaderSerializable) { - builder = builder.implement(CrossClassLoaderSerializableMock.class) - .intercept(MethodDelegation.to(MockMethodInterceptor.ForWriteReplace.class)); - } + DynamicType.Builder<T> builder = + byteBuddy.subclass(features.mockedType, ConstructorStrategy.Default.IMITATE_SUPER_TYPE) + .name(nameFor(features.mockedType)) + .implement(features.interfaces.toArray(new Class<?>[features.interfaces.size()])) + .method(any()).intercept(toInstanceField(MockMethodInterceptor.class, "mockitoInterceptor") + .filter(isDeclaredBy(MockMethodInterceptor.class))) + .implement(MockMethodInterceptor.MockAccess.class).intercept(ofBeanProperty()) + .method(isHashCode()).intercept(to(MockMethodInterceptor.ForHashCode.class)) + .method(isEquals()).intercept(to(MockMethodInterceptor.ForEquals.class)) + .defineField("serialVersionUID", long.class, STATIC, PRIVATE, FINAL).value(42L); + if (features.crossClassLoaderSerializable) { + builder = builder.implement(CrossClassLoaderSerializableMock.class) + .intercept(to(MockMethodInterceptor.ForWriteReplace.class)); + } Class<?>[] allMockedTypes = new Class<?>[features.interfaces.size() + 1]; allMockedTypes[0] = features.mockedType; // System.arraycopy(interfaces.toArray(), 0, allMockedTypes, 1, interfaces.size()); @@ -53,8 +56,8 @@ public <T> Class<? extends T> generateMockClass(MockFeatures<T> features) { allMockedTypes[index++] = type; } return builder.make() - .load(SearchingClassLoader.combineLoadersOf(allMockedTypes), ClassLoadingStrategy.Default.INJECTION) - .getLoaded(); + .load(SearchingClassLoader.combineLoadersOf(allMockedTypes), ClassLoadingStrategy.Default.INJECTION) + .getLoaded(); } // TODO inspect naming strategy (for OSGI, signed package, java.* (and bootstrap classes), etc...)

diff --git a/test/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java b/test/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java new file mode 100644 index 0000000000..9d4e340bf3 --- /dev/null +++ b/test/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java @@ -0,0 +1,22 @@ +package org.mockitousage.bugs.creation; + + +import org.junit.Test; +import org.mockito.Mockito; +import org.mockitousage.bugs.creation.api.PublicClass; + +// see GH-233 +public class PublicMethodInParentWithNonPublicTypeInSignatureTest { + + private Object ref; + + @Test + public void java_object_creation() throws Exception { + ref = new PublicClass(); + } + + @Test + public void should_not_fail_when_instantiating() throws Exception { + ref = Mockito.mock(PublicClass.class); + } +} diff --git a/test/org/mockitousage/bugs/creation/api/PublicClass.java b/test/org/mockitousage/bugs/creation/api/PublicClass.java new file mode 100644 index 0000000000..243036a0d4 --- /dev/null +++ b/test/org/mockitousage/bugs/creation/api/PublicClass.java @@ -0,0 +1,6 @@ +package org.mockitousage.bugs.creation.api; + +import org.mockitousage.bugs.creation.otherpackage.PublicParentClass; + +public class PublicClass extends PublicParentClass { +} diff --git a/test/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java b/test/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java new file mode 100644 index 0000000000..8f560d4645 --- /dev/null +++ b/test/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java @@ -0,0 +1,6 @@ +package org.mockitousage.bugs.creation.otherpackage; + +public class PublicParentClass { + public void method_with_non_public_argument(PackageLocalArg arg) { } + static class PackageLocalArg { } +}

val

train

christophsturm

train

mockito/mockito/220_235

mockito/mockito

mockito/mockito/220

mockito/mockito/235

ad0b7e88056eb662ead86885667be6055708e67d

e696f60bcfc5bbcffb59f68f4981f1ef9e8574e3

2.0.8-beta -> 2.0.9-beta 'Unable to initialize @Spy annotated field

No test failures when using 2.0.8-beta, but when incrementing to 2.0.9-beta, the following error occurs: ``` org.mockito.exceptions.base.MockitoException: Unable to initialize @Spy annotated field 'monitorTaskScheduler'. Unable to create mock instance of type 'MonitorTaskScheduler' at net.project.dash.monitor.MonitorTaskScheduler$MockitoMock$1184625981.getExecutorService(Unknown Source) at net.project.dash.monitor.MonitorTaskScheduler.<init>(MonitorTaskScheduler.java:39) at net.project.dash.monitor.MonitorTaskScheduler$MockitoMock$1184625981.<init>(Unknown Source) at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:422) at org.mockito.internal.creation.instance.ConstructorInstantiator.invokeConstructor(ConstructorInstantiator.java:42) at org.mockito.internal.creation.instance.ConstructorInstantiator.noArgConstructor(ConstructorInstantiator.java:66) at org.mockito.internal.creation.instance.ConstructorInstantiator.newInstance(ConstructorInstantiator.java:17) at org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:27) at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:33) at org.mockito.internal.MockitoCore.mock(MockitoCore.java:59) at org.mockito.Mockito.mock(Mockito.java:1284) at org.mockito.internal.configuration.SpyAnnotationEngine.newSpyInstance(SpyAnnotationEngine.java:117) at org.mockito.internal.configuration.SpyAnnotationEngine.process(SpyAnnotationEngine.java:67) at org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:73) at org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:55) at org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:108) at net.project.dash.monitor.MonitorTaskSchedulerTest.setUp(MonitorTaskSchedulerTest.java:38) ``` Relevant code (MonitorTaskSchedulerTest.java) ``` java @Spy MonitorTaskScheduler monitorTaskScheduler; @Before public void setUp() { MockitoAnnotations.initMocks(this); } ``` Relevant code (MonitorTaskScheduler.java) ``` java public class MonitorTaskScheduler { public MonitorTaskScheduler() { this.futureToTaskMap = new ConcurrentHashMap<>(); } } ```

diff --git a/gradle/javadoc.gradle b/gradle/javadoc.gradle index c221c6277b..716fb6a102 100644 --- a/gradle/javadoc.gradle +++ b/gradle/javadoc.gradle @@ -35,8 +35,8 @@ task mockitoJavadoc(type: Javadoc) { <script type="text/javascript"> var usingOldIE = \$.browser.msie && parseInt(\$.browser.version) < 9; if(!usingOldIE) { - \$("head").append("<link rel=\\"shortcut icon\\" href=\\"@{docRoot}/favicon.ico?v=cafebabe\\">") - \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"@{docRoot}/favicon.ico?v=cafebabe\\">") + \$("head").append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">") + \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">") hljs.initHighlightingOnLoad(); injectProjectVersionForJavadocJDK6("Mockito ${project.version} API", "em#mockito-version-header-javadoc7-header", diff --git a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java index 1ec76d2c6f..2875df319d 100644 --- a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java +++ b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java @@ -1,8 +1,8 @@ package org.mockito.internal.creation.bytebuddy; -import static org.mockito.internal.util.StringJoiner.join; import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.InternalMockHandler; +import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.MockAccess; import org.mockito.internal.creation.instance.Instantiator; import org.mockito.internal.creation.instance.InstantiatorProvider; import org.mockito.invocation.MockHandler; @@ -10,6 +10,8 @@ import org.mockito.mock.SerializableMode; import org.mockito.plugins.MockMaker; +import static org.mockito.internal.util.StringJoiner.join; + public class ByteBuddyMockMaker implements MockMaker { private final CachingMockBytecodeGenerator cachingMockBytecodeGenerator; @@ -25,7 +27,7 @@ public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) { T mockInstance = null; try { mockInstance = instantiator.newInstance(mockedProxyType); - MockMethodInterceptor.MockAccess mockAccess = (MockMethodInterceptor.MockAccess) mockInstance; + MockAccess mockAccess = (MockAccess) mockInstance; mockAccess.setMockitoInterceptor(new MockMethodInterceptor(asInternalMockHandler(handler), settings)); return ensureMockIsAssignableToMockedType(settings, mockInstance); @@ -75,14 +77,14 @@ private static String describeClass(Object instance) { } public MockHandler getHandler(Object mock) { - if (!(mock instanceof MockMethodInterceptor.MockAccess)) { + if (!(mock instanceof MockAccess)) { return null; } - return ((MockMethodInterceptor.MockAccess) mock).getMockitoInterceptor().getMockHandler(); + return ((MockAccess) mock).getMockitoInterceptor().getMockHandler(); } public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) { - ((MockMethodInterceptor.MockAccess) mock).setMockitoInterceptor( + ((MockAccess) mock).setMockitoInterceptor( new MockMethodInterceptor(asInternalMockHandler(newHandler), settings) ); } diff --git a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java index 8d7c42d252..e4ae2bf8f9 100644 --- a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java +++ b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockBytecodeGenerator.java @@ -5,9 +5,17 @@ import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.dynamic.loading.ClassLoadingStrategy; import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy; +import net.bytebuddy.implementation.FieldAccessor; +import net.bytebuddy.implementation.Implementation; +import net.bytebuddy.implementation.MethodDelegation; import net.bytebuddy.implementation.attribute.MethodAttributeAppender; import net.bytebuddy.implementation.attribute.TypeAttributeAppender; +import net.bytebuddy.implementation.bind.annotation.FieldProxy; import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock; +import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod; +import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod.FieldGetter; +import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod.FieldSetter; +import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.MockAccess; import org.mockito.internal.creation.util.SearchingClassLoader; import java.util.Random; @@ -15,21 +23,25 @@ import static net.bytebuddy.description.modifier.FieldManifestation.FINAL; import static net.bytebuddy.description.modifier.Ownership.STATIC; import static net.bytebuddy.description.modifier.Visibility.PRIVATE; -import static net.bytebuddy.implementation.FieldAccessor.ofBeanProperty; import static net.bytebuddy.implementation.MethodDelegation.to; -import static net.bytebuddy.implementation.MethodDelegation.toInstanceField; -import static net.bytebuddy.matcher.ElementMatchers.*; +import static net.bytebuddy.matcher.ElementMatchers.any; +import static net.bytebuddy.matcher.ElementMatchers.isEquals; +import static net.bytebuddy.matcher.ElementMatchers.isHashCode; class MockBytecodeGenerator { private final ByteBuddy byteBuddy; private final Random random; + private final Implementation toDispatcher; public MockBytecodeGenerator() { byteBuddy = new ByteBuddy(ClassFileVersion.JAVA_V5) -// .withIgnoredMethods(isBridge()) .withDefaultMethodAttributeAppender(MethodAttributeAppender.ForInstrumentedMethod.INSTANCE) .withAttribute(TypeAttributeAppender.ForSuperType.INSTANCE); + // Necessary for ConstructorInstantiator + toDispatcher = MethodDelegation.to(DispatcherDefaultingToRealMethod.class) + .appendParameterBinder(FieldProxy.Binder.install(FieldGetter.class, + FieldSetter.class)); random = new Random(); } @@ -38,9 +50,9 @@ public <T> Class<? extends T> generateMockClass(MockFeatures<T> features) { byteBuddy.subclass(features.mockedType, ConstructorStrategy.Default.IMITATE_SUPER_TYPE) .name(nameFor(features.mockedType)) .implement(features.interfaces.toArray(new Class<?>[features.interfaces.size()])) - .method(any()).intercept(toInstanceField(MockMethodInterceptor.class, "mockitoInterceptor") - .filter(isDeclaredBy(MockMethodInterceptor.class))) - .implement(MockMethodInterceptor.MockAccess.class).intercept(ofBeanProperty()) + .method(any()).intercept(toDispatcher) + .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE) + .implement(MockAccess.class).intercept(FieldAccessor.ofBeanProperty()) .method(isHashCode()).intercept(to(MockMethodInterceptor.ForHashCode.class)) .method(isEquals()).intercept(to(MockMethodInterceptor.ForEquals.class)) .defineField("serialVersionUID", long.class, STATIC, PRIVATE, FINAL).value(42L); @@ -48,18 +60,19 @@ public <T> Class<? extends T> generateMockClass(MockFeatures<T> features) { builder = builder.implement(CrossClassLoaderSerializableMock.class) .intercept(to(MockMethodInterceptor.ForWriteReplace.class)); } - Class<?>[] allMockedTypes = new Class<?>[features.interfaces.size() + 1]; - allMockedTypes[0] = features.mockedType; -// System.arraycopy(interfaces.toArray(), 0, allMockedTypes, 1, interfaces.size()); - int index = 1; - for (Class<?> type : features.interfaces) { - allMockedTypes[index++] = type; - } return builder.make() - .load(SearchingClassLoader.combineLoadersOf(allMockedTypes), ClassLoadingStrategy.Default.INJECTION) + .load(SearchingClassLoader.combineLoadersOf(allMockedTypes(features)), ClassLoadingStrategy.Default.INJECTION) .getLoaded(); } + private <T> Class<?>[] allMockedTypes(MockFeatures<T> features) { + Class<?>[] allMockedTypes = new Class<?>[features.interfaces.size() + 1]; + allMockedTypes[0] = features.mockedType; + System.arraycopy(features.interfaces.toArray(), 0, + (Object[]) allMockedTypes, 1, features.interfaces.size()); + return allMockedTypes; + } + // TODO inspect naming strategy (for OSGI, signed package, java.* (and bootstrap classes), etc...) private String nameFor(Class<?> type) { String typeName = type.getName(); diff --git a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java index c70d849dc3..3e55e6cb0d 100644 --- a/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java +++ b/mockmaker/bytebuddy/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java @@ -1,9 +1,6 @@ package org.mockito.internal.creation.bytebuddy; -import java.io.ObjectStreamException; -import java.io.Serializable; -import java.lang.reflect.Method; -import java.util.concurrent.Callable; +import net.bytebuddy.implementation.bind.annotation.*; import org.mockito.internal.InternalMockHandler; import org.mockito.internal.creation.DelegatingMethod; import org.mockito.internal.invocation.MockitoMethod; @@ -11,14 +8,11 @@ import org.mockito.internal.progress.SequenceNumber; import org.mockito.invocation.MockHandler; import org.mockito.mock.MockCreationSettings; -import net.bytebuddy.implementation.bind.annotation.AllArguments; -import net.bytebuddy.implementation.bind.annotation.Argument; -import net.bytebuddy.implementation.bind.annotation.BindingPriority; -import net.bytebuddy.implementation.bind.annotation.DefaultCall; -import net.bytebuddy.implementation.bind.annotation.Origin; -import net.bytebuddy.implementation.bind.annotation.RuntimeType; -import net.bytebuddy.implementation.bind.annotation.SuperCall; -import net.bytebuddy.implementation.bind.annotation.This; + +import java.io.ObjectStreamException; +import java.io.Serializable; +import java.lang.reflect.Method; +import java.util.concurrent.Callable; public class MockMethodInterceptor implements Serializable { @@ -122,8 +116,53 @@ public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamEx } } - public static interface MockAccess { + public interface MockAccess { MockMethodInterceptor getMockitoInterceptor(); void setMockitoInterceptor(MockMethodInterceptor mockMethodInterceptor); } + + public static class DispatcherDefaultingToRealMethod { + public interface FieldGetter<T> { + T getValue(); + } + public interface FieldSetter<T> { + void setValue(T value); + } + + @RuntimeType + @BindingPriority(BindingPriority.DEFAULT * 2) + public static Object interceptSuperCallable(@This Object mock, + @FieldProxy("mockitoInterceptor") FieldGetter<MockMethodInterceptor> fieldGetter, + @Origin Method invokedMethod, + @AllArguments Object[] arguments, + @SuperCall(serializableProxy = true) Callable<?> superCall) throws Throwable { + MockMethodInterceptor interceptor = fieldGetter.getValue(); + if (interceptor == null) { + return superCall.call(); + } + return interceptor.doIntercept( + mock, + invokedMethod, + arguments, + new InterceptedInvocation.SuperMethod.FromCallable(superCall) + ); + } + + @RuntimeType + public static Object interceptAbstract(@This Object mock, + @FieldProxy("mockitoInterceptor") FieldGetter<MockMethodInterceptor> fieldGetter, + @Origin(cache = true) Method invokedMethod, + @AllArguments Object[] arguments) throws Throwable { + MockMethodInterceptor interceptor = fieldGetter.getValue(); + if (interceptor == null) { + return null; + } + return interceptor.doIntercept( + mock, + invokedMethod, + arguments, + InterceptedInvocation.SuperMethod.IsIllegal.INSTANCE + ); + } + } }

diff --git a/test/org/mockitousage/bugs/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java b/test/org/mockitousage/bugs/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java new file mode 100644 index 0000000000..af85e88f15 --- /dev/null +++ b/test/org/mockitousage/bugs/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java @@ -0,0 +1,46 @@ +package org.mockitousage.bugs; + +import org.junit.Test; +import org.junit.experimental.runners.Enclosed; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; +import org.mockito.Spy; + +@RunWith(Enclosed.class) +public class ConstructorInvokingMethodShouldNotRaiseExceptionTest { + + public static class WithDumbMethod { + @Spy + HasConstructorInvokingMethod hasConstructorInvokingMethod; + + @Test + public void should_be_able_to_create_spy() throws Exception { + MockitoAnnotations.initMocks(this); + } + + private static class HasConstructorInvokingMethod { + public HasConstructorInvokingMethod() { someMethod(); } + + void someMethod() { } + } + } + + public static class UsingMethodResult { + @Spy + HasConstructorInvokingMethod hasConstructorInvokingMethod; + + @Test + public void should_be_able_to_create_spy() throws Exception { + MockitoAnnotations.initMocks(this); + } + + private static class HasConstructorInvokingMethod { + private final boolean doesIt; + public HasConstructorInvokingMethod() { + doesIt = someMethod().contains("yup"); + } + + String someMethod() { return "tada!"; } + } + } +}

train

train

brcolow

train

mockito/mockito/244_247

mockito/mockito

mockito/mockito/244

mockito/mockito/247

dba9d50911870431ba891be8b9438ec326811482

4486887c02c436f12223e198818faa2544a16f9b

StackOverflowError in MockitoSerializationIssue.java

In MockitoSerializationIssue.filterStackTrace(), it calls `filter.filter(this)`, which then calls getStackTrace() again, causing an infinite recursion.

diff --git a/src/org/mockito/exceptions/base/MockitoSerializationIssue.java b/src/org/mockito/exceptions/base/MockitoSerializationIssue.java index 67a7387016..458b56dcc6 100644 --- a/src/org/mockito/exceptions/base/MockitoSerializationIssue.java +++ b/src/org/mockito/exceptions/base/MockitoSerializationIssue.java @@ -30,12 +30,6 @@ public MockitoSerializationIssue(String message, Exception cause) { filterStackTrace(); } - @Override - public StackTraceElement[] getStackTrace() { - filterStackTrace(); - return super.getStackTrace(); - } - private void filterStackTrace() { unfilteredStackTrace = super.getStackTrace();

diff --git a/test/org/mockito/exceptions/base/MockitoSerializationIssueTest.java b/test/org/mockito/exceptions/base/MockitoSerializationIssueTest.java new file mode 100644 index 0000000000..8e81b00939 --- /dev/null +++ b/test/org/mockito/exceptions/base/MockitoSerializationIssueTest.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2007 Mockito contributors + * This program is made available under the terms of the MIT License. + */ + +package org.mockito.exceptions.base; + +import org.junit.Test; +import org.mockito.internal.configuration.ConfigurationAccess; +import org.mockitoutil.TestBase; + +import java.util.Arrays; + +public class MockitoSerializationIssueTest extends TestBase { + + @Test + public void shouldFilterOutTestClassFromStacktraceWhenCleanFlagIsTrue() { + // given + ConfigurationAccess.getConfig().overrideCleansStackTrace(true); + + // when + MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause")); + + // then + assertContains("MockitoSerializationIssueTest", Arrays.toString(issue.getUnfilteredStackTrace())); + assertNotContains("MockitoSerializationIssueTest", Arrays.toString(issue.getStackTrace())); + } + + @Test + public void shouldKeepExecutingClassInStacktraceWhenCleanFlagIsFalse() { + // given + ConfigurationAccess.getConfig().overrideCleansStackTrace(false); + + // when + MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause")); + + // then + assertContains("MockitoSerializationIssueTest", Arrays.toString(issue.getUnfilteredStackTrace())); + assertContains("MockitoSerializationIssueTest", Arrays.toString(issue.getStackTrace())); + } +}

test

train

fluentfuture

train

mockito/mockito/251_252

mockito/mockito

mockito/mockito/251

mockito/mockito/252

037b0dbc2097f0d5aee0200d22bd46a79f8a34d3

5f4dbe782093df70566ff0ee1bacc3baf5aa1158

Unit tests improvements: migrate from legacy FEST Assert code to AssertJ

Triggered by #250.

diff --git a/build.gradle b/build.gradle index 635663b403..6bbc7b7efd 100644 --- a/build.gradle +++ b/build.gradle @@ -63,8 +63,7 @@ dependencies { testCompile 'org.ow2.asm:asm:5.0.4' - testCompile "org.easytesting:fest-assert:1.3" - testCompile "org.easytesting:fest-util:1.1.4" + testCompile 'org.assertj:assertj-core:2.1.0' testRuntime configurations.provided

diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest.java index 06ad4c6ed9..640142a15a 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest.java @@ -12,7 +12,7 @@ import java.util.HashMap; import java.util.List; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; @Listeners(MockitoTestNGListener.class) public class AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest { diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/CaptorAnnotatedFieldShouldBeClearedTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/CaptorAnnotatedFieldShouldBeClearedTest.java index 4a1b2ad959..79c3071408 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/CaptorAnnotatedFieldShouldBeClearedTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/CaptorAnnotatedFieldShouldBeClearedTest.java @@ -9,7 +9,7 @@ import java.util.List; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/ConfigurationMethodTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/ConfigurationMethodTest.java index a268a9a364..76095f3af4 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/ConfigurationMethodTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/ConfigurationMethodTest.java @@ -9,7 +9,7 @@ import java.io.IOException; import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.when; @Listeners(MockitoTestNGListener.class) diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/DontResetMocksIfNoListenerTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/DontResetMocksIfNoListenerTest.java index b8075dcab4..5cbe4fc20d 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/DontResetMocksIfNoListenerTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/DontResetMocksIfNoListenerTest.java @@ -8,7 +8,7 @@ import java.io.IOException; import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.when; public class DontResetMocksIfNoListenerTest { diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/EnsureMocksAreInitializedBeforeBeforeClassMethodTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/EnsureMocksAreInitializedBeforeBeforeClassMethodTest.java index 49eaeacd3f..c26075825c 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/EnsureMocksAreInitializedBeforeBeforeClassMethodTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/EnsureMocksAreInitializedBeforeBeforeClassMethodTest.java @@ -8,7 +8,7 @@ import java.util.Observer; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; @Listeners(MockitoTestNGListener.class) public class EnsureMocksAreInitializedBeforeBeforeClassMethodTest { diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/InitializeChildTestWhenParentHasListenerTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/InitializeChildTestWhenParentHasListenerTest.java index c69118efa4..2a8cb70685 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/InitializeChildTestWhenParentHasListenerTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/InitializeChildTestWhenParentHasListenerTest.java @@ -5,7 +5,7 @@ import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.testng.Assert.fail; public class InitializeChildTestWhenParentHasListenerTest extends ParentTest { diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/MockFieldsShouldBeResetBetweenTestMethodsTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/MockFieldsShouldBeResetBetweenTestMethodsTest.java index ba3214fae2..f6c3933b9d 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/MockFieldsShouldBeResetBetweenTestMethodsTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/MockFieldsShouldBeResetBetweenTestMethodsTest.java @@ -11,7 +11,7 @@ import java.util.List; import java.util.Observable; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.BDDMockito.given; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.never; diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest.java index 091a5d85a1..1133adfac9 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest.java @@ -10,7 +10,7 @@ import java.util.List; import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest { diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/TestNGShouldFailWhenMockitoListenerFailsTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/TestNGShouldFailWhenMockitoListenerFailsTest.java index 9720c94101..0870b9bb72 100644 --- a/subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/TestNGShouldFailWhenMockitoListenerFailsTest.java +++ b/subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/TestNGShouldFailWhenMockitoListenerFailsTest.java @@ -7,7 +7,7 @@ import org.testng.annotations.AfterMethod; import org.testng.annotations.Test; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.testng.Assert.assertTrue; @Test( diff --git a/subprojects/testng/testng.gradle b/subprojects/testng/testng.gradle index 1e6be98732..7b0fab9d6c 100644 --- a/subprojects/testng/testng.gradle +++ b/subprojects/testng/testng.gradle @@ -46,7 +46,7 @@ uploadArchives { dependencies { compile project.rootProject compile 'org.testng:testng:6.3.1' - testCompile 'org.easytesting:fest-assert:1.4' + testCompile 'org.assertj:assertj-core:2.1.0' } test { diff --git a/test/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java b/test/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java index 9635c9b103..09cdab4997 100644 --- a/test/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java +++ b/test/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java @@ -1,6 +1,6 @@ package org.mockito; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Ignore; import org.junit.Test; diff --git a/test/org/mockito/internal/configuration/MockInjectionTest.java b/test/org/mockito/internal/configuration/MockInjectionTest.java index fbb2f6e16f..32993ebd58 100644 --- a/test/org/mockito/internal/configuration/MockInjectionTest.java +++ b/test/org/mockito/internal/configuration/MockInjectionTest.java @@ -14,7 +14,7 @@ import java.util.Observer; import java.util.Set; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; @SuppressWarnings("unchecked") diff --git a/test/org/mockito/internal/creation/MockSettingsImplTest.java b/test/org/mockito/internal/creation/MockSettingsImplTest.java index 57fc5570a4..f67bcd78b3 100644 --- a/test/org/mockito/internal/creation/MockSettingsImplTest.java +++ b/test/org/mockito/internal/creation/MockSettingsImplTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.creation; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.Mock; import org.mockito.exceptions.base.MockitoException; diff --git a/test/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java b/test/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java index e8578bccf0..8b55b7f650 100644 --- a/test/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java +++ b/test/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java @@ -18,7 +18,7 @@ import java.util.List; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockitoutil.ClassLoaders.coverageTool; diff --git a/test/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGeneratorTest.java b/test/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGeneratorTest.java index cbbcfd840a..d66c152a2e 100644 --- a/test/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGeneratorTest.java +++ b/test/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGeneratorTest.java @@ -1,6 +1,6 @@ package org.mockito.internal.creation.bytebuddy; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assume.assumeTrue; import static org.mockito.internal.creation.bytebuddy.MockFeatures.withMockFeatures; import static org.mockitoutil.ClassLoaders.inMemoryClassLoader; diff --git a/test/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java b/test/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java index 6bf40a5b5e..c5e3c913c0 100644 --- a/test/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java +++ b/test/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java @@ -16,7 +16,7 @@ import java.io.ByteArrayOutputStream; import java.io.PrintStream; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class VerboseMockInvocationLoggerTest { diff --git a/test/org/mockito/internal/handler/InvocationNotifierHandlerTest.java b/test/org/mockito/internal/handler/InvocationNotifierHandlerTest.java index 5216f74168..1adb2a22cc 100644 --- a/test/org/mockito/internal/handler/InvocationNotifierHandlerTest.java +++ b/test/org/mockito/internal/handler/InvocationNotifierHandlerTest.java @@ -22,7 +22,7 @@ import java.text.ParseException; import java.util.ArrayList; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.willThrow; diff --git a/test/org/mockito/internal/invocation/InvocationMatcherTest.java b/test/org/mockito/internal/invocation/InvocationMatcherTest.java index 282bd8a1bf..a866f0fcbb 100644 --- a/test/org/mockito/internal/invocation/InvocationMatcherTest.java +++ b/test/org/mockito/internal/invocation/InvocationMatcherTest.java @@ -5,7 +5,7 @@ package org.mockito.internal.invocation; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentMatcher; diff --git a/test/org/mockito/internal/matchers/CapturingMatcherTest.java b/test/org/mockito/internal/matchers/CapturingMatcherTest.java index b3bbbc76ce..783e03663e 100644 --- a/test/org/mockito/internal/matchers/CapturingMatcherTest.java +++ b/test/org/mockito/internal/matchers/CapturingMatcherTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.matchers; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.base.MockitoException; import org.mockitoutil.TestBase; diff --git a/test/org/mockito/internal/matchers/VarargCapturingMatcherTest.java b/test/org/mockito/internal/matchers/VarargCapturingMatcherTest.java index d6763fc0a3..6d517087a3 100644 --- a/test/org/mockito/internal/matchers/VarargCapturingMatcherTest.java +++ b/test/org/mockito/internal/matchers/VarargCapturingMatcherTest.java @@ -5,7 +5,7 @@ import org.mockito.exceptions.base.MockitoException; import static java.util.Arrays.asList; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; public class VarargCapturingMatcherTest { diff --git a/test/org/mockito/internal/progress/HandyReturnValuesTest.java b/test/org/mockito/internal/progress/HandyReturnValuesTest.java index f9ddd0e7e0..1894dea7a0 100644 --- a/test/org/mockito/internal/progress/HandyReturnValuesTest.java +++ b/test/org/mockito/internal/progress/HandyReturnValuesTest.java @@ -6,7 +6,7 @@ import org.junit.Test; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; diff --git a/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java b/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java index 9ec0d7ea6f..431c395a24 100644 --- a/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java +++ b/test/org/mockito/internal/stubbing/answers/AnswersValidatorTest.java @@ -15,7 +15,7 @@ import java.nio.charset.CharacterCodingException; import java.util.ArrayList; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.Mockito.mock; diff --git a/test/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java b/test/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java index 9977eb6fcb..44481ddc9c 100644 --- a/test/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java +++ b/test/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.stubbing.answers; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import org.junit.Test; import org.mockito.internal.invocation.InvocationBuilder; diff --git a/test/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java b/test/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java index a9422f8525..44066b8ced 100644 --- a/test/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java +++ b/test/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java @@ -11,7 +11,7 @@ import java.util.Map; import java.util.Set; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; diff --git a/test/org/mockito/internal/util/MockCreationValidatorTest.java b/test/org/mockito/internal/util/MockCreationValidatorTest.java index 1cf6f8beb2..f911e4f7be 100644 --- a/test/org/mockito/internal/util/MockCreationValidatorTest.java +++ b/test/org/mockito/internal/util/MockCreationValidatorTest.java @@ -14,7 +14,7 @@ import java.util.Observer; import static java.util.Arrays.asList; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; @SuppressWarnings("unchecked") diff --git a/test/org/mockito/internal/util/MockUtilTest.java b/test/org/mockito/internal/util/MockUtilTest.java index 726804f9a6..43b0afd2fc 100644 --- a/test/org/mockito/internal/util/MockUtilTest.java +++ b/test/org/mockito/internal/util/MockUtilTest.java @@ -5,7 +5,7 @@ package org.mockito.internal.util; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.Mockito; import org.mockito.exceptions.base.MockitoException; diff --git a/test/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java b/test/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java index 366595e15b..e8dc0c2688 100644 --- a/test/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java +++ b/test/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java @@ -10,7 +10,7 @@ import java.util.List; import java.util.Observer; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; public class HashCodeAndEqualsSafeSetTest { diff --git a/test/org/mockito/internal/util/junit/JUnitFailureHackerTest.java b/test/org/mockito/internal/util/junit/JUnitFailureHackerTest.java index 1409f07b22..5a0fbebc5c 100644 --- a/test/org/mockito/internal/util/junit/JUnitFailureHackerTest.java +++ b/test/org/mockito/internal/util/junit/JUnitFailureHackerTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.util.junit; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.junit.runner.Description; import org.junit.runner.notification.Failure; diff --git a/test/org/mockito/internal/util/reflection/BeanPropertySetterTest.java b/test/org/mockito/internal/util/reflection/BeanPropertySetterTest.java index 9bd1a8d681..a0b6119a8b 100644 --- a/test/org/mockito/internal/util/reflection/BeanPropertySetterTest.java +++ b/test/org/mockito/internal/util/reflection/BeanPropertySetterTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.util.reflection; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import java.io.File; diff --git a/test/org/mockito/internal/util/reflection/FieldsTest.java b/test/org/mockito/internal/util/reflection/FieldsTest.java index ef8409fc54..d86fb30370 100644 --- a/test/org/mockito/internal/util/reflection/FieldsTest.java +++ b/test/org/mockito/internal/util/reflection/FieldsTest.java @@ -8,7 +8,7 @@ import java.lang.reflect.Field; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.internal.util.reflection.Fields.syntheticField; public class FieldsTest { diff --git a/test/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java b/test/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java index 3beb894793..565e14bbda 100644 --- a/test/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java +++ b/test/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.util.reflection; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.internal.util.reflection.GenericMetadataSupport.inferFrom; @@ -73,19 +73,19 @@ public void can_get_raw_type_from_ParameterizedType() throws Exception { @Test public void can_get_type_variables_from_Class() throws Exception { - assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet()).hasSize(1).onProperty("name").contains("K"); + assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("K"); assertThat(inferFrom(ListOfNumbers.class).actualTypeArguments().keySet()).isEmpty(); - assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet()).hasSize(1).onProperty("name").contains("N"); - assertThat(inferFrom(Map.class).actualTypeArguments().keySet()).hasSize(2).onProperty("name").contains("K", "V"); + assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("N"); + assertThat(inferFrom(Map.class).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V"); assertThat(inferFrom(Serializable.class).actualTypeArguments().keySet()).isEmpty(); assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty(); } @Test public void can_get_type_variables_from_ParameterizedType() throws Exception { - assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(2).onProperty("name").contains("K", "V"); - assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).onProperty("name").contains("E"); - assertThat(inferFrom(Integer.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).onProperty("name").contains("T"); + assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V"); + assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("E"); + assertThat(inferFrom(Integer.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("T"); assertThat(inferFrom(StringBuilder.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).isEmpty(); assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty(); } diff --git a/test/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java b/test/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java index ada6a84113..2d234c0c5f 100644 --- a/test/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java +++ b/test/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java @@ -22,7 +22,7 @@ import java.util.Observer; import java.util.Set; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.fail; import static org.mockito.BDDMockito.given; diff --git a/test/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java b/test/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java index 4a635b7e7d..677a81a96a 100644 --- a/test/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java +++ b/test/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java @@ -5,7 +5,7 @@ import java.lang.reflect.Field; import java.util.*; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; @SuppressWarnings("unused") public class SuperTypesLastSorterTest { diff --git a/test/org/mockito/internal/verification/NoMoreInteractionsTest.java b/test/org/mockito/internal/verification/NoMoreInteractionsTest.java index ff87144842..725085b830 100644 --- a/test/org/mockito/internal/verification/NoMoreInteractionsTest.java +++ b/test/org/mockito/internal/verification/NoMoreInteractionsTest.java @@ -4,7 +4,7 @@ */ package org.mockito.internal.verification; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.verification.NoInteractionsWanted; import org.mockito.exceptions.verification.VerificationInOrderFailure; diff --git a/test/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java b/test/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java index 1438ddf0b9..ba889814bd 100644 --- a/test/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java +++ b/test/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java @@ -5,7 +5,7 @@ package org.mockitousage.annotation; -import static org.fest.assertions.Assertions.*; +import static org.assertj.core.api.Assertions.*; import org.junit.Test; import org.junit.runner.RunWith; diff --git a/test/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java b/test/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java index 6a8857a547..816863a04a 100644 --- a/test/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java +++ b/test/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java @@ -24,7 +24,7 @@ import java.util.List; import java.util.Set; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; diff --git a/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java b/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java index a530084da1..9b51e0b243 100644 --- a/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java +++ b/test/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java @@ -4,7 +4,7 @@ */ package org.mockitousage.annotation; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; import org.mockito.InjectMocks; diff --git a/test/org/mockitousage/annotation/SpyAnnotationTest.java b/test/org/mockitousage/annotation/SpyAnnotationTest.java index b67f1365cd..77f6b5e3ed 100644 --- a/test/org/mockitousage/annotation/SpyAnnotationTest.java +++ b/test/org/mockitousage/annotation/SpyAnnotationTest.java @@ -13,7 +13,7 @@ import java.util.Arrays; import java.util.LinkedList; import java.util.List; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; diff --git a/test/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java b/test/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java index 4f909dbc2f..8e6225d565 100644 --- a/test/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java +++ b/test/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java @@ -5,7 +5,7 @@ package org.mockitousage.annotation; import java.util.List; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Captor; diff --git a/test/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java b/test/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java index de78ac8d55..a7517c605b 100644 --- a/test/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java +++ b/test/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java @@ -5,8 +5,8 @@ package org.mockitousage.basicapi; -import static org.fest.assertions.Assertions.assertThat; -import static org.fest.assertions.Fail.fail; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.withSettings; import static org.mockitoutil.ClassLoaders.inMemoryClassLoader; diff --git a/test/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java b/test/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java index 214c7c0a47..e0016e5ee6 100644 --- a/test/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java +++ b/test/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java @@ -24,7 +24,7 @@ import java.util.Collections; import java.util.List; import java.util.Observable; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mock; diff --git a/test/org/mockitousage/basicapi/MocksSerializationTest.java b/test/org/mockitousage/basicapi/MocksSerializationTest.java index 90056c61ed..79f36ea387 100644 --- a/test/org/mockitousage/basicapi/MocksSerializationTest.java +++ b/test/org/mockitousage/basicapi/MocksSerializationTest.java @@ -26,7 +26,7 @@ import java.util.Collections; import java.util.List; import java.util.Observable; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mockito; diff --git a/test/org/mockitousage/bugs/EqualsWithDeltaTest.java b/test/org/mockitousage/bugs/EqualsWithDeltaTest.java index da6d9281ff..582a6a1ece 100644 --- a/test/org/mockitousage/bugs/EqualsWithDeltaTest.java +++ b/test/org/mockitousage/bugs/EqualsWithDeltaTest.java @@ -4,7 +4,7 @@ import org.mockito.ArgumentMatcher; import org.mockito.internal.matchers.EqualsWithDelta; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class EqualsWithDeltaTest { diff --git a/test/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java b/test/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java index c66291d4c3..e462276863 100644 --- a/test/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java +++ b/test/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java @@ -10,7 +10,7 @@ import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.mock; diff --git a/test/org/mockitousage/bugs/ParentClassNotPublicTest.java b/test/org/mockitousage/bugs/ParentClassNotPublicTest.java index 961b150ec1..8b6c0f78e2 100644 --- a/test/org/mockitousage/bugs/ParentClassNotPublicTest.java +++ b/test/org/mockitousage/bugs/ParentClassNotPublicTest.java @@ -4,7 +4,7 @@ */ package org.mockitousage.bugs; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Assume; import org.junit.Before; import org.junit.Test; diff --git a/test/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java b/test/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java index 6e297efce7..82b6241dc5 100644 --- a/test/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java +++ b/test/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java @@ -5,7 +5,7 @@ package org.mockitousage.bugs; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.Spy; import org.mockitoutil.TestBase; diff --git a/test/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java b/test/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java index 3751a89047..568ef18ad4 100644 --- a/test/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java +++ b/test/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java @@ -5,7 +5,7 @@ package org.mockitousage.bugs.creation; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.Mock; import org.mockito.Spy; diff --git a/test/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java b/test/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java index 6344fab10c..8c20f80d92 100644 --- a/test/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java +++ b/test/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java @@ -2,7 +2,7 @@ import org.junit.Test; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; diff --git a/test/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java b/test/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java index 26b075ea1c..f6acc8a375 100644 --- a/test/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java +++ b/test/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java @@ -10,7 +10,7 @@ import java.util.HashMap; import java.util.Map; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertSame; @RunWith(MockitoJUnitRunner.class) diff --git a/test/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java b/test/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java index 9193b95b2f..25d8604230 100644 --- a/test/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java +++ b/test/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java @@ -5,11 +5,11 @@ package org.mockitousage.configuration; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.Mockito.mock; import java.util.concurrent.Callable; -import org.fest.assertions.Condition; +import org.assertj.core.api.Condition; import org.junit.Assume; import org.junit.Test; import org.mockito.exceptions.base.MockitoException; @@ -38,8 +38,8 @@ public void should_throw_ClassCastException_on_second_call() throws Exception { .containsIgnoringCase("objenesis") .containsIgnoringCase("MockitoConfiguration"); assertThat(e.getCause()) - .satisfies(thatCceIsThrownFrom("java.lang.Class.cast")) - .satisfies(thatCceIsThrownFrom("org.mockito.internal.creation.cglib.ClassImposterizer.imposterise")); + .has(cceIsThrownFrom("java.lang.Class.cast")) + .has(cceIsThrownFrom("org.mockito.internal.creation.cglib.ClassImposterizer.imposterise")); } } @@ -51,7 +51,7 @@ public void should_not_throw_ClassCastException_when_objenesis_cache_disabled() doInNewChildRealm(testMethodClassLoaderRealm, "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking"); } - private Condition<Throwable> thatCceIsThrownFrom(final String stacktraceElementDescription) { + private Condition<Throwable> cceIsThrownFrom(final String stacktraceElementDescription) { return new Condition<Throwable>() { @Override public boolean matches(Throwable throwable) { diff --git a/test/org/mockitousage/debugging/InvocationListenerCallbackTest.java b/test/org/mockitousage/debugging/InvocationListenerCallbackTest.java index 040b06c3a8..56828dd4a8 100644 --- a/test/org/mockitousage/debugging/InvocationListenerCallbackTest.java +++ b/test/org/mockitousage/debugging/InvocationListenerCallbackTest.java @@ -10,7 +10,7 @@ import org.mockito.listeners.InvocationListener; import org.mockito.listeners.MethodInvocationReport; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.willReturn; diff --git a/test/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java b/test/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java index 588e62abb3..3dbaa0ffea 100644 --- a/test/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java +++ b/test/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java @@ -12,7 +12,7 @@ import static org.mockito.Mockito.withSettings; import java.io.ByteArrayOutputStream; import java.io.PrintStream; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.After; import org.junit.Before; import org.junit.Test; diff --git a/test/org/mockitousage/matchers/CapturingArgumentsTest.java b/test/org/mockitousage/matchers/CapturingArgumentsTest.java index 379075d414..43c362a9b4 100644 --- a/test/org/mockitousage/matchers/CapturingArgumentsTest.java +++ b/test/org/mockitousage/matchers/CapturingArgumentsTest.java @@ -5,7 +5,7 @@ package org.mockitousage.matchers; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.exceptions.base.MockitoException; diff --git a/test/org/mockitousage/matchers/InvalidUseOfMatchersTest.java b/test/org/mockitousage/matchers/InvalidUseOfMatchersTest.java index 7b12324806..756c9d0388 100644 --- a/test/org/mockitousage/matchers/InvalidUseOfMatchersTest.java +++ b/test/org/mockitousage/matchers/InvalidUseOfMatchersTest.java @@ -14,7 +14,7 @@ import org.mockito.runners.MockitoJUnitRunner; import org.mockitousage.IMethods; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.when; diff --git a/test/org/mockitousage/misuse/SpyStubbingMisuseTest.java b/test/org/mockitousage/misuse/SpyStubbingMisuseTest.java index 7d9cabdae0..77179ad292 100644 --- a/test/org/mockitousage/misuse/SpyStubbingMisuseTest.java +++ b/test/org/mockitousage/misuse/SpyStubbingMisuseTest.java @@ -8,7 +8,7 @@ import org.mockito.exceptions.misusing.WrongTypeOfReturnValue; import static org.junit.Assert.fail; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.*; public class SpyStubbingMisuseTest { diff --git a/test/org/mockitousage/serialization/DeepStubsSerializableTest.java b/test/org/mockitousage/serialization/DeepStubsSerializableTest.java index 800a58e2e1..bdd5cee862 100644 --- a/test/org/mockitousage/serialization/DeepStubsSerializableTest.java +++ b/test/org/mockitousage/serialization/DeepStubsSerializableTest.java @@ -1,6 +1,6 @@ package org.mockitousage.serialization; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; diff --git a/test/org/mockitousage/stubbing/DeepStubbingTest.java b/test/org/mockitousage/stubbing/DeepStubbingTest.java index be8bcaa33b..77fbdd28c3 100644 --- a/test/org/mockitousage/stubbing/DeepStubbingTest.java +++ b/test/org/mockitousage/stubbing/DeepStubbingTest.java @@ -22,7 +22,7 @@ import java.net.Socket; import java.util.Locale; import javax.net.SocketFactory; -import org.fest.assertions.Assertions; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.InOrder; import org.mockito.exceptions.verification.TooManyActualInvocations; diff --git a/test/org/mockitousage/stubbing/StubbingWithAdditionalAnswers.java b/test/org/mockitousage/stubbing/StubbingWithAdditionalAnswers.java index 3f428ad24a..0ba0430e3c 100644 --- a/test/org/mockitousage/stubbing/StubbingWithAdditionalAnswers.java +++ b/test/org/mockitousage/stubbing/StubbingWithAdditionalAnswers.java @@ -10,7 +10,7 @@ import org.mockito.runners.MockitoJUnitRunner; import org.mockitousage.IMethods; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.AdditionalAnswers.returnsArgAt; import static org.mockito.AdditionalAnswers.returnsFirstArg; import static org.mockito.AdditionalAnswers.returnsLastArg; diff --git a/test/org/mockitousage/stubbing/StubbingWithDelegateTest.java b/test/org/mockitousage/stubbing/StubbingWithDelegateTest.java index bc4494a473..e8fc92ab43 100644 --- a/test/org/mockitousage/stubbing/StubbingWithDelegateTest.java +++ b/test/org/mockitousage/stubbing/StubbingWithDelegateTest.java @@ -4,7 +4,7 @@ */ package org.mockitousage.stubbing; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockito.AdditionalAnswers.delegatesTo; import static org.mockito.Mockito.doReturn; diff --git a/test/org/mockitoutil/ClassLoadersTest.java b/test/org/mockitoutil/ClassLoadersTest.java index 1f6b0900bd..557ecfe446 100644 --- a/test/org/mockitoutil/ClassLoadersTest.java +++ b/test/org/mockitoutil/ClassLoadersTest.java @@ -3,7 +3,7 @@ import org.junit.Test; import org.mockito.Mockito; -import static org.fest.assertions.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; import static org.mockitoutil.ClassLoaders.currentClassLoader; import static org.mockitoutil.ClassLoaders.excludingClassLoader;

test

train

szpak

train

mockito/mockito/260_261

mockito/mockito

mockito/mockito/260

mockito/mockito/261

817b04b82ee802f0cf9009952521d1d7496c69d7

298330658c63b36a154470f742e829bdf713c921

Typo in documentation

Very minor thing, there's an extra "at" (@) in the documentation. If you go to http://site.mockito.org/mockito/docs/current/org/mockito/Mockito.html#33 

diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index 1e833596a2..72e4b28c08 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -1051,7 +1051,7 @@ * such as <code>&#064;{@link Mock}</code>, <code>&#064;{@link Spy}</code>, <code>&#064;{@link InjectMocks}</code>, etc. * * <ul> - * <li>Annotating the JUnit test class with a <code>&#064;{@link org.junit.runner.RunWith}(&#064;{@link MockitoJUnitRunner}.class)</code></li> + * <li>Annotating the JUnit test class with a <code>&#064;{@link org.junit.runner.RunWith}({@link MockitoJUnitRunner}.class)</code></li> * <li>Invoking <code>{@link MockitoAnnotations#initMocks(Object)}</code> in the <code>&#064;{@link org.junit.Before}</code> method</li> * </ul> *

train

train

carlos-aguayo

train

mockito/mockito/243_280

mockito/mockito

mockito/mockito/243

mockito/mockito/280

2f88f06d6b0e851ff8ed2125085d3faac3f4ee1b

27e074066ecec55ed086f7430246ef1c8818819f

MockUtil.isMock() no longer checks null

In version 1.9.5, MockUtil.isMock() is defined as: ``` return instance != null && isMockitoMock(instance); ``` In v1.10.19 and HEAD, the `instance != null` check is gone. This method is called by MockScanner when injecting mock instances on fields, where field values can be null. Is this a bug? Or it's up to MockMaker.getHandler() to check for null? If it's a bug, I can fix it. But then we'll need to wait for v2.0 before upgrading Mockito for the company's code base. If it's up to the mock maker, then I guess we need to fix Google's DexmakerMockMaker to add a line of `if (mock == null) return null;`

diff --git a/src/main/java/org/mockito/internal/util/MockUtil.java b/src/main/java/org/mockito/internal/util/MockUtil.java index 96b47a73bf..3ea20cded9 100644 --- a/src/main/java/org/mockito/internal/util/MockUtil.java +++ b/src/main/java/org/mockito/internal/util/MockUtil.java @@ -70,7 +70,7 @@ public boolean isSpy(Object mock) { } private <T> boolean isMockitoMock(T mock) { - return mockMaker.getHandler(mock) != null; + return mock != null && mockMaker.getHandler(mock) != null; } public MockName getMockName(Object mock) {

test

train

fluentfuture

train

mockito/mockito/183_286

mockito/mockito

mockito/mockito/183

mockito/mockito/286

971be4d8184ec916a5ebc2395050804da22b5b33

318d92fe4effc1ff23c62b4909538307239b7e7c

Feature request: Method to reset mock interactions/invocations without resetting stubs

I'm still missing the ability to reset the invocations on a mock, while keeping all the stubbing, so this is a GitHub equivalent of https://code.google.com/p/mockito/issues/detail?id=316 Some background discussion exists in a [thread](https://groups.google.com/forum/#!topic/mockito/5G-XnpIhP3s) that also refers to [issue 84](https://code.google.com/p/mockito/issues/detail?id=84) for which there already [is a GitHub issue](https://github.com/mockito/mockito/issues/86).

diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index 25db83abee..302bd6cce6 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -1703,6 +1703,21 @@ public static <T> void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } + /** + * Use this method in order to only clear invocations, when stubbing is non-trivial. Use-cases can be: + * <ul> + * <li>You are using a dependency injection framework to inject your mocks.</li> + * <li>The mock is used in a stateful scenario. For example a class is Singleton which depends on your mock.</li> + * </ul> + * + * <b>Try to avoid this method at all costs. Only clear invocations if you are unable to efficiently test your program.</b> + * @param <T> The type of the mocks + * @param mocks The mocks to clear the invocations for + */ + public static <T> void clearInvocations(T ... mocks) { + MOCKITO_CORE.clearInvocations(mocks); + } + /** * Checks if any of given mocks has any unverified interaction. * <p> diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java index 8ad222f849..e6dcb469bc 100644 --- a/src/main/java/org/mockito/internal/MockitoCore.java +++ b/src/main/java/org/mockito/internal/MockitoCore.java @@ -95,6 +95,16 @@ public <T> void reset(T ... mocks) { mockUtil.resetMock(m); } } + + public <T> void clearInvocations(T ... mocks) { + mockingProgress.validateState(); + mockingProgress.reset(); + mockingProgress.resetOngoingStubbing(); + + for (T m : mocks) { + mockUtil.getMockHandler(m).getInvocationContainer().clearInvocations(); + } + } public void verifyNoMoreInteractions(Object... mocks) { assertMocksNotEmpty(mocks); @@ -182,4 +192,5 @@ public Object[] ignoreStubs(Object... mocks) { public MockingDetails mockingDetails(Object toInspect) { return new DefaultMockingDetails(toInspect, new MockUtil()); } + } diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainer.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainer.java index 0e82e85cb9..b926183f63 100644 --- a/src/main/java/org/mockito/internal/stubbing/InvocationContainer.java +++ b/src/main/java/org/mockito/internal/stubbing/InvocationContainer.java @@ -12,5 +12,7 @@ public interface InvocationContainer { List<Invocation> getInvocations(); + void clearInvocations(); + List<StubbedInvocationMatcher> getStubbedInvocations(); } diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java index 9d10ab9bce..fb391e3cef 100644 --- a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java +++ b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java @@ -121,6 +121,10 @@ public List<Invocation> getInvocations() { return registeredInvocations.getAll(); } + public void clearInvocations() { + registeredInvocations.clear(); + } + public List<StubbedInvocationMatcher> getStubbedInvocations() { return stubbed; } diff --git a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java index a9690066a2..7b6442bdd2 100644 --- a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java +++ b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java @@ -44,6 +44,12 @@ public List<Invocation> getAll() { return ListUtil.filter(copiedList, new RemoveToString()); } + public void clear() { + synchronized (invocations) { + invocations.clear(); + } + } + public boolean isEmpty() { synchronized (invocations) { return invocations.isEmpty(); diff --git a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java index 1cb2131775..75c0b3f224 100644 --- a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java +++ b/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java @@ -21,6 +21,8 @@ public interface RegisteredInvocations { List<Invocation> getAll(); + void clear(); + boolean isEmpty(); } diff --git a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java b/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java index 07da74c378..67ceafa52e 100644 --- a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java +++ b/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java @@ -27,6 +27,10 @@ public List<Invocation> getAll() { return Collections.emptyList(); } + public void clear() { + invocation = null; + } + public boolean isEmpty() { return invocation == null; }

diff --git a/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java b/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java new file mode 100644 index 0000000000..3f18478086 --- /dev/null +++ b/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java @@ -0,0 +1,48 @@ +package org.mockitousage.basicapi; + +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.exceptions.misusing.NotAMockException; +import org.mockitousage.IMethods; +import org.mockitoutil.TestBase; + +import static org.mockito.Mockito.*; + +public class ResetInvocationsTest extends TestBase { + + @Mock IMethods methods; + @Mock IMethods moarMethods; + + @Test + public void reset_invocations_should_reset_only_invocations() { + when(methods.simpleMethod()).thenReturn("return"); + + methods.simpleMethod(); + verify(methods).simpleMethod(); + + clearInvocations(methods); + + verifyNoMoreInteractions(methods); + assertEquals("return", methods.simpleMethod()); + } + + @Test + public void should_reset_invocations_on_multiple_mocks() { + methods.simpleMethod(); + moarMethods.simpleMethod(); + + clearInvocations(methods, moarMethods); + + verifyNoMoreInteractions(methods, moarMethods); + } + + @Test(expected = NotAMockException.class) + public void resettingNonMockIsSafe() { + clearInvocations(""); + } + + @Test(expected = NotAMockException.class) + public void resettingNullIsSafe() { + clearInvocations(new Object[]{null}); + } +}

test

train

mjiderhamn

train

mockito/mockito/124_287

mockito/mockito

mockito/mockito/124

mockito/mockito/287

495406554354a23980ac40fb991c1dae8f4105aa

08b0daeea01e17a63b0c817ff3139ab918aec710

Concise way to collect multiple verify failures, ideally with JUnitCollector or derivative

If you are using more than one verify statement as test post-conditions, it would be nice to be able to collect each failure and continue with the remaining verify statements or asserts that follow. JUnit provides the ErrorCollector @Rule to facilitate this kid of thing, but the current [ErrorCollector API](http://junit.org/apidocs/org/junit/rules/ErrorCollector.html) requires either - a Matcher<T> and a value to compare - or a Callable<Object> The Mockito verify statements only return void, however, since they depend on throwing exceptions. I have not thought of an ideal, non-disruptive way to use JUnit's ErrorCollector to aggregate multiple Mockito verify failure

diff --git a/src/main/java/org/mockito/junit/MockitoJUnit.java b/src/main/java/org/mockito/junit/MockitoJUnit.java index f13b667796..b680079e80 100644 --- a/src/main/java/org/mockito/junit/MockitoJUnit.java +++ b/src/main/java/org/mockito/junit/MockitoJUnit.java @@ -16,4 +16,14 @@ public class MockitoJUnit { public static MockitoRule rule() { return new MockitoJUnitRule(); } + + /** + * Creates a rule instance that can perform lazy verifications. + * + * @see VerificationCollector + * @return the rule instance + */ + public static VerificationCollector collector() { + return new VerificationCollectorImpl(); + } } diff --git a/src/main/java/org/mockito/junit/VerificationCollector.java b/src/main/java/org/mockito/junit/VerificationCollector.java new file mode 100644 index 0000000000..432dc55b36 --- /dev/null +++ b/src/main/java/org/mockito/junit/VerificationCollector.java @@ -0,0 +1,62 @@ +package org.mockito.junit; + +import org.junit.rules.TestRule; +import org.mockito.exceptions.base.MockitoAssertionError; +import org.mockito.verification.VerificationMode; + +/** + * Use this rule in order to collect multiple verification failures and report at once. + * + * In the example below, the verification failure thrown by {@code byteReturningMethod()} does not block + * verifying against the {@code simpleMethod()}. After the test is run, a report is generated stating all + * collect verification failures. + * + * <pre class="code"><code class="java"> + * &#064;Rule + * public VerificationCollector collector = MockitoJUnit.collector(); + * + * &#064;Test + * public void should_fail() { + * IMethods methods = mock(IMethods.class); + * + * collector.verify(methods).byteReturningMethod(); + * collector.verify(methods).simpleMethod(); + * } + * </code></pre> + * + * @see org.mockito.Mockito#verify(Object) + * @see org.mockito.Mockito#verify(Object, VerificationMode) + */ +public interface VerificationCollector extends TestRule { + + /** + * Lazily verify certain behaviour happened once. + * + * @see org.mockito.Mockito#verify(Object) + * + * @param <T> The type of the mock + * @param mock to be verified + * @return mock object itself + */ + <T> T verify(T mock); + + /** + * Lazily verify certain behaviour happened at least once / exact number of times / never. + * + * @see org.mockito.Mockito#verify(Object, VerificationMode) + * + * @param mock to be verified + * @param mode times(x), atLeastOnce() or never() + * @param <T> The type of the mock + * @return mock object itself + */ + <T> T verify(T mock, VerificationMode mode); + + /** + * Collect all lazily verified behaviour. If there were failed verifications, it will + * throw a MockitoAssertionError containing all messages indicating the failed verifications. + * + * @throws MockitoAssertionError If there were failed verifications + */ + void collectAndReport() throws MockitoAssertionError; +} diff --git a/src/main/java/org/mockito/junit/VerificationCollectorImpl.java b/src/main/java/org/mockito/junit/VerificationCollectorImpl.java new file mode 100644 index 0000000000..64b7ec2697 --- /dev/null +++ b/src/main/java/org/mockito/junit/VerificationCollectorImpl.java @@ -0,0 +1,89 @@ +package org.mockito.junit; + +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runners.model.Statement; +import org.mockito.exceptions.base.MockitoAssertionError; +import org.mockito.internal.MockitoCore; +import org.mockito.internal.verification.api.VerificationData; +import org.mockito.verification.VerificationMode; + +import static org.mockito.Mockito.times; + +/** + * Mockito implementation of VerificationCollector. + */ +class VerificationCollectorImpl implements VerificationCollector { + + private static final MockitoCore MOCKITO_CORE = new MockitoCore(); + + private StringBuilder builder; + private int numberOfFailures; + + public VerificationCollectorImpl() { + this.resetBuilder(); + } + + public Statement apply(final Statement base, final Description description) { + return new Statement() { + @Override + public void evaluate() throws Throwable { + base.evaluate(); + VerificationCollectorImpl.this.collectAndReport(); + } + }; + } + + public <T> T verify(T mock) { + return MOCKITO_CORE.verify(mock, new VerificationWrapper(times(1))); + } + + public <T> T verify(T mock, VerificationMode mode) { + return MOCKITO_CORE.verify(mock, new VerificationWrapper(mode)); + } + + public void collectAndReport() throws MockitoAssertionError { + if (this.numberOfFailures > 0) { + String error = this.builder.toString(); + + this.resetBuilder(); + + throw new MockitoAssertionError(error); + } + } + + private void resetBuilder() { + this.builder = new StringBuilder() + .append("There were multiple verification failures:"); + this.numberOfFailures = 0; + } + + private void append(String message) { + this.numberOfFailures++; + this.builder.append('\n') + .append(this.numberOfFailures).append(". ") + .append(message.substring(1, message.length())); + } + + private class VerificationWrapper implements VerificationMode { + + private final VerificationMode delegate; + + private VerificationWrapper(VerificationMode delegate) { + this.delegate = delegate; + } + + public void verify(VerificationData data) { + try { + this.delegate.verify(data); + } catch (MockitoAssertionError error) { + VerificationCollectorImpl.this.append(error.getMessage()); + } + } + + public VerificationMode description(String description) { + throw new IllegalStateException("Should not fail in this mode"); + } + } + +}

diff --git a/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java b/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java new file mode 100644 index 0000000000..4749304fee --- /dev/null +++ b/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java @@ -0,0 +1,121 @@ +package org.mockitousage.junitrule; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.mockito.exceptions.base.MockitoAssertionError; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.VerificationCollector; +import org.mockitousage.IMethods; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; + +public class VerificationCollectorImplTest { + + @Test + public void should_not_throw_any_exceptions_when_verifications_are_succesful() { + VerificationCollector collector = MockitoJUnit.collector(); + + IMethods methods = mock(IMethods.class); + methods.simpleMethod(); + + collector.verify(methods).simpleMethod(); + collector.collectAndReport(); + } + + @Test(expected = MockitoAssertionError.class) + public void should_collect_verification_failures() { + VerificationCollector collector = MockitoJUnit.collector(); + + IMethods methods = mock(IMethods.class); + + collector.verify(methods).simpleMethod(); + collector.collectAndReport(); + } + + @Test + public void should_collect_multiple_verification_failures() { + VerificationCollector collector = MockitoJUnit.collector(); + + IMethods methods = mock(IMethods.class); + + collector.verify(methods).simpleMethod(); + collector.verify(methods).byteReturningMethod(); + try { + collector.collectAndReport(); + fail(); + } catch (MockitoAssertionError error) { + assertThat(error).hasMessageContaining("1. Wanted but not invoked:"); + assertThat(error).hasMessageContaining("2. Wanted but not invoked:"); + } + } + + @Test + public void should_only_collect_failures_ignore_succesful_verifications() { + VerificationCollector collector = MockitoJUnit.collector(); + + IMethods methods = mock(IMethods.class); + + collector.verify(methods, never()).simpleMethod(); + collector.verify(methods).byteReturningMethod(); + + this.assertAtLeastOneFailure(collector); + } + + @Test + public void should_continue_collecting_after_failing_verification() { + VerificationCollector collector = MockitoJUnit.collector(); + + IMethods methods = mock(IMethods.class); + methods.simpleMethod(); + + collector.verify(methods).byteReturningMethod(); + collector.verify(methods).simpleMethod(); + + this.assertAtLeastOneFailure(collector); + } + + private void assertAtLeastOneFailure(VerificationCollector collector) { + try { + collector.collectAndReport(); + fail(); + } catch (MockitoAssertionError error) { + assertThat(error).hasMessageContaining("1. Wanted but not invoked:"); + assertThat(error.getMessage()).doesNotContain("2."); + } + } + + @Test + public void should_invoke_collector_rule_after_test() { + JUnitCore runner = new JUnitCore(); + Result result = runner.run(VerificationCollectorRuleInner.class); + + assertThat(result.getFailureCount()).isEqualTo(1); + assertThat(result.getFailures().get(0).getMessage()).contains("1. Wanted but not invoked:"); + } + + public static class VerificationCollectorRuleInner { + + @Rule + public VerificationCollector collector = MockitoJUnit.collector(); + + @Test + public void should_fail() { + IMethods methods = mock(IMethods.class); + + collector.verify(methods).simpleMethod(); + } + + @Test + public void should_not_fail() { + IMethods methods = mock(IMethods.class); + methods.simpleMethod(); + + collector.verify(methods).simpleMethod(); + } + } +}

train

train

welkman

train

mockito/mockito/273_294

mockito/mockito

mockito/mockito/273

mockito/mockito/294

a821f7b0ec47f3214bf6f0361df5deb211fa2214

39e732869eef5d6b54af4a6890b895fba430171d

Get rid of ReturnValues

`org.mockito.ReturnValues` has been deprecated for years, it should be removed in mockito 2.0

diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index 04f4a9e69e..e2eca63a6d 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -1327,41 +1327,6 @@ public static MockingDetails mockingDetails(Object toInspect) { return MOCKITO_CORE.mockingDetails(toInspect); } - /** - * <b>Deprecated : Please use mock(Foo.class, defaultAnswer);</b> - * <p> - * See {@link Mockito#mock(Class, Answer)} - * <p> - * Why it is deprecated? ReturnValues is being replaced by Answer - * for better consistency & interoperability of the framework. - * Answer interface has been in Mockito for a while and it has the same responsibility as ReturnValues. - * There's no point in mainting exactly the same interfaces. - * <p> - * Creates mock with a specified strategy for its return values. - * It's quite advanced feature and typically you don't need it to write decent tests. - * However it can be helpful when working with legacy systems. - * <p> - * Obviously return values are used only when you don't stub the method call. - * - * <pre class="code"><code class="java"> - * Foo mock = mock(Foo.class, Mockito.RETURNS_SMART_NULLS); - * Foo mockTwo = mock(Foo.class, new YourOwnReturnValues()); - * </code></pre> - * - * <p>See examples in javadoc for {@link Mockito} class</p> - * - * @param classToMock class or interface to mock - * @param returnValues default return values for unstubbed methods - * - * @return mock object - * - * @deprecated <b>Please use mock(Foo.class, defaultAnswer);</b> - */ - @Deprecated - public static <T> T mock(Class<T> classToMock, ReturnValues returnValues) { - return mock(classToMock, withSettings().defaultAnswer(new AnswerReturnValuesAdapter(returnValues))); - } - /** * Creates mock with a specified strategy for its answers to interactions. * It's quite advanced feature and typically you don't need it to write decent tests. diff --git a/src/main/java/org/mockito/ReturnValues.java b/src/main/java/org/mockito/ReturnValues.java deleted file mode 100644 index f9402129c2..0000000000 --- a/src/main/java/org/mockito/ReturnValues.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ - -package org.mockito; - -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; - -/** - * @deprecated - * <b>Instead, please use {@link Answer} interface</b> - * <p> - * In rare cases your code might not compile with recent deprecation & changes. - * Very sorry for inconvenience but it had to be done in order to keep framework consistent. - * <p> - * Why it is deprecated? ReturnValues is being replaced by Answer - * for better consistency & interoperability of the framework. - * Answer interface has been in Mockito for a while and it has the same responsibility as ReturnValues. - * There's no point in mainting exactly the same interfaces. - * <p> - * Configures return values for an unstubbed invocation - * <p> - * Can be used in {@link Mockito#mock(Class, ReturnValues)} - */ -@Deprecated -public interface ReturnValues { - - /** - * return value for an unstubbed invocation - * - * @param invocation placeholder for mock and a method - * @return the return value - */ - Object valueFor(InvocationOnMock invocation) throws Throwable; -} \ No newline at end of file diff --git a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java b/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java index fe9a8f6062..ce5714d0c0 100644 --- a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java +++ b/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java @@ -4,7 +4,6 @@ */ package org.mockito.configuration; -import org.mockito.ReturnValues; import org.mockito.internal.configuration.InjectingAnnotationEngine; import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues; import org.mockito.stubbing.Answer; @@ -16,17 +15,7 @@ * <p> * See javadocs for {@link IMockitoConfiguration} on info how to configure Mockito */ -@SuppressWarnings("deprecation")//suppressed until ReturnValues are removed public class DefaultMockitoConfiguration implements IMockitoConfiguration { - - /* (non-Javadoc) - * @see org.mockito.IMockitoConfiguration#getReturnValues() - */ - @Deprecated - public ReturnValues getReturnValues() { - throw new RuntimeException("\n" + "This method should not be used by the framework because it was deprecated" - + "\n" + "Please report the failure to the Mockito mailing list"); - } public Answer<Object> getDefaultAnswer() { return new ReturnsEmptyValues(); diff --git a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java b/src/main/java/org/mockito/configuration/IMockitoConfiguration.java index 2f693879ff..cebd25f366 100644 --- a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java +++ b/src/main/java/org/mockito/configuration/IMockitoConfiguration.java @@ -4,7 +4,6 @@ */ package org.mockito.configuration; -import org.mockito.ReturnValues; import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues; import org.mockito.stubbing.Answer; @@ -26,31 +25,8 @@ * <p> * If you have comments on Mockito configuration feature don't hesitate to write to mockito@googlegroups.com */ -@SuppressWarnings("deprecation")//suppressed until ReturnValues are removed public interface IMockitoConfiguration { - /** - * @deprecated - * <b>Please use {@link IMockitoConfiguration#getDefaultAnswer()}</b> - * <p> - * Steps: - * <p> - * 1. Leave the implementation of getReturnValues() method empty - it's not going to be used anyway. - * <p> - * 2. Implement getDefaultAnswer() instead. - * <p> - * In rare cases your code might not compile with recent deprecation & changes. - * Very sorry for inconvenience but it had to be done in order to keep framework consistent. - * <p> - * See javadoc {@link ReturnValues} for info why this method was deprecated - * <p> - * Allows configuring the default return values of unstubbed invocations - * <p> - * See javadoc for {@link IMockitoConfiguration} - */ - @Deprecated - ReturnValues getReturnValues(); - /** * Allows configuring the default answers of unstubbed invocations * <p> diff --git a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java b/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java index 9a54c27a69..c8a94e8937 100644 --- a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java +++ b/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java @@ -4,7 +4,6 @@ */ package org.mockito.internal.configuration; -import org.mockito.ReturnValues; import org.mockito.configuration.AnnotationEngine; import org.mockito.configuration.DefaultMockitoConfiguration; import org.mockito.configuration.IMockitoConfiguration; @@ -15,7 +14,6 @@ /** * Thread-safe wrapper on user-defined org.mockito.configuration.MockitoConfiguration implementation */ -@SuppressWarnings("deprecation")//suppressed until ReturnValues are removed public class GlobalConfiguration implements IMockitoConfiguration, Serializable { private static final long serialVersionUID = -2860353062105505938L; @@ -47,10 +45,6 @@ public static void validate() { new GlobalConfiguration(); } - public ReturnValues getReturnValues() { - return GLOBAL_CONFIGURATION.get().getReturnValues(); - } - public AnnotationEngine getAnnotationEngine() { return GLOBAL_CONFIGURATION.get().getAnnotationEngine(); } diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AnswerReturnValuesAdapter.java b/src/main/java/org/mockito/internal/stubbing/answers/AnswerReturnValuesAdapter.java deleted file mode 100644 index 1d5492ed31..0000000000 --- a/src/main/java/org/mockito/internal/stubbing/answers/AnswerReturnValuesAdapter.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.stubbing.answers; - -import java.io.Serializable; - -import org.mockito.ReturnValues; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; - -//It's ok to suppress deprecation because this class goes away as soon as ReturnValues disappears in future release -@SuppressWarnings("deprecation") -public class AnswerReturnValuesAdapter implements Answer<Object>, Serializable { - - private static final long serialVersionUID = 1418158596876713469L; - private final ReturnValues returnValues; - - public AnswerReturnValuesAdapter(ReturnValues returnValues) { - this.returnValues = returnValues; - } - - public Object answer(InvocationOnMock invocation) throws Throwable { - return returnValues.valueFor(invocation); - } -} \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java index df86442619..1916a62ce2 100644 --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java @@ -9,9 +9,6 @@ import java.lang.reflect.Method; import org.mockito.exceptions.Reporter; -import org.mockito.exceptions.base.MockitoException; -import org.mockito.internal.stubbing.answers.MethodInfo; -import org.mockito.internal.util.Primitives; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/package.html b/src/main/java/org/mockito/internal/stubbing/defaultanswers/package.html index 15877151bd..f2dee90a8c 100644 --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/package.html +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/package.html @@ -4,5 +4,5 @@ --> <body> -Implementations of ReturnValues +Implementations of Answer </body> \ No newline at end of file

train

train

bric3

train

mockito/mockito/311_314

mockito/mockito

mockito/mockito/311

mockito/mockito/314

e8640baba7eeaf4d333696492b6868feb115094f

7bd8cb501439886a31d787cc708d0c77101a3fde

Add BDD version of verifyNoMoreInteractions()

Current state: ``` java then(file).should().moveTo(directory); verifyNoMoreInteractions(file); ``` Would be great to have BDD replacement for `verifyNoMoreInteractions()`. Then the test would be even nicer: ``` java then(file).should().moveTo(directory); then(file).shouldHaveNoMoreInteractions(); ``` If you agree, I will submit a PR.

diff --git a/src/main/java/org/mockito/BDDMockito.java b/src/main/java/org/mockito/BDDMockito.java index 560cdf8bd7..7bb8f4679f 100644 --- a/src/main/java/org/mockito/BDDMockito.java +++ b/src/main/java/org/mockito/BDDMockito.java @@ -57,6 +57,7 @@ * person.ride(bike); * * then(person).should(times(2)).ride(bike); + * then(person).shouldHaveNoMoreInteractions(); * then(police).shouldHaveZeroInteractions(); * </code></pre> * <p> @@ -256,6 +257,12 @@ public interface Then<T> { * @since 2.0 */ void shouldHaveZeroInteractions(); + + /** + * @see #verifyNoMoreInteractions(Object...) + * @since 2.0 + */ + void shouldHaveNoMoreInteractions(); } /** @@ -309,6 +316,14 @@ public T should(InOrder inOrder, VerificationMode mode) { public void shouldHaveZeroInteractions() { verifyZeroInteractions(mock); } + + /** + * @see #verifyNoMoreInteractions(Object...) + * @since 2.0 + */ + public void shouldHaveNoMoreInteractions() { + verifyNoMoreInteractions(mock); + } } /**

diff --git a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java index c207361c9d..b74487ef04 100644 --- a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java +++ b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java @@ -246,6 +246,7 @@ public void should_pass_for_expected_behavior_that_happened() { mock.booleanObjectReturningMethod(); then(mock).should().booleanObjectReturningMethod(); + then(mock).shouldHaveNoMoreInteractions(); } @Test @@ -263,6 +264,18 @@ public void should_fail_when_mock_had_unwanted_interactions() { } catch (NoInteractionsWanted expected) { } } + @Test + public void should_fail_when_mock_had_more_interactions_than_expected() { + mock.booleanObjectReturningMethod(); + mock.byteObjectReturningMethod(); + + then(mock).should().booleanObjectReturningMethod(); + try { + then(mock).shouldHaveNoMoreInteractions(); + fail("should have reported that no more interactions were wanted"); + } catch (NoInteractionsWanted expected) { } + } + @Test public void should_pass_for_interactions_that_happened_in_correct_order() { mock.booleanObjectReturningMethod();

train

train

mkordas

train

mockito/mockito/316_317

mockito/mockito

mockito/mockito/316

mockito/mockito/317

971be4d8184ec916a5ebc2395050804da22b5b33

8017ee1ff766b96725a64d0a2fff79e26300a19b

modify StackTraceFilter to not strip away "good" elements from the middle

according to javadoc of org.mockito.internal.exceptions.stacktrace.StackTraceFilter, filter works like this: [a+, b+, c-, d+, e+, f-, g+] -> [a+, b+, g+] it would be better to not strip away "good" d and e elements: [a+, b+, c-, d+, e+, f-, g+] -> [a+, b+, d+, e+, g+] What do you think about this? For me current behaviour is very inconvenient, I had to turn it off.

diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java index cd462dcee1..2b5bb658cc 100644 --- a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java +++ b/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java @@ -10,8 +10,6 @@ import java.io.Serializable; import java.util.ArrayList; -import java.util.Arrays; -import java.util.LinkedList; import java.util.List; public class StackTraceFilter implements Serializable { @@ -20,38 +18,22 @@ public class StackTraceFilter implements Serializable { private static final StackTraceCleaner CLEANER = Plugins.getStackTraceCleanerProvider().getStackTraceCleaner(new DefaultStackTraceCleaner()); - + /** * Example how the filter works (+/- means good/bad): - * [a+, b+, c-, d+, e+, f-, g+] -> [a+, b+, g+] - * Basically removes all bad from the middle. If any good are in the middle of bad those are also removed. + * [a+, b+, c-, d+, e+, f-, g+] -> [a+, b+, d+, e+, g+] + * Basically removes all bad from the middle. + * <strike>If any good are in the middle of bad those are also removed.</strike> */ public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) { //TODO: profile - List<StackTraceElement> unfilteredStackTrace = Arrays.asList(target); - - int lastBad = -1; - int firstBad = -1; - for (int i = 0; i < unfilteredStackTrace.size(); i++) { - if (!CLEANER.isOut(unfilteredStackTrace.get(i))) { - continue; - } - lastBad = i; - if (firstBad == -1) { - firstBad = i; + final List<StackTraceElement> filtered = new ArrayList<StackTraceElement>(); + for (StackTraceElement aTarget : target) { + if (!CLEANER.isOut(aTarget)) { + filtered.add(aTarget); } } - - List<StackTraceElement> top; - if (keepTop && firstBad != -1) { - top = unfilteredStackTrace.subList(0, firstBad); - } else { - top = new LinkedList<StackTraceElement>(); - } - - List<StackTraceElement> bottom = unfilteredStackTrace.subList(lastBad + 1, unfilteredStackTrace.size()); - List<StackTraceElement> filtered = new ArrayList<StackTraceElement>(top); - filtered.addAll(bottom); - return filtered.toArray(new StackTraceElement[]{}); + StackTraceElement[] result = new StackTraceElement[filtered.size()]; + return filtered.toArray(result); } } \ No newline at end of file

diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java index 3d4185e7c9..0b1e588d86 100644 --- a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java +++ b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java @@ -40,7 +40,7 @@ public void shouldFilterOutMockitoPackage() { } @Test - public void shouldFilterOutTracesMiddleBadTraces() { + public void shouldNotFilterOutTracesMiddleGoodTraces() { StackTraceElement[] t = new TraceBuilder().classes( "org.test.MockitoSampleTest", "org.test.TestSupport", @@ -51,7 +51,7 @@ public void shouldFilterOutTracesMiddleBadTraces() { StackTraceElement[] filtered = filter.filter(t, false); - assertThat(filtered, hasOnlyThoseClasses("org.test.TestSupport", "org.test.MockitoSampleTest")); + assertThat(filtered, hasOnlyThoseClasses("org.test.TestSupport", "org.test.TestSupport", "org.test.MockitoSampleTest")); } @Test

train

train

astafev

train

mockito/mockito/256_342

mockito/mockito

mockito/mockito/256

mockito/mockito/342

7b62390fec00c46fa8924354c27686a1a44fe2ab

b3648078d7adeb4277bbaf75a87b2a272335d5bf

task mockitoJavadoc fails when compiling in windows

When compiling the mockito project using gradle in a command line in Windows following compile error occurs: javadoc: error - Illegal package name: "<script" javadoc: error - Illegal package name: "type=" javadoc: error - Illegal package name: "text/javascript" javadoc: error - Illegal package name: "src=" javadoc: error - Illegal package name: "{@docRoot}/js/jdk6-project-version-insert.js" javadoc: error - Illegal package name: "></script>" javadoc: error - Illegal package name: "<script" javadoc: error - Illegal package name: "type=" javadoc: error - Illegal package name: "text/javascript" javadoc: error - Illegal package name: "src=" javadoc: error - Illegal package name: "{@docRoot}/js/jquery-1.7.min.js" javadoc: error - Illegal package name: "></script>" javadoc: error - Illegal package name: "<script" javadoc: error - Illegal package name: "type=" javadoc: error - Illegal package name: "text/javascript" javadoc: error - Illegal package name: "src=" javadoc: error - Illegal package name: "{@docRoot}/js/highlight-8.6-java/highlight.pack.js" javadoc: error - Illegal package name: "></script>" javadoc: error - Illegal package name: "<link" javadoc: error - Illegal package name: "rel=" javadoc: error - Illegal package name: "type=" javadoc: error - Illegal package name: "text/css" javadoc: error - Illegal package name: "href=" javadoc: error - Illegal package name: "{@docRoot}/js/highlight-8.6-java/styles/obsidian.css" javadoc: error - Illegal package name: "/>" javadoc: error - Illegal package name: "<script" javadoc: error - Illegal package name: "type=" javadoc: error - Illegal package name: "text/javascript" javadoc: error - Illegal package name: ">" javadoc: error - Illegal package name: "=" javadoc: error - Illegal package name: "&&" javadoc: error - Illegal package name: "parseInt($.browser.version)" javadoc: error - Illegal package name: "<" javadoc: error - Illegal package name: "9;" javadoc: error - Illegal package name: "if(!usingOldIE)" javadoc: error - Illegal package name: "{" javadoc: error - Illegal package name: "$(" javadoc: error - Illegal package name: ").append(" javadoc: error - Illegal package name: "<link rel=\" javadoc: error - Illegal package name: "icon\\" javadoc: error - Illegal package name: " href=\" javadoc: error - Illegal package name: "{@docRoot}/favicon.ico?v=cafebabe\\" javadoc: error - Illegal package name: ">" javadoc: error - Illegal package name: ")" javadoc: error - Illegal package name: "$(" javadoc: error - Illegal package name: "," javadoc: error - Illegal package name: "window.parent.document).append(" javadoc: error - Illegal package name: "<link rel=\" javadoc: error - Illegal package name: "icon\\" javadoc: error - Illegal package name: " href=\" javadoc: error - Illegal package name: "{@docRoot}/favicon.ico?v=cafebabe\\" javadoc: error - Illegal package name: ">" javadoc: error - Illegal package name: ")" javadoc: error - Illegal package name: "hljs.initHighlightingOnLoad();" javadoc: error - Illegal package name: "injectProjectVersionForJavadocJDK6(" javadoc: error - Illegal package name: "Mockito 2.0.29-beta API" javadoc: error - Illegal package name: "," javadoc: error - Illegal package name: "em#mockito-version-header-javadoc7-header" javadoc: error - Illegal package name: "," javadoc: error - Illegal package name: "em#mockito-version-header-javadoc7-footer" javadoc: error - Illegal package name: ");" javadoc: error - Illegal package name: "}" javadoc: error - Illegal package name: "</script>" javadoc: error - Illegal package name: "" javadoc: warning - No source files for package stylesheet javadoc: warning - No source files for package var javadoc: warning - No source files for package usingOldIE javadoc: warning - No source files for package $.browser.msie javadoc: warning - No source files for package head javadoc: warning - No source files for package shortcut javadoc: warning - No source files for package head javadoc: warning - No source files for package shortcut 64 errors 8 warnings I tracked the issue down to gradle/javadoc.gradle where the gradle scripts sets the bottom property to a java script with multiple lines. Changing that to a single line seems to be make it possible to complete the mockitoJavaDoc task without any errors.

diff --git a/gradle/javadoc.gradle b/gradle/javadoc.gradle index 55052e9f3e..4d5daa5d43 100644 --- a/gradle/javadoc.gradle +++ b/gradle/javadoc.gradle @@ -40,8 +40,8 @@ task mockitoJavadoc(type: Javadoc) { <script type="text/javascript"> var usingOldIE = \$.browser.msie && parseInt(\$.browser.version) < 9; if(!usingOldIE) { - \$("head").append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">") - \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">") + \$("head").append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">"); + \$("head", window.parent.document).append("<link rel=\\"shortcut icon\\" href=\\"{@docRoot}/favicon.ico?v=cafebabe\\">"); hljs.initHighlightingOnLoad(); \$("pre.code").css("font-size", "0.9em"); injectProjectVersionForJavadocJDK6("Mockito ${project.version} API", @@ -49,7 +49,7 @@ task mockitoJavadoc(type: Javadoc) { "em#mockito-version-header-javadoc7-footer"); } </script> - """) + """.replaceAll(/\r|\n/, "")) // options.stylesheetFile file("src/javadoc/stylesheet.css") // options.addStringOption('top', 'some html') if (JavaVersion.current().isJava8Compatible()) {

test

train

mat013

train

mockito/mockito/345_349

mockito/mockito

mockito/mockito/345

mockito/mockito/349

c18bf2a94e2e8d95a78cbd5fe18252d39acee8c4

455eb2f4737b4f15bd4472cce675d24398975439

Verification using After and ArgumentCaptor returns unexpected size of captured values list

Hi, I found weird behavior of Mockito (ver. 1.10.19) when verifying method invocation with after() and ArgumentCaptor. The list of captured values returned by ArgumentCaptor has size much bigger than I expect. Moreover this behavior in connection with long timeout leads to exceeding memory limit. Example below. Is it expected behavior or bug? ``` java package org.mockito.test; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.after; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; public class MockitoAfterFeatureTest { private RequestSender requestSender; private RequestProcessor requestProcessor; private ArgumentCaptor<String> stringArgumentCaptor; @Before public void doBeforeTest() { requestSender = mock(RequestSender.class); requestProcessor = new RequestProcessor(requestSender); stringArgumentCaptor = ArgumentCaptor.forClass(String.class); } @Test public void shouldVerifyUsingAfterAndArgumentCaptor() { // when requestProcessor.process("first_request"); requestProcessor.process("second_request"); // then verify(requestSender, after(2500).times(2)).send(stringArgumentCaptor.capture()); assertEquals("first_request", stringArgumentCaptor.getAllValues().get(0)); assertEquals("second_request", stringArgumentCaptor.getAllValues().get(1)); assertEquals(2, stringArgumentCaptor.getAllValues().size()); } public static class RequestProcessor { private final RequestSender requestSender; public RequestProcessor(RequestSender requestSender) { this.requestSender = requestSender; } public void process(String request) { requestSender.send(request); } } public interface RequestSender { void send(String request); } } ```

diff --git a/src/main/java/org/mockito/internal/verification/AtMost.java b/src/main/java/org/mockito/internal/verification/AtMost.java index 54a5285c47..25a7fc59d1 100644 --- a/src/main/java/org/mockito/internal/verification/AtMost.java +++ b/src/main/java/org/mockito/internal/verification/AtMost.java @@ -5,6 +5,7 @@ package org.mockito.internal.verification; +import java.util.Iterator; import java.util.List; import org.mockito.exceptions.Reporter; @@ -38,7 +39,8 @@ public void verify(VerificationData data) { if (foundSize > maxNumberOfInvocations) { new Reporter().wantedAtMostX(maxNumberOfInvocations, foundSize); } - + + removeAlreadyVerified(found); invocationMarker.markVerified(found, wanted); } @@ -46,4 +48,13 @@ public void verify(VerificationData data) { public VerificationMode description(String description) { return VerificationModeFactory.description(this, description); } + + private void removeAlreadyVerified(List<Invocation> invocations) { + for (Iterator<Invocation> iterator = invocations.iterator(); iterator.hasNext(); ) { + Invocation i = iterator.next(); + if (i.isVerified()) { + iterator.remove(); + } + } + } } \ No newline at end of file

diff --git a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java b/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java index d20c39d8ba..e0d4f76c71 100644 --- a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java +++ b/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java @@ -15,6 +15,8 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; import org.mockito.Mock; import org.mockito.exceptions.base.MockitoAssertionError; import org.mockitoutil.TestBase; @@ -29,6 +31,9 @@ public class VerificationAfterDelayTest extends TestBase { private List<Exception> exceptions = new LinkedList<Exception>(); + @Captor + private ArgumentCaptor<String> stringArgumentCaptor; + @After public void teardown() { // making sure there are no threading related exceptions @@ -106,6 +111,31 @@ public void shouldStopEarlyIfTestIsDefinitelyFailed() throws Exception { verify(mock, after(10000).never()).clear(); } + /** + * Test for issue #345. + */ + @Test + public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtMostVerification() { + // given + int n = 3; + + // when + exerciseMockNTimes(n); + + // then + verify(mock, after(200).atMost(n)).add(stringArgumentCaptor.capture()); + assertEquals(n, stringArgumentCaptor.getAllValues().size()); + assertEquals("0", stringArgumentCaptor.getAllValues().get(0)); + assertEquals("1", stringArgumentCaptor.getAllValues().get(1)); + assertEquals("2", stringArgumentCaptor.getAllValues().get(2)); + } + + private void exerciseMockNTimes(int n) { + for (int i = 0; i < n; i++) { + mock.add(String.valueOf(i)); + } + } + private Thread waitAndExerciseMock(final int sleep) { Thread t = new Thread() {

test

train

tarnowskijan

train

mockito/mockito/365_373

mockito/mockito

mockito/mockito/365

mockito/mockito/373

196ff979da156caa07e19f57e4849637d8bede1a

f2ec9da14192fa98f534dd8e01d4921fcc5c8c14

Simplify the InvocationOnMock-API to get a casted argument

The 2nd argument of `InvocationOnMock.getArgumentAt(int,Class<T>)` can be removed cause it is not neccessary. Intuitively on would write this to get a "auto casted" argument: `String text = invocation.getArgumentAt(1,String.class)` The type can be ommited without side effects (the implementation of InvocationOnMock discards it anyway). `String text = invocation.getArgumentAt(1,null)` Therefore Mockito 2.0 should consider to simplify the API and ommit the `Class`-argument here. Maybe it is also a good chance to simplify the method name too. What about `getArgument(int index)` ? This is how the 'new' API could look like: `String text = invocation.getArgument(1)`

diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java index b0687142e3..8445e4b70b 100644 --- a/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java +++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InterceptedInvocation.java @@ -113,9 +113,14 @@ public Object[] getArguments() { } @Override - @SuppressWarnings("unchecked") + @Deprecated public <T> T getArgumentAt(int index, Class<T> clazz) { - return (T) arguments[index]; + return (T) getArgument(index); + } + + @Override + public <T> T getArgument(int index) { + return (T)arguments[index]; } @Override diff --git a/src/main/java/org/mockito/internal/invocation/InvocationImpl.java b/src/main/java/org/mockito/internal/invocation/InvocationImpl.java index dc77a57e25..b7bf096249 100644 --- a/src/main/java/org/mockito/internal/invocation/InvocationImpl.java +++ b/src/main/java/org/mockito/internal/invocation/InvocationImpl.java @@ -62,10 +62,17 @@ public Object[] getArguments() { return arguments; } + @Deprecated public <T> T getArgumentAt(int index, Class<T> clazz) { - return (T) arguments[index]; + return (T) getArgument(index); } + public <T> T getArgument(int index) { + return (T)arguments[index]; + } + + + public boolean isVerified() { return verified || isIgnoredForVerification; } diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java b/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java index a18f1b62e2..112c7dd5a9 100644 --- a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java +++ b/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java @@ -122,7 +122,7 @@ private void captureRegularArguments(Invocation invocation) { for (int position = 0; position < regularArgumentsSize(invocation); position++) { ArgumentMatcher m = matchers.get(position); if (m instanceof CapturesArguments) { - ((CapturesArguments) m).captureFrom(invocation.getArgumentAt(position, Object.class)); + ((CapturesArguments) m).captureFrom(invocation.getArgument(position)); } } } diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java index 059074d254..6db6db8899 100644 --- a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java +++ b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java @@ -39,7 +39,7 @@ public ReturnsArgumentAt(int wantedArgumentPosition) { public Object answer(InvocationOnMock invocation) throws Throwable { validateIndexWithinInvocationRange(invocation); - return invocation.getArguments()[actualArgumentPosition(invocation)]; + return invocation.getArgument(actualArgumentPosition(invocation)); } diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java index 11304afce1..4b8b9474c5 100644 --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java @@ -72,7 +72,7 @@ public Object answer(InvocationOnMock invocation) { //see issue 184. //mocks by default should return 0 if references are the same, otherwise some other value because they are not the same. Hence we return 1 (anything but 0 is good). //Only for compareTo() method by the Comparable interface - return invocation.getMock() == invocation.getArguments()[0] ? 0 : 1; + return invocation.getMock() == invocation.getArgument(0) ? 0 : 1; } Class<?> returnType = invocation.getMethod().getReturnType(); diff --git a/src/main/java/org/mockito/invocation/InvocationOnMock.java b/src/main/java/org/mockito/invocation/InvocationOnMock.java index 815b8a4422..95f7667c5d 100644 --- a/src/main/java/org/mockito/invocation/InvocationOnMock.java +++ b/src/main/java/org/mockito/invocation/InvocationOnMock.java @@ -41,9 +41,18 @@ public interface InvocationOnMock extends Serializable { * @param index argument position * @param clazz argument type * @return casted argument on position + * @deprecated use {@link #getArgument(int)} */ + @Deprecated <T> T getArgumentAt(int index, Class<T> clazz); + /** + * Returns casted argument at the given index + * @param index argument index + * @return casted argument at the given index + */ + <T> T getArgument(int index); + /** * calls real method

diff --git a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java b/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java index c5230db380..8eea369948 100644 --- a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java +++ b/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java @@ -54,6 +54,6 @@ public void shouldNotCountDuplicatedInteractions() throws Exception { } private void assertArgumentEquals(Object argumentValue, Invocation invocation) { - assertEquals(argumentValue, invocation.getArguments()[0]); + assertEquals(argumentValue, invocation.getArgument(0)); } } \ No newline at end of file diff --git a/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java b/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java index 0317dea5fe..57f229fd32 100644 --- a/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java +++ b/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java @@ -156,7 +156,7 @@ public void shouldReturnCastedArgumentAt(){ argTypes(int.class, int.class).args(1, argument).toInvocation(); //when - int secondArgument = invocationOnInterface.getArgumentAt(1, int.class); + int secondArgument = invocationOnInterface.getArgument(1); //then assertTrue(secondArgument == argument); diff --git a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java b/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java index 882d235c81..a446bda754 100644 --- a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java +++ b/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java @@ -75,7 +75,7 @@ public void shouldAlterFinalLog() { private Answer byCheckingLogEquals(final ImportLogBean status) { return new Answer() { public Object answer(InvocationOnMock invocation) throws Throwable { - ImportLogBean bean = (ImportLogBean) invocation.getArguments()[0]; + ImportLogBean bean = invocation.getArgument(0); assertEquals(status, bean); return null; } diff --git a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java index b74487ef04..b932bd0b33 100644 --- a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java +++ b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java @@ -68,7 +68,7 @@ public void should_stub_with_throwable_classes() throws Exception { public void should_stub_with_answer() throws Exception { given(mock.simpleMethod(anyString())).willAnswer(new Answer<String>() { public String answer(InvocationOnMock invocation) throws Throwable { - return (String) invocation.getArguments()[0]; + return invocation.getArgument(0); }}); Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo"); @@ -78,7 +78,7 @@ public String answer(InvocationOnMock invocation) throws Throwable { public void should_stub_with_will_answer_alias() throws Exception { given(mock.simpleMethod(anyString())).will(new Answer<String>() { public String answer(InvocationOnMock invocation) throws Throwable { - return (String) invocation.getArguments()[0]; + return invocation.getArgument(0); } }); @@ -184,7 +184,7 @@ public void should_stub_using_do_return_style() throws Exception { public void should_stub_using_do_answer_style() throws Exception { willAnswer(new Answer<String>() { public String answer(InvocationOnMock invocation) throws Throwable { - return (String) invocation.getArguments()[0]; + return invocation.getArgument(0); } }) .given(mock).simpleMethod(anyString()); diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java index 8ca965d148..10486b7971 100644 --- a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java +++ b/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java @@ -28,7 +28,7 @@ public class StubbingWithCustomAnswerTest extends TestBase { public void shouldAnswer() throws Exception { when(mock.simpleMethod(anyString())).thenAnswer(new Answer<String>() { public String answer(InvocationOnMock invocation) throws Throwable { - String arg = (String) invocation.getArguments()[0]; + String arg = invocation.getArgument(0); return invocation.getMethod().getName() + "-" + arg; }

val

train

ChristianSchwarz

train

mockito/mockito/379_380

mockito/mockito

mockito/mockito/379

mockito/mockito/380

196ff979da156caa07e19f57e4849637d8bede1a

31c7876f0693a1335c8e41b340e8580aa9a510ae

Verification using After and ArgumentCaptor with Times or AtLeast methods returns unexpected size of captured values list.

Hi! I was looking issue #345 and found that the test "shouldReturnListOfArgumentsWithSameSizeAsGivenInAtMostVerification" (located in VerificationAfterDelayTest.java) fails if you use atLeast() or times() instead of atMost(). I created these tests: 

diff --git a/src/main/java/org/mockito/internal/verification/Times.java b/src/main/java/org/mockito/internal/verification/Times.java index 62a7ed753f..f43ce4286c 100644 --- a/src/main/java/org/mockito/internal/verification/Times.java +++ b/src/main/java/org/mockito/internal/verification/Times.java @@ -31,12 +31,16 @@ public Times(int wantedNumberOfInvocations) { } public void verify(VerificationData data) { + List<Invocation> invocations = data.getAllInvocations(); + InvocationMatcher wanted = data.getWanted(); + if (wantedCount > 0) { MissingInvocationChecker missingInvocation = new MissingInvocationChecker(); - missingInvocation.check(data.getAllInvocations(), data.getWanted()); + missingInvocation.check(invocations, wanted); } + NumberOfInvocationsChecker numberOfInvocations = new NumberOfInvocationsChecker(); - numberOfInvocations.check(data.getAllInvocations(), data.getWanted(), wantedCount); + numberOfInvocations.check(invocations, wanted, wantedCount); } public void verifyInOrder(VerificationDataInOrder data) { diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java index cc29e0963c..f21489edf8 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java @@ -5,6 +5,7 @@ package org.mockito.internal.verification.checkers; +import java.util.Iterator; import java.util.List; import org.mockito.exceptions.Reporter; @@ -28,7 +29,17 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa Location lastLocation = finder.getLastLocation(actualInvocations); reporter.tooLittleActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, lastLocation); } - + + removeAlreadyVerified(actualInvocations); invocationMarker.markVerified(actualInvocations, wanted); } + + private void removeAlreadyVerified(List<Invocation> invocations) { + for (Iterator<Invocation> iterator = invocations.iterator(); iterator.hasNext(); ) { + Invocation i = iterator.next(); + if (i.isVerified()) { + iterator.remove(); + } + } + } } \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java index 17dec9ff2e..2529095c46 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java @@ -5,6 +5,7 @@ package org.mockito.internal.verification.checkers; +import java.util.Iterator; import java.util.List; import org.mockito.exceptions.Reporter; @@ -44,7 +45,17 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa Location firstUndesired = actualInvocations.get(wantedCount).getLocation(); reporter.tooManyActualInvocations(wantedCount, actualCount, wanted, firstUndesired); } - + + removeAlreadyVerified(actualInvocations); invocationMarker.markVerified(actualInvocations, wanted); } + + private void removeAlreadyVerified(List<Invocation> invocations) { + for (Iterator<Invocation> iterator = invocations.iterator(); iterator.hasNext(); ) { + Invocation i = iterator.next(); + if (i.isVerified()) { + iterator.remove(); + } + } + } } \ No newline at end of file

diff --git a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java b/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java index e0d4f76c71..2462f28e45 100644 --- a/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java +++ b/src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java @@ -130,6 +130,38 @@ public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtMostVerification() assertEquals("2", stringArgumentCaptor.getAllValues().get(2)); } + @Test + public void shouldReturnListOfArgumentsWithSameSizeAsGivenInTimesVerification() { + // given + int n = 3; + + // when + exerciseMockNTimes(n); + + //Then + verify(mock, after(200).times(n)).add(stringArgumentCaptor.capture()); + assertEquals(n, stringArgumentCaptor.getAllValues().size()); + assertEquals("0", stringArgumentCaptor.getAllValues().get(0)); + assertEquals("1", stringArgumentCaptor.getAllValues().get(1)); + assertEquals("2", stringArgumentCaptor.getAllValues().get(2)); + } + + @Test + public void shouldReturnListOfArgumentsWithSameSizeAsGivenInAtLeastVerification() { + // given + int n = 3; + + // when + exerciseMockNTimes(n); + + //Then + verify(mock, after(200).atLeast(n)).add(stringArgumentCaptor.capture()); + assertEquals(n, stringArgumentCaptor.getAllValues().size()); + assertEquals("0", stringArgumentCaptor.getAllValues().get(0)); + assertEquals("1", stringArgumentCaptor.getAllValues().get(1)); + assertEquals("2", stringArgumentCaptor.getAllValues().get(2)); + } + private void exerciseMockNTimes(int n) { for (int i = 0; i < n; i++) { mock.add(String.valueOf(i));

train

train

thesnowgoose

train

mockito/mockito/374_386

mockito/mockito

mockito/mockito/374

mockito/mockito/386

196ff979da156caa07e19f57e4849637d8bede1a

66a7205945d201e01aa6043d5cfe1aa0ae08e622

Remove deprecated API from Mockito 2

# This is a reminder to remove all deprecated API's from the upcoming mockito 2. This issue blocks #123 [Release Mockito 2.0](123) Relates to - #273 [Get rid of ReturnValues](273)

diff --git a/src/main/java/org/mockito/Answers.java b/src/main/java/org/mockito/Answers.java index db3f5723ad..ff89b4b482 100644 --- a/src/main/java/org/mockito/Answers.java +++ b/src/main/java/org/mockito/Answers.java @@ -87,15 +87,6 @@ public enum Answers implements Answer<Object>{ this.implementation = implementation; } - /** - * @deprecated Use the enum-constant directly, instead of this getter. This method will be removed in a future release<br> - * E.g. instead of <code>Answers.CALLS_REAL_METHODS.get()</code> use <code>Answers.CALLS_REAL_METHODS</code> . - */ - @Deprecated - public Answer<Object> get() { - return this; - } - public Object answer(InvocationOnMock invocation) throws Throwable { return implementation.answer(invocation); } diff --git a/src/main/java/org/mockito/ArgumentCaptor.java b/src/main/java/org/mockito/ArgumentCaptor.java index e84de14c83..0bf639d414 100644 --- a/src/main/java/org/mockito/ArgumentCaptor.java +++ b/src/main/java/org/mockito/ArgumentCaptor.java @@ -65,26 +65,6 @@ public class ArgumentCaptor<T> { private final CapturingMatcher<T> capturingMatcher = new CapturingMatcher<T>(); private final Class<? extends T> clazz; - /** - * @deprecated - * - * <b>Please use factory method {@link ArgumentCaptor#forClass(Class)} to create captors</b> - * <p> - * This is required to avoid NullPointerExceptions when autoUnboxing primitive types. - * See issue 99. - * <p> - * Example: - * <pre class="code"><code class="java"> - * ArgumentCaptor&lt;Person&gt; argument = ArgumentCaptor.forClass(Person.class); - * verify(mock).doSomething(argument.capture()); - * assertEquals("John", argument.getValue().getName()); - * </code></pre> - */ - @Deprecated - public ArgumentCaptor() { - this.clazz = null; - } - private ArgumentCaptor(Class<? extends T> clazz) { this.clazz = clazz; } diff --git a/src/main/java/org/mockito/exceptions/Discrepancy.java b/src/main/java/org/mockito/exceptions/Discrepancy.java deleted file mode 100644 index 4b3e4d7f2d..0000000000 --- a/src/main/java/org/mockito/exceptions/Discrepancy.java +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.exceptions; - -@Deprecated -/** - * @Deprecated. This class has been moved to internal packages because it was never meant to be public. - * If you need it for extending Mockito please let us know. You can still use {@link org.mockito.internal.reporting.Discrepancy}. - * However, the package clearly states that the class in a part of a public API so it can change. - */ -public class Discrepancy extends org.mockito.internal.reporting.Discrepancy { - public Discrepancy(int wantedCount, int actualCount) { - super(wantedCount, actualCount); - } -} \ No newline at end of file diff --git a/src/main/java/org/mockito/exceptions/Pluralizer.java b/src/main/java/org/mockito/exceptions/Pluralizer.java deleted file mode 100644 index 0dcecee5e9..0000000000 --- a/src/main/java/org/mockito/exceptions/Pluralizer.java +++ /dev/null @@ -1,13 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.exceptions; - -@Deprecated -/** - * @Deprecated. This class has been moved to internal packages because it was never meant to be public. - * If you need it for extending Mockito please let us know. You can still use {@link org.mockito.internal.reporting.Pluralizer}. - * However, the package clearly states that the class in a part of a public API so it can change. - */ -public class Pluralizer extends org.mockito.internal.reporting.Pluralizer {} diff --git a/src/main/java/org/mockito/exceptions/PrintableInvocation.java b/src/main/java/org/mockito/exceptions/PrintableInvocation.java deleted file mode 100644 index 52e288ddc8..0000000000 --- a/src/main/java/org/mockito/exceptions/PrintableInvocation.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ - -package org.mockito.exceptions; - -import org.mockito.invocation.DescribedInvocation; -import org.mockito.invocation.Location; - -@Deprecated -/** - * @Deprecated. We needed to move this class to a better place to keep consistency of the API. - * Please use {@link DescribedInvocation} instead. - */ -public interface PrintableInvocation { - - String toString(); - - Location getLocation(); - -} \ No newline at end of file diff --git a/src/main/java/org/mockito/exceptions/verification/junit/JUnitTool.java b/src/main/java/org/mockito/exceptions/verification/junit/JUnitTool.java deleted file mode 100644 index f5c614a3d3..0000000000 --- a/src/main/java/org/mockito/exceptions/verification/junit/JUnitTool.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.exceptions.verification.junit; - -@Deprecated -/** - * @Deprecated. This class has been moved to internal packages because it was never meant to be public. - * If you need it for extending Mockito please let us know. You can still use {@link org.mockito.internal.junit.JUnitTool}. - * However, the package clearly states that the class in a part of a public API so it can change. - */ -public class JUnitTool { - - public static boolean hasJUnit() { - return org.mockito.internal.junit.JUnitTool.hasJUnit(); - } - - public static AssertionError createArgumentsAreDifferentException(String message, String wanted, String actual) { - return org.mockito.internal.junit.JUnitTool.createArgumentsAreDifferentException(message, wanted, actual); - } -} \ No newline at end of file diff --git a/src/main/java/org/mockito/invocation/DescribedInvocation.java b/src/main/java/org/mockito/invocation/DescribedInvocation.java index b18223560b..fc975aba44 100644 --- a/src/main/java/org/mockito/invocation/DescribedInvocation.java +++ b/src/main/java/org/mockito/invocation/DescribedInvocation.java @@ -4,12 +4,11 @@ */ package org.mockito.invocation; -import org.mockito.exceptions.PrintableInvocation; /** * Provides information about the invocation, specifically a human readable description and the location. */ -public interface DescribedInvocation extends PrintableInvocation { +public interface DescribedInvocation { /** * Describes the invocation in the human friendly way. diff --git a/src/main/java/org/mockito/listeners/MethodInvocationReport.java b/src/main/java/org/mockito/listeners/MethodInvocationReport.java index da171ba911..a7303e892b 100644 --- a/src/main/java/org/mockito/listeners/MethodInvocationReport.java +++ b/src/main/java/org/mockito/listeners/MethodInvocationReport.java @@ -4,7 +4,6 @@ */ package org.mockito.listeners; -import org.mockito.exceptions.PrintableInvocation; import org.mockito.invocation.DescribedInvocation; /** @@ -18,10 +17,6 @@ */ public interface MethodInvocationReport { /** - * The return type is deprecated, please assign the return value from this method - * to the {@link DescribedInvocation} type. Sorry for inconvenience but we had to move - * {@link PrintableInvocation} to better place to keep the API consistency. - * * @return Information on the method call, never {@code null} */ DescribedInvocation getInvocation(); diff --git a/src/main/java/org/mockito/runners/MockitoJUnit44Runner.java b/src/main/java/org/mockito/runners/MockitoJUnit44Runner.java deleted file mode 100644 index 4080d1ef8e..0000000000 --- a/src/main/java/org/mockito/runners/MockitoJUnit44Runner.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ - -package org.mockito.runners; - -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; - -import java.lang.reflect.InvocationTargetException; - -/** - * <b>Deprecated: Simply use {@link MockitoJUnitRunner}</b> - * <p> - * Compatible only with <b>JUnit 4.4</b>, this runner adds following behavior: - * <ul> - * <li> - * Initializes mocks annotated with {@link Mock}, - * so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary. - * Mocks are initialized before each test method. - * <li> - * validates framework usage after each test method. See javadoc for {@link Mockito#validateMockitoUsage()}. - * </ul> - * - * Runner is completely optional - there are other ways you can get &#064;Mock working, for example by writing a base class. - * Explicitly validating framework usage is also optional because it is triggered automatically by Mockito every time you use the framework. - * See javadoc for {@link Mockito#validateMockitoUsage()}. - * <p> - * Read more about &#064;Mock annotation in javadoc for {@link MockitoAnnotations} - * <p> - * Example: - * <pre class="code"><code class="java"> - * &#064;RunWith(MockitoJUnitRunner.class) - * public class ExampleTest { - * - * &#064;Mock - * private List list; - * - * &#064;Test - * public void shouldDoSomething() { - * list.add(100); - * } - * } - * <p> - * - * </code></pre> - */ -@Deprecated -public class MockitoJUnit44Runner extends MockitoJUnitRunner { - - public MockitoJUnit44Runner(Class<?> klass) throws InvocationTargetException { - super(klass); - } -} \ No newline at end of file diff --git a/src/main/java/org/mockito/stubbing/answers/ReturnsElementsOf.java b/src/main/java/org/mockito/stubbing/answers/ReturnsElementsOf.java deleted file mode 100644 index bd8f182455..0000000000 --- a/src/main/java/org/mockito/stubbing/answers/ReturnsElementsOf.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.stubbing.answers; - -import java.util.Collection; - -/** - * Returns elements of the collection. Keeps returning the last element forever. - * Might be useful on occasion when you have a collection of elements to return. - * <p> - * <pre class="code"><code class="java"> - * //this: - * when(mock.foo()).thenReturn(1, 2, 3); - * //is equivalent to: - * when(mock.foo()).thenReturn(new ReturnsElementsOf(Arrays.asList(1, 2, 3))); - * </code></pre> - * - * @deprecated Use {@link org.mockito.AdditionalAnswers#returnsElementsOf} - */ -@Deprecated -public class ReturnsElementsOf extends org.mockito.internal.stubbing.answers.ReturnsElementsOf { - - @Deprecated - public ReturnsElementsOf(Collection<?> elements) { - super(elements); - } -} \ No newline at end of file

diff --git a/src/test/java/org/mockito/runners/RunnersValidateFrameworkUsageTest.java b/src/test/java/org/mockito/runners/RunnersValidateFrameworkUsageTest.java index 35f29a78d3..44f1de9a06 100644 --- a/src/test/java/org/mockito/runners/RunnersValidateFrameworkUsageTest.java +++ b/src/test/java/org/mockito/runners/RunnersValidateFrameworkUsageTest.java @@ -16,7 +16,7 @@ import org.mockito.internal.runners.util.FrameworkUsageValidator; import org.mockitoutil.TestBase; -@SuppressWarnings({"unchecked", "deprecation"}) +@SuppressWarnings({"unchecked"}) public class RunnersValidateFrameworkUsageTest extends TestBase { private Runner runner; @@ -51,7 +51,7 @@ public void shouldValidateWithDefaultRunner() throws Exception { @Test public void shouldValidateWithD44Runner() throws Exception { //given - runner = new MockitoJUnit44Runner(DummyTest.class); + runner = new MockitoJUnitRunner(DummyTest.class); //when runner.run(notifier); diff --git a/src/test/java/org/mockitousage/junitrunner/JUnit44RunnerTest.java b/src/test/java/org/mockitousage/junitrunner/JUnit44RunnerTest.java deleted file mode 100644 index cc5e08a451..0000000000 --- a/src/test/java/org/mockitousage/junitrunner/JUnit44RunnerTest.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockitousage.junitrunner; - -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; -import static org.mockitousage.junitrunner.Filters.*; - -import java.util.List; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.runners.MockitoJUnit44Runner; - -@RunWith(MockitoJUnit44Runner.class) -@SuppressWarnings( { "unchecked", "deprecation" }) -public class JUnit44RunnerTest { - - @InjectMocks - private ListDependent listDependent = new ListDependent(); - - @Mock - private List list; - - @Test - public void shouldInitMocksUsingRunner() { - list.add("test"); - verify(list).add("test"); - } - @Test - public void shouldInjectMocksUsingRunner() { - assertSame(list, listDependent.getList()); - } - - @Test - public void shouldFilterTestMethodsCorrectly() throws Exception{ - MockitoJUnit44Runner runner = new MockitoJUnit44Runner(this.getClass()); - - runner.filter(methodNameContains("shouldInitMocksUsingRunner")); - - assertEquals(1, runner.testCount()); - } - - class ListDependent { - private List list; - - public List getList() { - return list; - } - } -} \ No newline at end of file diff --git a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java b/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java index 43c362a9b4..9457cd51c5 100644 --- a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java +++ b/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java @@ -63,7 +63,7 @@ interface EmailService { @Test public void should_allow_assertions_on_captured_argument() { //given - ArgumentCaptor<Person> argument = new ArgumentCaptor<Person>(); + ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); //when bulkEmailService.email(12); diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java index ea57e5e645..2522224197 100644 --- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java +++ b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java @@ -12,13 +12,12 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.exceptions.verification.NeverWantedButInvoked; -import org.mockito.runners.MockitoJUnit44Runner; +import org.mockito.runners.MockitoJUnitRunner; import org.mockitousage.IMethods; import org.mockitoutil.TestBase; //This is required to make sure stack trace is well filtered when runner is ON -@SuppressWarnings("deprecation") -@RunWith(MockitoJUnit44Runner.class) +@RunWith(MockitoJUnitRunner.class) public class PointingStackTraceToActualInvocationTest extends TestBase { @Mock private IMethods mock; diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java index b85c2394eb..8fb8a89857 100644 --- a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java +++ b/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java @@ -11,9 +11,9 @@ import java.util.List; import org.junit.Test; +import org.mockito.AdditionalAnswers; import org.mockito.Mock; import org.mockito.exceptions.base.MockitoException; -import org.mockito.stubbing.answers.ReturnsElementsOf; import org.mockitousage.IMethods; import org.mockitoutil.TestBase; @@ -25,7 +25,7 @@ public class StubbingWithExtraAnswersTest extends TestBase { public void shouldWorkAsStandardMockito() throws Exception { //when List<Integer> list = asList(1, 2, 3); - when(mock.objectReturningMethodNoArgs()).thenAnswer(new ReturnsElementsOf(list)); + when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list)); //then assertEquals(1, mock.objectReturningMethodNoArgs()); @@ -40,7 +40,7 @@ public void shouldWorkAsStandardMockito() throws Exception { public void shouldReturnNullIfNecessary() throws Exception { //when List<Integer> list = asList(1, null); - when(mock.objectReturningMethodNoArgs()).thenAnswer(new ReturnsElementsOf(list)); + when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list)); //then assertEquals(1, mock.objectReturningMethodNoArgs()); @@ -52,7 +52,7 @@ public void shouldReturnNullIfNecessary() throws Exception { public void shouldScreamWhenNullPassed() throws Exception { try { //when - new ReturnsElementsOf(null); + AdditionalAnswers.returnsElementsOf(null); //then fail(); } catch (MockitoException e) {}

train

train

ChristianSchwarz

train

mockito/mockito/407_412

mockito/mockito

mockito/mockito/407

mockito/mockito/412

8331e6e4bb37e459950dc12ef48ff4f5ed10f953

3da645d2d38e6be82bdcd2ee2bb7abf08deb74d9

Vararg method call on mock object fails when used org.mockito.AdditionalAnswers#delegatesTo

I try to mock interface with varargs method and default implementation in final class and get this error: ``` java.lang.IllegalArgumentException: wrong number of arguments at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.mockito.internal.stubbing.defaultanswers.ForwardsInvocations.answer(ForwardsInvocations.java:31) at org.mockito.internal.handler.MockHandlerImpl.handle(MockHandlerImpl.java:93) at org.mockito.internal.handler.NullResultGuardian.handle(NullResultGuardian.java:29) at org.mockito.internal.handler.InvocationNotifierHandler.handle(InvocationNotifierHandler.java:38) at org.mockito.internal.creation.MethodInterceptorFilter.intercept(MethodInterceptorFilter.java:51) ``` I run the following code: ``` java public class DefaultAnswerDemo { public interface Foo { void bar(String baz, Object... args); } public static final class FooImpl implements Foo { @Override public void bar(String baz, Object... args) { System.out.println("bar"); } } @Test public void defaultAnswerTest() { Foo fooImpl = new FooImpl(); Foo foo = mock(Foo.class, withSettings() .defaultAnswer(delegatesTo(fooImpl))); foo.bar("baz", 12, "45", 67.8); } } ``` This is happens because org.mockito.internal.invocation.InvocationImpl by default expands varargs arguments to flat list. And I have no idea, how correctly fix this.

diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java index 1916a62ce2..95da223adf 100644 --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java @@ -9,6 +9,7 @@ import java.lang.reflect.Method; import org.mockito.exceptions.Reporter; +import org.mockito.invocation.Invocation; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -37,8 +38,9 @@ public Object answer(InvocationOnMock invocation) throws Throwable { if (!compatibleReturnTypes(mockMethod.getReturnType(), delegateMethod.getReturnType())) { new Reporter().delegatedMethodHasWrongReturnType(mockMethod, delegateMethod, invocation.getMock(), delegatedObject); } - - result = delegateMethod.invoke(delegatedObject, invocation.getArguments()); + + Object[] rawArguments = ((Invocation) invocation).getRawArguments(); + result = delegateMethod.invoke(delegatedObject, rawArguments); } catch (NoSuchMethodException e) { new Reporter().delegatedMethodDoesNotExistOnDelegate(mockMethod, invocation.getMock(), delegatedObject); } catch (InvocationTargetException e) {

diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java new file mode 100644 index 0000000000..42234edc08 --- /dev/null +++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java @@ -0,0 +1,30 @@ +package org.mockito.internal.stubbing.defaultanswers; + +import org.junit.Test; +import org.mockitoutil.TestBase; + +public class ForwardsInvocationsTest extends TestBase { + + interface Foo { + int bar(String baz, Object... args); + } + + private static final class FooImpl implements Foo { + @Override + public int bar(String baz, Object... args) { + return baz.length() + args.length; + } + } + + @Test + public void should_call_method_with_varargs() throws Throwable { + ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl()); + assertEquals(4, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {12, "3", 4.5}))); + } + + @Test + public void should_call_method_with_empty_varargs() throws Throwable { + ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl()); + assertEquals(1, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {}))); + } +} \ No newline at end of file diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java new file mode 100644 index 0000000000..5f41d7178a --- /dev/null +++ b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java @@ -0,0 +1,46 @@ +package org.mockitousage.stubbing; + +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.AdditionalAnswers.delegatesTo; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.withSettings; + +public class StubbingWithDelegateVarArgsTest { + + public interface Foo { + int bar(String baz, Object... args); + } + + private static final class FooImpl implements Foo { + + @Override + public int bar(String baz, Object... args) { + return args != null ? args.length : -1; // simple return argument count + } + + } + + @Test + public void should_not_fail_when_calling_varargs_method() { + Foo foo = mock(Foo.class, withSettings() + .defaultAnswer(delegatesTo(new FooImpl()))); + assertThat(foo.bar("baz", 12, "45", 67.8)).isEqualTo(3); + } + + @Test + public void should_not_fail_when_calling_varargs_method_without_arguments() { + Foo foo = mock(Foo.class, withSettings() + .defaultAnswer(delegatesTo(new FooImpl()))); + assertThat(foo.bar("baz")).isEqualTo(0); + assertThat(foo.bar("baz", new Object[0])).isEqualTo(0); + } + + @Test + public void should_not_fail_when_calling_varargs_method_with_null_argument() { + Foo foo = mock(Foo.class, withSettings() + .defaultAnswer(delegatesTo(new FooImpl()))); + assertThat(foo.bar("baz", (Object[]) null)).isEqualTo(-1); + } +}

train

train

iam-afk

train

mockito/mockito/422_423

mockito/mockito

mockito/mockito/422

mockito/mockito/423

74e312b7a9236a43eb543bd3184607b75375bc40

d528d12806a460dd1a646e49afc09dab3cc1c8fe

Whitebox.setInternalState for private static final fields

Hello, Can you please add the ability for [Whitebox.setInternalState](https://github.com/mockito/mockito/blob/74e312b7a9236a43eb543bd3184607b75375bc40/src/main/java/org/mockito/internal/util/reflection/Whitebox.java#L22-L31) to be invokable on classes with private static final field? ``` java Whitebox.setInternalState(ClassToTest.class, "LOG", mockLog); ``` I did not understand where is the best place to add a feature request. I hope this is the best place. Thank you

diff --git a/src/main/java/org/mockito/internal/util/reflection/Whitebox.java b/src/main/java/org/mockito/internal/util/reflection/Whitebox.java index c63f59b87a..14ea30be98 100644 --- a/src/main/java/org/mockito/internal/util/reflection/Whitebox.java +++ b/src/main/java/org/mockito/internal/util/reflection/Whitebox.java @@ -5,31 +5,58 @@ package org.mockito.internal.util.reflection; import java.lang.reflect.Field; +import java.lang.reflect.Modifier; public class Whitebox { - public static Object getInternalState(Object target, String field) { - Class<?> c = target.getClass(); + public static Object getInternalState(Object targetInstance, String fieldName) { + return getInternalState(targetInstance.getClass(), targetInstance, fieldName); + } + + public static Object getInternalState(Class targetClass, String fieldName) { + return getInternalState(targetClass, null, fieldName); + } + + private static Object getInternalState(Class<?> targetClass, Object targetInstance, String fieldName) { try { - Field f = getFieldFromHierarchy(c, field); + Field f = getFieldFromHierarchy(targetClass, fieldName); f.setAccessible(true); - return f.get(target); + return f.get(targetInstance); } catch (Exception e) { throw new RuntimeException("Unable to get internal state on a private field. Please report to mockito mailing list.", e); } } - public static void setInternalState(Object target, String field, Object value) { - Class<?> c = target.getClass(); + public static void setInternalState(Object targetInstance, String fieldName, Object value) { + setInternalState(targetInstance.getClass(), targetInstance, fieldName, value); + } + + public static void setInternalState(Class targetClass, String fieldName, Object value) { + setInternalState(targetClass, null, fieldName, value); + } + + private static void setInternalState(Class targetClass, Object targetInstance, String fieldName, Object value) { try { - Field f = getFieldFromHierarchy(c, field); + Field f = getFieldFromHierarchy(targetClass, fieldName); f.setAccessible(true); - f.set(target, value); + removeFinalModifierIfPresent(f); + f.set(targetInstance, value); } catch (Exception e) { throw new RuntimeException("Unable to set internal state on a private field. Please report to mockito mailing list.", e); } } + private static void removeFinalModifierIfPresent(Field fieldToRemoveFinalFrom) throws IllegalAccessException, NoSuchFieldException { + int fieldModifiersMask = fieldToRemoveFinalFrom.getModifiers(); + boolean isFinalModifierPresent = (fieldModifiersMask & Modifier.FINAL) == Modifier.FINAL; + if (isFinalModifierPresent) { + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + int fieldModifiersMaskWithoutFinal = fieldModifiersMask & ~Modifier.FINAL; + modifiersField.setInt(fieldToRemoveFinalFrom, fieldModifiersMaskWithoutFinal); + } + } + private static Field getFieldFromHierarchy(Class<?> clazz, String field) { Field f = getField(clazz, field); while (f == null && clazz != Object.class) {

diff --git a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java b/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java index 6967c02c8a..2b5da62228 100644 --- a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java +++ b/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java @@ -4,8 +4,13 @@ */ package org.mockito.internal.util.reflection; +import java.util.logging.Logger; + public class DummyParentClassForTests { + @SuppressWarnings("unused")//I know, I know. We're doing nasty reflection hacks here... + private static final Logger LOG = Logger.getLogger(DummyParentClassForTests.class.toString()); + @SuppressWarnings("unused")//I know, I know. We're doing nasty reflection hacks here... private String somePrivateField; } diff --git a/src/test/java/org/mockito/internal/util/reflection/WhiteboxTest.java b/src/test/java/org/mockito/internal/util/reflection/WhiteboxTest.java index add464c140..97a07ea530 100644 --- a/src/test/java/org/mockito/internal/util/reflection/WhiteboxTest.java +++ b/src/test/java/org/mockito/internal/util/reflection/WhiteboxTest.java @@ -5,10 +5,16 @@ package org.mockito.internal.util.reflection; import org.junit.Test; +import org.mockito.Mock; import org.mockitoutil.TestBase; +import java.util.logging.Logger; + public class WhiteboxTest extends TestBase { + @Mock + Logger mockLogger; + @Test public void private_state() { //given @@ -19,4 +25,13 @@ public void private_state() { Object internalState = Whitebox.getInternalState(dummy, "somePrivateField"); assertEquals("cool!", internalState); } + + @Test + public void private_static_final_state() { + //when + Whitebox.setInternalState(DummyParentClassForTests.class, "LOG", mockLogger); + //then + Object internalState = Whitebox.getInternalState(DummyParentClassForTests.class, "LOG"); + assertEquals(mockLogger, internalState); + } } \ No newline at end of file

test

train

andreicristianpetcu

train

mockito/mockito/426_432

mockito/mockito

mockito/mockito/426

mockito/mockito/432

a1de9a5e1d38774f2f3e343e60c56e8f000b71ca

3c4edc6b49ce4a30dcaf00a78cf014c245f2eefa

Refactor instance based utility classes to static utility classes

The internal implementation of Mockito contains numerous helper classed that serve as a container for useful methods. By its nature these classes don't have a state. Currently some them are instance based in other word you need to create the utility class to call a helper method. This not only pollutes the heap but also the code cause instance methods can't be imported statically. Here is an example: ```java Helper helper = new Helper(); if (helper.isInputValid(input)){ [...] } ``` vs. static import of Helper.isInputValid ```java if (isInputValid(input)){ [...] } ``` The aim of this ticket is to identify canidates that can be refactored to static utility classes. If you like to refactoring and mockito feel free to send a PR and reference this issue. Refactoring canidates: - [ ] `AccessibilityChanger` - [ ] `BeanPropertySetter` - [ ] `ConditionalStackTraceFilter` - [ ] `FieldCopier` - [ ] `FieldReader` - [ ] `GenericMaster` should be integrate into `GenericTypeResolver` - [ ] `JUnitFailureHacker` can be removed when the deprecated `VerboseMockitoJUnitRunner` is removed - [ ] `LenientCopyTool` - [ ] `MatcherBinder` - [ ] `MockitoCore` should better be a singleton - [x] `MockCreationValidator` - [ ] `RemoveFirstLine` - [x] #591 `ArgumentMatchingTool` - [x] #515 `AllInvocationsFinder` - [x] #502 `ArgumentsComparator` - [x] #540 `ArrayUtils` - [x] #490 `AtLeastXNumberOfInvocationsChecker` - [x] #490 `AtLeastXNumberOfInvocationsInOrderChecker` - [ ] #912 `Constructors` - [x] #427 `FieldSetter` - [x] #908 `FriendlyExceptionMaker` - [x] #431 `HandyReturnValues` - [x] #432 `InvocationMarker` - [x] #462 `InvocationsFinder` - [x] #908 `JUnitDetecter` - [x] #490 `MissingInvocationChecker` - [x] #490 `MissingInvocationInOrderChecker` - [x] #514 `MockUtil` - [x] #503 `NonGreedyNumberOfInvocationsInOrderChecker` - [x] #907 `NumberOfInvocationsInOrderChecker` - [x] #907 `NumberOfInvocationsChecker` - [x] #547 `ObjectMethodsGuru` - [x] #427 `Reporter` - [x] #535 `SuperTypesLastSorter` - [x] #501 `TestMethodFinder` - [x] #515 `VerifiableInvocationsFinder`

diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java b/src/main/java/org/mockito/internal/invocation/InvocationMarker.java index 882ccf2681..f05a22158b 100644 --- a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java +++ b/src/main/java/org/mockito/internal/invocation/InvocationMarker.java @@ -11,22 +11,24 @@ public class InvocationMarker { - public void markVerified(List<Invocation> invocations, CapturesArgumentsFromInvocation wanted) { + private InvocationMarker(){} + + public static void markVerified(List<Invocation> invocations, CapturesArgumentsFromInvocation wanted) { for (Invocation invocation : invocations) { markVerified(invocation, wanted); } } - public void markVerified(Invocation invocation, CapturesArgumentsFromInvocation wanted) { + public static void markVerified(Invocation invocation, CapturesArgumentsFromInvocation wanted) { invocation.markVerified(); wanted.captureArgumentsFrom(invocation); } - public void markVerifiedInOrder(List<Invocation> chunk, CapturesArgumentsFromInvocation wanted, InOrderContext context) { + public static void markVerifiedInOrder(List<Invocation> chunk, CapturesArgumentsFromInvocation wanted, InOrderContext context) { markVerified(chunk, wanted); for (Invocation i : chunk) { context.markVerified(i); } } -} +} \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/verification/AtMost.java b/src/main/java/org/mockito/internal/verification/AtMost.java index 8b5e0eeef9..a47c832949 100644 --- a/src/main/java/org/mockito/internal/verification/AtMost.java +++ b/src/main/java/org/mockito/internal/verification/AtMost.java @@ -6,14 +6,13 @@ package org.mockito.internal.verification; import static org.mockito.exceptions.Reporter.wantedAtMostX; +import static org.mockito.internal.invocation.InvocationMarker.markVerified; import java.util.Iterator; import java.util.List; -import org.mockito.exceptions.Reporter; import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.invocation.InvocationMatcher; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.verification.api.VerificationData; import org.mockito.invocation.Invocation; @@ -22,7 +21,6 @@ public class AtMost implements VerificationMode { private final int maxNumberOfInvocations; - private final InvocationMarker invocationMarker = new InvocationMarker(); public AtMost(int maxNumberOfInvocations) { if (maxNumberOfInvocations < 0) { @@ -43,7 +41,7 @@ public void verify(VerificationData data) { } removeAlreadyVerified(found); - invocationMarker.markVerified(found, wanted); + markVerified(found, wanted); } @Override diff --git a/src/main/java/org/mockito/internal/verification/Only.java b/src/main/java/org/mockito/internal/verification/Only.java index 04b4bdbfcc..cf7febb8aa 100644 --- a/src/main/java/org/mockito/internal/verification/Only.java +++ b/src/main/java/org/mockito/internal/verification/Only.java @@ -6,10 +6,10 @@ import static org.mockito.exceptions.Reporter.noMoreInteractionsWanted; import static org.mockito.exceptions.Reporter.wantedButNotInvoked; +import static org.mockito.internal.invocation.InvocationMarker.markVerified; import java.util.List; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.verification.api.VerificationData; @@ -19,7 +19,6 @@ public class Only implements VerificationMode { private final InvocationsFinder finder = new InvocationsFinder(); - private final InvocationMarker marker = new InvocationMarker(); @SuppressWarnings("unchecked") public void verify(VerificationData data) { @@ -33,7 +32,7 @@ public void verify(VerificationData data) { if (invocations.size() != 1 || chunk.size() == 0) { throw wantedButNotInvoked(wantedMatcher); } - marker.markVerified(chunk.get(0), wantedMatcher); + markVerified(chunk.get(0), wantedMatcher); } public VerificationMode description(String description) { diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java index 4eadb22e85..4a9e5dca7e 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java @@ -6,10 +6,10 @@ package org.mockito.internal.verification.checkers; import static org.mockito.exceptions.Reporter.tooLittleActualInvocations; +import static org.mockito.internal.invocation.InvocationMarker.markVerified; import java.util.List; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.invocation.Invocation; @@ -18,7 +18,6 @@ public class AtLeastXNumberOfInvocationsChecker { InvocationsFinder finder = new InvocationsFinder(); - InvocationMarker invocationMarker = new InvocationMarker(); public void check(List<Invocation> invocations, InvocationMatcher wanted, int wantedCount) { List<Invocation> actualInvocations = finder.findInvocations(invocations, wanted); @@ -29,6 +28,6 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa throw tooLittleActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, lastLocation); } - invocationMarker.markVerified(actualInvocations, wanted); + markVerified(actualInvocations, wanted); } } \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsInOrderChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsInOrderChecker.java index c3d7f93cbb..96c61dc43d 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsInOrderChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsInOrderChecker.java @@ -6,10 +6,10 @@ package org.mockito.internal.verification.checkers; import static org.mockito.exceptions.Reporter.tooLittleActualInvocationsInOrder; +import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder; import java.util.List; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.verification.api.InOrderContext; @@ -19,7 +19,6 @@ public class AtLeastXNumberOfInvocationsInOrderChecker { private final InvocationsFinder finder = new InvocationsFinder(); - private final InvocationMarker invocationMarker = new InvocationMarker(); private final InOrderContext orderingContext; public AtLeastXNumberOfInvocationsInOrderChecker(InOrderContext orderingContext) { @@ -36,6 +35,6 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa throw tooLittleActualInvocationsInOrder(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, lastLocation); } - invocationMarker.markVerifiedInOrder(chunk, wanted, orderingContext); + markVerifiedInOrder(chunk, wanted, orderingContext); } } \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/verification/checkers/NonGreedyNumberOfInvocationsInOrderChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NonGreedyNumberOfInvocationsInOrderChecker.java index a6c205b06a..6f40481ee8 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/NonGreedyNumberOfInvocationsInOrderChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/NonGreedyNumberOfInvocationsInOrderChecker.java @@ -5,8 +5,11 @@ package org.mockito.internal.verification.checkers; -import org.mockito.exceptions.Reporter; -import org.mockito.internal.invocation.InvocationMarker; +import static org.mockito.exceptions.Reporter.tooLittleActualInvocationsInOrder; +import static org.mockito.internal.invocation.InvocationMarker.markVerified; + +import java.util.List; + import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.reporting.Discrepancy; @@ -14,22 +17,16 @@ import org.mockito.invocation.Invocation; import org.mockito.invocation.Location; -import static org.mockito.exceptions.Reporter.tooLittleActualInvocationsInOrder; - -import java.util.List; - public class NonGreedyNumberOfInvocationsInOrderChecker { private final InvocationsFinder finder; - private final InvocationMarker marker; public NonGreedyNumberOfInvocationsInOrderChecker() { - this(new InvocationsFinder(), new InvocationMarker()); + this(new InvocationsFinder()); } - NonGreedyNumberOfInvocationsInOrderChecker(InvocationsFinder finder, InvocationMarker marker ) { + NonGreedyNumberOfInvocationsInOrderChecker(InvocationsFinder finder ) { this.finder = finder; - this.marker = marker; } public void check(List<Invocation> invocations, InvocationMatcher wanted, int wantedCount, InOrderContext context) { @@ -40,7 +37,7 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa if( next == null ){ throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, lastLocation ); } - marker.markVerified( next, wanted ); + markVerified( next, wanted ); context.markVerified( next ); lastLocation = next.getLocation(); actualCount++; diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java index 7b277e880b..15c7594a47 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java @@ -8,10 +8,10 @@ import static org.mockito.exceptions.Reporter.neverWantedButInvoked; import static org.mockito.exceptions.Reporter.tooLittleActualInvocations; import static org.mockito.exceptions.Reporter.tooManyActualInvocations; +import static org.mockito.internal.invocation.InvocationMarker.markVerified; import java.util.List; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.reporting.Discrepancy; @@ -21,8 +21,6 @@ public class NumberOfInvocationsChecker { private final InvocationsFinder finder=new InvocationsFinder(); - private final InvocationMarker invocationMarker = new InvocationMarker(); - public void check(List<Invocation> invocations, InvocationMatcher wanted, int wantedCount) { List<Invocation> actualInvocations = finder.findInvocations(invocations, wanted); @@ -41,6 +39,6 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa throw tooManyActualInvocations(wantedCount, actualCount, wanted, firstUndesired); } - invocationMarker.markVerified(actualInvocations, wanted); + markVerified(actualInvocations, wanted); } } \ No newline at end of file diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderChecker.java index 5063955968..c9a769546d 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderChecker.java @@ -7,10 +7,10 @@ import static org.mockito.exceptions.Reporter.tooLittleActualInvocationsInOrder; import static org.mockito.exceptions.Reporter.tooManyActualInvocationsInOrder; +import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder; import java.util.List; -import org.mockito.internal.invocation.InvocationMarker; import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.internal.invocation.InvocationsFinder; import org.mockito.internal.reporting.Discrepancy; @@ -19,10 +19,8 @@ import org.mockito.invocation.Location; public class NumberOfInvocationsInOrderChecker { - private final InvocationsFinder finder; - private final InvocationMarker invocationMarker = new InvocationMarker(); public NumberOfInvocationsInOrderChecker() { this(new InvocationsFinder()); @@ -30,7 +28,6 @@ public NumberOfInvocationsInOrderChecker() { NumberOfInvocationsInOrderChecker(InvocationsFinder finder) { this.finder = finder; - } public void check(List<Invocation> invocations, InvocationMatcher wanted, int wantedCount, InOrderContext context) { @@ -47,6 +44,6 @@ public void check(List<Invocation> invocations, InvocationMatcher wanted, int wa throw tooManyActualInvocationsInOrder(wantedCount, actualCount, wanted, firstUndesired); } - invocationMarker.markVerifiedInOrder(chunk, wanted, context); + markVerifiedInOrder(chunk, wanted, context); } } \ No newline at end of file

diff --git a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java b/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java index d85320c485..777e76b517 100644 --- a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java +++ b/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java @@ -17,13 +17,12 @@ public class InvocationMarkerTest extends TestBase { @Test public void shouldMarkInvocationAsVerified() { //given - InvocationMarker marker = new InvocationMarker(); Invocation i = new InvocationBuilder().toInvocation(); InvocationMatcher im = new InvocationBuilder().toInvocationMatcher(); assertFalse(i.isVerified()); //when - marker.markVerified(Arrays.asList(i), im); + InvocationMarker.markVerified(Arrays.asList(i), im); //then assertTrue(i.isVerified()); @@ -32,7 +31,6 @@ public void shouldMarkInvocationAsVerified() { @Test public void shouldCaptureArguments() { //given - InvocationMarker marker = new InvocationMarker(); Invocation i = new InvocationBuilder().toInvocation(); final ObjectBox box = new ObjectBox(); CapturesArgumentsFromInvocation c = new CapturesArgumentsFromInvocation() { @@ -41,7 +39,7 @@ public void captureArgumentsFrom(Invocation i) { }}; //when - marker.markVerified(Arrays.asList(i), c); + InvocationMarker.markVerified(Arrays.asList(i), c); //then assertEquals(i, box.getObject()); @@ -51,14 +49,14 @@ public void captureArgumentsFrom(Invocation i) { public void shouldMarkInvocationsAsVerifiedInOrder() { //given InOrderContextImpl context = new InOrderContextImpl(); - InvocationMarker marker = new InvocationMarker(); + Invocation i = new InvocationBuilder().toInvocation(); InvocationMatcher im = new InvocationBuilder().toInvocationMatcher(); assertFalse(context.isVerified(i)); assertFalse(i.isVerified()); //when - marker.markVerifiedInOrder(Arrays.asList(i), im, context); + InvocationMarker.markVerifiedInOrder(Arrays.asList(i), im, context); //then assertTrue(context.isVerified(i)); diff --git a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java index 9dfb7ca1c7..9e318a4611 100644 --- a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java +++ b/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java @@ -5,22 +5,20 @@ package org.mockito.internal.verification.checkers; import static java.util.Arrays.asList; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.eq; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.Test; -import org.mockito.Mockito; -import org.mockito.internal.invocation.*; +import org.mockito.internal.invocation.InvocationBuilder; +import org.mockito.internal.invocation.InvocationMatcher; import org.mockito.invocation.Invocation; -import org.mockitoutil.TestBase; -public class AtLeastXNumberOfInvocationsCheckerTest extends TestBase { +public class AtLeastXNumberOfInvocationsCheckerTest { @Test public void shouldMarkActualInvocationsAsVerified() { //given AtLeastXNumberOfInvocationsChecker c = new AtLeastXNumberOfInvocationsChecker(); - c.invocationMarker = Mockito.mock(InvocationMarker.class); + Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation(); Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation(); @@ -28,6 +26,6 @@ public void shouldMarkActualInvocationsAsVerified() { c.check(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1); //then - Mockito.verify(c.invocationMarker).markVerified(eq(asList(invocation)), any(CapturesArgumentsFromInvocation.class)); + assertThat(invocation.isVerified()).isTrue(); } }

train

train

ChristianSchwarz

train

mockito/mockito/438_444

mockito/mockito

mockito/mockito/438

mockito/mockito/444

d6480148b28defa299b25230abe7f463f850350a

e75b07853f855e2ae990a87a2cd50b971eed7cff

Add ElementType.PARAMETER to @Mock

Parameterized tests are becoming more common - JUnit 5 explicitly allows parameters and the sample [MockitoExtension](https://github.com/junit-team/junit5-samples/tree/master/junit5-mockito-extension/src/main/java/com/example/mockito) currently includes an @InjectMock to trigger the creation of a mock parameter. It would be so much cleaner to use @Mock in both places. This shouldn't be an issue for most legacy test systems since they don't allow test parameters (by default).

diff --git a/src/main/java/org/mockito/Mock.java b/src/main/java/org/mockito/Mock.java index 91cb0538c8..2988cb2cba 100644 --- a/src/main/java/org/mockito/Mock.java +++ b/src/main/java/org/mockito/Mock.java @@ -9,6 +9,7 @@ import java.lang.annotation.Target; import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.RUNTIME; /** @@ -58,7 +59,7 @@ * @see MockitoAnnotations#initMocks(Object) * @see org.mockito.runners.MockitoJUnitRunner */ -@Target(FIELD) +@Target({FIELD, PARAMETER}) @Retention(RUNTIME) @Documented public @interface Mock {

train

train

smoyer64

train

mockito/mockito/453_454

mockito/mockito

mockito/mockito/453

mockito/mockito/454

ce957844a9adc8403434ccf893b9d68d047573e9

9af742d476dbfc746e2cb09698af3524c96b49ec

Either revert recent Functional Interfaces change or change JavaDoc

I've been reading the Javadoc regarding `ArgumentMatcher` and I noticed a couple of things. Relating back to the changes of #338 - The example of how to override it is still based around `Object` rather than `T` - Someone has very deliberately decided not to make it use `T` in the past and now we've changed that. > The argument is not using the generic type in order to force explicit casting in the implementation. This way it is easier to debug when incompatible arguments are passed to the matchers. You have to trust us on this one. If we used parametrized type then ClassCastException would be thrown in certain scenarios. My view at the time was that changing it to `T` would remove the class casting and that this would be a good thing. It was kind of necessary to have it as `T` so that the lambda expressions in Java 8 could infer the right types. The rationale about a class cast exception giving weird results kind of makes sense, but does that really really happen? It seems it's either solve one problem or the other. What do folks think? I'll happily amend the code either way.

diff --git a/src/main/java/org/mockito/ArgumentMatcher.java b/src/main/java/org/mockito/ArgumentMatcher.java index 3b2e3d19c4..8b9abd0ce4 100644 --- a/src/main/java/org/mockito/ArgumentMatcher.java +++ b/src/main/java/org/mockito/ArgumentMatcher.java @@ -35,6 +35,8 @@ * Useful if you already have a hamcrest matcher. Reuse and win! * Note that {@link org.mockito.hamcrest.MockitoHamcrest#argThat(org.hamcrest.Matcher)} demonstrates <b>NullPointerException</b> auto-unboxing caveat. * </li> + * <li>Java 8 only - use a lambda in place of an {@link ArgumentMatcher} since {@link ArgumentMatcher} + * is effectively a functional interface. A lambda can be used with the {@link Mockito#argThat} method.</li> * </ul> * * <p> @@ -44,8 +46,8 @@ * * <pre class="code"><code class="java"> * class ListOfTwoElements implements ArgumentMatcher&lt;List&gt; { - * public boolean matches(Object list) { - * return ((List) list).size() == 2; + * public boolean matches(List list) { + * return list.size() == 2; * } * public String toString() { * //printed in verification errors @@ -93,6 +95,7 @@ * b) Use <code>org.mockito.hamcrest.MockitoHamcrest.argThat()</code> instead of <code>Mockito.argThat()</code>. * Ensure that there is <a href="http://hamcrest.org/JavaHamcrest/">hamcrest</a> dependency on classpath * (Mockito does not depend on hamcrest any more). + * * </li> * </ul> * What option is right for you? If you don't mind compile dependency to hamcrest @@ -111,22 +114,6 @@ public interface ArgumentMatcher<T> { * The method should <b>never</b> assert if the argument doesn't match. It * should only return false. * <p> - * The argument is not using the generic type in order to force explicit casting in the implementation. - * This way it is easier to debug when incompatible arguments are passed to the matchers. - * You have to trust us on this one. If we used parametrized type then <code>ClassCastException</code> - * would be thrown in certain scenarios. - * For example: - * - * <pre class="code"><code class="java"> - * //test, method accepts Collection argument and ArgumentMatcher&lt;List&gt; is used - * when(mock.useCollection(someListMatcher())).thenDoNothing(); - * - * //production code, yields confusing ClassCastException - * //although Set extends Collection but is not compatible with ArgumentMatcher&lt;List&gt; - * mock.useCollection(new HashSet()); - * </pre> - * - * <p> * See the example in the top level javadoc for {@link ArgumentMatcher} * * @param argument

val

train

ashleyfrieze

train

mockito/mockito/226_481

mockito/mockito

mockito/mockito/226

mockito/mockito/481

1eddf98e096c8d55a4f5a0bc08947003e9448c81

b0393eafeeb81b6c75e40a82b81672543777ca9a

Exclude internal package from javadoc

Internal package don't need to be included in the javadoc generation, just like the jdk doesn't have `com.sun` package In the javadoc that may be done via a doclet since `exclude '**/internal/**'` raise javadoc errors ``` groovy doclet = "qualified.name.of.DocletExclude" docletpath = [rootProject.file('./gradle/doclet-exclude.jar')] ```

diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index 28c2cd953a..6720ba5a90 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -8,6 +8,7 @@ dependencies { //TODO SF use jcabi to edit issues after the release so that they have the milestone attached //compile "com.jcabi:jcabi-github:0.17" compile "com.googlecode.json-simple:json-simple:1.1.1@jar" + compile files("${System.properties['java.home']}/../lib/tools.jar") testCompile("org.spockframework:spock-core:0.7-groovy-2.0") { exclude module: "groovy-all" } diff --git a/buildSrc/src/main/java/org/mockito/javadoc/JavadocExclude.java b/buildSrc/src/main/java/org/mockito/javadoc/JavadocExclude.java new file mode 100644 index 0000000000..3464f0b426 --- /dev/null +++ b/buildSrc/src/main/java/org/mockito/javadoc/JavadocExclude.java @@ -0,0 +1,70 @@ +package org.mockito.javadoc; + +import com.sun.javadoc.*; +import com.sun.tools.doclets.formats.html.HtmlDoclet; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.ArrayList; +import java.util.List; + +/** + * Doclet built to exclude mockito internal packages from the outputted Javadoc. + * All methods except the start method are copied from {@link com.sun.tools.doclets.standard.Standard}. + * Inspired by https://gist.github.com/benjchristensen/1410681 + */ +public class JavadocExclude { + + public static int optionLength(String var0) { + return HtmlDoclet.optionLength(var0); + } + + public static boolean start(RootDoc root) { + Class clz = root.getClass(); + return HtmlDoclet.start((RootDoc) Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), new ExcludeHandler(root))); + } + + public static boolean validOptions(String[][] var0, DocErrorReporter var1) { + return HtmlDoclet.validOptions(var0, var1); + } + + public static LanguageVersion languageVersion() { + return HtmlDoclet.languageVersion(); + } + + /** + * Proxy which filters the {@link RootDoc#classes()} method to filter {@link ClassDoc} based on their package name. + */ + private static class ExcludeHandler implements InvocationHandler { + private final RootDoc root; + + private ExcludeHandler(RootDoc root) { + this.root = root; + } + + @Override + public Object invoke(Object o, Method method, Object[] args) throws Throwable { + Object result = method.invoke(root, args); + if (result instanceof Object[]) { + List<ClassDoc> filteredDocs = new ArrayList<ClassDoc>(); + Object[] array = (Object[]) result; + for (Object entry : array) { + if (entry instanceof ClassDoc) { + ClassDoc doc = (ClassDoc) entry; + if (!doc.containingPackage().name().startsWith("org.mockito.internal")) { + filteredDocs.add(doc); + } + } + } + // If no ClassDoc were found in the original array, + // since PackageDoc area also included in the classes array. + if (filteredDocs.size() > 0) { + ClassDoc[] docArray = new ClassDoc[filteredDocs.size()]; + return filteredDocs.toArray(docArray); + } + } + return result; + } + } +} diff --git a/gradle/javadoc.gradle b/gradle/javadoc.gradle index 4d5daa5d43..51f4cd4e1d 100644 --- a/gradle/javadoc.gradle +++ b/gradle/javadoc.gradle @@ -14,6 +14,8 @@ task mockitoJavadoc(type: Javadoc) { title = "Mockito ${project.version} API" def javadocJdk6Hack = "jdk6-project-version-insert.min.js" + options.doclet "org.mockito.javadoc.JavadocExclude" + options.docletpath = [rootProject.file('./buildSrc/build/classes/main/')] options.docTitle = """<h1><a href="org/mockito/Mockito.html">Click to see examples</a>. Mockito ${project.version} API.</h1>""" options.windowTitle = "Mockito ${project.version} API" options.group("Main package", ["org.mockito"]) diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 80cbe6ead4..0b5a32f1e1 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Sun Mar 09 16:13:07 CET 2016 +#Wed Jul 06 11:31:59 CEST 2016 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.11-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-2.11-all.zip

val

train

bric3

train

mockito/mockito/123_483

mockito/mockito

mockito/mockito/123

mockito/mockito/483

d01911eb9040d21ba6763dfb90c5210bb480e1b9

80ab0db765138a57b105c7a64676ebc38cb94f35

Release Mockito 2.0

Incompatible changes: - [x] stop producing mockito-all #153 - [x] stop depending on hamcrest internally #154 - [x] use newer hamcrest #232 - [x] make the anyXxx and any(Xxx) matchers intuitive #134, #194 - ~~fix the site links~~ - [x] push cglib mockmaker to a separate jar #248 - [x] stop using ant for producing OSGi bundles. No more ant in the build #249 - [x] remove jars from source distribution #250 - ~~perhaps introduce is() matcher~~ #246 - ~~richer and smarter stubbing~~ #303 - ~~support java8 features for capturing arguments and matchers~~ - [x] make the JUnitRule and the runner verbose - [x] ensure release notes can be neatly generated for the RC #582 Possibly compatible (and hence, could be released pre-2.0 if needed) - [x] drop deprecated code - [x] unincubate API - ~~drop serialVersionUID~~

diff --git a/README.md b/README.md index 1ffdd450c9..d3595e27fc 100644 --- a/README.md +++ b/README.md @@ -17,24 +17,34 @@ See the [release notes page](https://github.com/mockito/mockito/blob/master/doc/ ## Versioning -Mockito has an automated release system, which imposed some change on how the version numbers work. While this is similar to [_semver_](http://semver.org/), there's some differences. Let's look at the following versions `1.10.19` and `2.0.5-beta` and `2.0.0` (not yet released). They follow this scheme: +Mockito has an automated release system, which imposed some change on how the version numbers work. +They follow this scheme: ``` -major.minor.build-tag +major.minor.patch-tag.tagVersion ``` | number | meaning | | ------ | ------------------------------------------------------------------------------------- | -| major | major version, with most probably incompatible change in API and behavior | -| minor | minor version, important enough change to bump this number | -| build | a released build number incremented automatically when a pull request is merged | -| tag | will probably be `-beta` or just nothing (during beta, breaking changes are expected) | +| major | major version, backwards incompatible with the previous major version | +| minor | minor version, backwards compatible with added features | +| patch | patch version, small bug fixes or stylistic improvements | +| tag | *optional* beta or RC (release candidate). See below. | That means: -* `2.0.0` and `2.0.5-beta` are binary incompatible with `1.10.19`. -* `2.0.5-beta` is the fifth release beta of version `2.0.0`. -* `2.0.5-beta` is a work in progress, api may change and may not be graduated in version `2.0.0`. +* `2.0.0` and `2.0.0-beta.5` are binary incompatible with `1.10.19`. +* `2.0.0-beta.5` is the fifth release beta of version `2.0.0`. +* `2.0.0-beta.5` could be (but is not necessarily) binary incompatible with version `2.0.0`. +* `2.0.0-RC.1` is binary compatible with release `2.0.0`. + +### Tags +There are two different tags: beta or RC. Beta indicates that the version is directly generated from the master branch of the git repository. +Beta releases are automatically published whenever we merge a pull request or push a change to the master branch. + +When we deem our master status worthy of a release, we publish a release candidate. The release candidate is scheduled to be officially published +in the official release a while later. There will be no breaking changes between a release candidate and its equivalent official release. +The only changes will include bug fixes or small updates. No additional features will be included. ## Looking for support diff --git a/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java b/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java index 01ed67cac5..b6f6ba8e54 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java +++ b/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java @@ -9,17 +9,20 @@ class VersionBumper { * Increments 'patch' element of the version of provided version, e.g. 1.0.0 -> 1.0.1 */ String incrementVersion(String version) { - Pattern pattern = Pattern.compile("(\\d+)\\.(\\d+)\\.(\\d+)(-(\\w+)){0,1}"); + Pattern pattern = Pattern.compile("(\\d+)\\.(\\d+)\\.(\\d+)(-(\\w+)\\.(\\d+))?"); Matcher matcher = pattern.matcher(version); boolean m = matcher.matches(); if (!m) { - throw new IllegalArgumentException("Unsupported version: '" + version + "'. Examples of supported versions: 1.0.0, 1.20.123, 1.0.10-beta"); + throw new IllegalArgumentException("Unsupported version: '" + version + "'. Examples of supported versions: 1.0.0, 1.20.123, 1.0.10-beta.3"); } int major = Integer.parseInt(matcher.group(1)); int minor = Integer.parseInt(matcher.group(2)); int patch = Integer.parseInt(matcher.group(3)); - String postfix = matcher.group(4) != null ? matcher.group(4) : ""; - return "" + major + "." + minor + "." + (patch + 1) + postfix; + if (matcher.group(4) != null) { + int betaVersion = Integer.parseInt(matcher.group(6)); + return "" + major + "." + minor + "." + patch + "-" + matcher.group(5) + "." + (betaVersion + 1); + } + return "" + major + "." + minor + "." + (patch + 1); } } diff --git a/version.properties b/version.properties index 3d70180266..d87a336523 100644 --- a/version.properties +++ b/version.properties @@ -1,2 +1,2 @@ -version=2.0.112-beta +version=2.0.0-beta.112 mockito.testng.version=1.0

diff --git a/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy index db1c3d6835..b34bcda696 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy @@ -13,8 +13,9 @@ class VersionBumperTest extends Specification { v.incrementVersion("0.0.0") == "0.0.1" v.incrementVersion("1.10.15") == "1.10.16" - v.incrementVersion("1.0.0-beta") == "1.0.1-beta" - v.incrementVersion("1.10.15-beta") == "1.10.16-beta" + v.incrementVersion("1.0.0-beta.3") == "1.0.0-beta.4" + v.incrementVersion("1.10.15-beta.5") == "1.10.15-beta.6" + v.incrementVersion("2.0.0-RC.1") == "2.0.0-RC.2" } def "increments only 3 numbered versions"() { @@ -25,6 +26,6 @@ class VersionBumperTest extends Specification { thrown(IllegalArgumentException) where: - unsupported << ["1.0", "2", "1.0.0.0", "1.0.1-beta.2"] + unsupported << ["1.0", "2", "1.0.0.0", "1.0.1-beta"] } }

train

train

mockitoguy

train

mockito/mockito/478_483

mockito/mockito

mockito/mockito/478

mockito/mockito/483

d01911eb9040d21ba6763dfb90c5210bb480e1b9

80ab0db765138a57b105c7a64676ebc38cb94f35

Improve release generator

Currently releases are generated automatically and documentation pushed to the website. However, when we are publishing a major release, this should be changed. Probably the best solution is to disable the automatic generation for now and invoke this manually. This does require some changes to the current Gradle release process. Also, in #79 the changelog was improved. We should take a look at improving this as well. TLDR: Take a good look at the Gradle release process and purge/improve tasks.

diff --git a/README.md b/README.md index 1ffdd450c9..d3595e27fc 100644 --- a/README.md +++ b/README.md @@ -17,24 +17,34 @@ See the [release notes page](https://github.com/mockito/mockito/blob/master/doc/ ## Versioning -Mockito has an automated release system, which imposed some change on how the version numbers work. While this is similar to [_semver_](http://semver.org/), there's some differences. Let's look at the following versions `1.10.19` and `2.0.5-beta` and `2.0.0` (not yet released). They follow this scheme: +Mockito has an automated release system, which imposed some change on how the version numbers work. +They follow this scheme: ``` -major.minor.build-tag +major.minor.patch-tag.tagVersion ``` | number | meaning | | ------ | ------------------------------------------------------------------------------------- | -| major | major version, with most probably incompatible change in API and behavior | -| minor | minor version, important enough change to bump this number | -| build | a released build number incremented automatically when a pull request is merged | -| tag | will probably be `-beta` or just nothing (during beta, breaking changes are expected) | +| major | major version, backwards incompatible with the previous major version | +| minor | minor version, backwards compatible with added features | +| patch | patch version, small bug fixes or stylistic improvements | +| tag | *optional* beta or RC (release candidate). See below. | That means: -* `2.0.0` and `2.0.5-beta` are binary incompatible with `1.10.19`. -* `2.0.5-beta` is the fifth release beta of version `2.0.0`. -* `2.0.5-beta` is a work in progress, api may change and may not be graduated in version `2.0.0`. +* `2.0.0` and `2.0.0-beta.5` are binary incompatible with `1.10.19`. +* `2.0.0-beta.5` is the fifth release beta of version `2.0.0`. +* `2.0.0-beta.5` could be (but is not necessarily) binary incompatible with version `2.0.0`. +* `2.0.0-RC.1` is binary compatible with release `2.0.0`. + +### Tags +There are two different tags: beta or RC. Beta indicates that the version is directly generated from the master branch of the git repository. +Beta releases are automatically published whenever we merge a pull request or push a change to the master branch. + +When we deem our master status worthy of a release, we publish a release candidate. The release candidate is scheduled to be officially published +in the official release a while later. There will be no breaking changes between a release candidate and its equivalent official release. +The only changes will include bug fixes or small updates. No additional features will be included. ## Looking for support diff --git a/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java b/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java index 01ed67cac5..b6f6ba8e54 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java +++ b/buildSrc/src/main/groovy/org/mockito/release/version/VersionBumper.java @@ -9,17 +9,20 @@ class VersionBumper { * Increments 'patch' element of the version of provided version, e.g. 1.0.0 -> 1.0.1 */ String incrementVersion(String version) { - Pattern pattern = Pattern.compile("(\\d+)\\.(\\d+)\\.(\\d+)(-(\\w+)){0,1}"); + Pattern pattern = Pattern.compile("(\\d+)\\.(\\d+)\\.(\\d+)(-(\\w+)\\.(\\d+))?"); Matcher matcher = pattern.matcher(version); boolean m = matcher.matches(); if (!m) { - throw new IllegalArgumentException("Unsupported version: '" + version + "'. Examples of supported versions: 1.0.0, 1.20.123, 1.0.10-beta"); + throw new IllegalArgumentException("Unsupported version: '" + version + "'. Examples of supported versions: 1.0.0, 1.20.123, 1.0.10-beta.3"); } int major = Integer.parseInt(matcher.group(1)); int minor = Integer.parseInt(matcher.group(2)); int patch = Integer.parseInt(matcher.group(3)); - String postfix = matcher.group(4) != null ? matcher.group(4) : ""; - return "" + major + "." + minor + "." + (patch + 1) + postfix; + if (matcher.group(4) != null) { + int betaVersion = Integer.parseInt(matcher.group(6)); + return "" + major + "." + minor + "." + patch + "-" + matcher.group(5) + "." + (betaVersion + 1); + } + return "" + major + "." + minor + "." + (patch + 1); } } diff --git a/version.properties b/version.properties index 3d70180266..d87a336523 100644 --- a/version.properties +++ b/version.properties @@ -1,2 +1,2 @@ -version=2.0.112-beta +version=2.0.0-beta.112 mockito.testng.version=1.0

diff --git a/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy index db1c3d6835..b34bcda696 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/version/VersionBumperTest.groovy @@ -13,8 +13,9 @@ class VersionBumperTest extends Specification { v.incrementVersion("0.0.0") == "0.0.1" v.incrementVersion("1.10.15") == "1.10.16" - v.incrementVersion("1.0.0-beta") == "1.0.1-beta" - v.incrementVersion("1.10.15-beta") == "1.10.16-beta" + v.incrementVersion("1.0.0-beta.3") == "1.0.0-beta.4" + v.incrementVersion("1.10.15-beta.5") == "1.10.15-beta.6" + v.incrementVersion("2.0.0-RC.1") == "2.0.0-RC.2" } def "increments only 3 numbered versions"() { @@ -25,6 +26,6 @@ class VersionBumperTest extends Specification { thrown(IllegalArgumentException) where: - unsupported << ["1.0", "2", "1.0.0.0", "1.0.1-beta.2"] + unsupported << ["1.0", "2", "1.0.0.0", "1.0.1-beta"] } }

val

train

TimvdLippe

train

mockito/mockito/465_493

mockito/mockito

mockito/mockito/465

mockito/mockito/493

5dd0f71ae37f75f3abc9b3d9ba7ad5cb4b79f38a

272b32bb11a41d757c535675b9bfda0fa6ffd90b

Delivery drone breaks codecov

Since the commits of the delivery drone have `[ci skip]`, there is no coverage report for that specific commit. As a result, when a pull request has as base such a commit, CodeCov reports that it could not generate a coverage report. Maybe we can depend executing `gradle release` if the commit is from a user other than the delivery drone, to not break codecov.

diff --git a/.travis.yml b/.travis.yml index 20b34b70df..e1b7d261d7 100644 --- a/.travis.yml +++ b/.travis.yml @@ -39,7 +39,9 @@ branches: install: - true script: - - ./gradlew ciBuild release + - TRAVIS_MESSAGE="$(git log --format=%B -n 1)" + - ./gradlew ciBuild + - if [[ $TRAVIS_MESSAGE != *"[ci skip-release]"* ]] ; then ./gradlew release; fi after_success: - ./gradlew --stacktrace coverageReport && cp build/reports/jacoco/mockitoCoverage/mockitoCoverage.xml jacoco.xml || echo "Code coverage failed" - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports" diff --git a/dummy-commit.txt b/dummy-commit.txt index 39b0928f91..7ca32a7a2e 100644 --- a/dummy-commit.txt +++ b/dummy-commit.txt @@ -1,1 +1,1 @@ -Change this if you need a dummy commit. Push build. +Change this if you need a dummy commit. Push build diff --git a/gradle/release.gradle b/gradle/release.gradle index a748bc1cd1..461d849c38 100644 --- a/gradle/release.gradle +++ b/gradle/release.gradle @@ -86,7 +86,7 @@ release { releaseSteps { String currentVersion = project.version //the version loaded when Gradle build has started - String buildInfo = "by Travis CI build $System.env.TRAVIS_BUILD_NUMBER [ci skip]" + String buildInfo = "by Travis CI build $System.env.TRAVIS_BUILD_NUMBER [ci skip-release]" MaskedArg pushTarget = new MaskedArg(value: "https://szczepiq:${System.env.GH_TOKEN}@github.com/mockito/mockito.git") step("ensure good chunk of recent commits is pulled for release notes automation") { @@ -197,4 +197,4 @@ TODO: -new commits removal (git reset --hard) on all affected branches -clean up after release: -? - */ \ No newline at end of file + */

train

train

TimvdLippe

train

mockito/mockito/482_494

mockito/mockito

mockito/mockito/482

mockito/mockito/494

5dd0f71ae37f75f3abc9b3d9ba7ad5cb4b79f38a

038637612ac8abe962094d87c9cf6252f60a49dc

Restore depecated Answers.get() method

Commit da5e750957b494e7fa0548bf1286d67b8b0386d5 removed the deprecated `Answers.get()` method, however the method was only deprecated in the 2.0 BETA line and never made it into a GA release. It would be helpful if the method could remain in the deprecated form in 2.0 to give people an opportunity to move away from it. (originally raise by a Spring Boot user [here](https://github.com/spring-projects/spring-boot/pull/6323))

diff --git a/src/main/java/org/mockito/Answers.java b/src/main/java/org/mockito/Answers.java index 5d86e9abdf..3f2ec706a1 100644 --- a/src/main/java/org/mockito/Answers.java +++ b/src/main/java/org/mockito/Answers.java @@ -5,11 +5,11 @@ package org.mockito; import org.mockito.internal.stubbing.answers.CallsRealMethods; -import org.mockito.internal.stubbing.defaultanswers.TriesToReturnSelf; import org.mockito.internal.stubbing.defaultanswers.GloballyConfiguredAnswer; import org.mockito.internal.stubbing.defaultanswers.ReturnsDeepStubs; import org.mockito.internal.stubbing.defaultanswers.ReturnsMocks; import org.mockito.internal.stubbing.defaultanswers.ReturnsSmartNulls; +import org.mockito.internal.stubbing.defaultanswers.TriesToReturnSelf; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -24,7 +24,7 @@ * </code></pre> * <b>This is not the full list</b> of Answers available in Mockito. Some interesting answers can be found in org.mockito.stubbing.answers package. */ -public enum Answers implements Answer<Object>{ +public enum Answers implements Answer<Object> { /** * The default configured answer of every mock. * @@ -78,8 +78,7 @@ public enum Answers implements Answer<Object>{ * * @see org.mockito.Mockito#RETURNS_SELF */ - RETURNS_SELF(new TriesToReturnSelf()) - ; + RETURNS_SELF(new TriesToReturnSelf()); private final Answer<Object> implementation; @@ -87,7 +86,16 @@ public enum Answers implements Answer<Object>{ this.implementation = implementation; } + /** + * @deprecated Use the enum-constant directly, instead of this getter. This method will be removed in a future release<br> + * e.g. instead of <code>Answers.CALLS_REAL_METHODS.get()</code> use <code>Answers.CALLS_REAL_METHODS</code>. + */ + @Deprecated + public Answer<Object> get() { + return this; + } + public Object answer(InvocationOnMock invocation) throws Throwable { return implementation.answer(invocation); - } -} \ No newline at end of file + } +}

train

train

philwebb

train

mockito/mockito/506_507

mockito/mockito

mockito/mockito/506

mockito/mockito/507

21f80c8de824fc9a8c3d56fff029f6909d4b5b84

8fc9b5da2156cc8c038f2e2431459127b0901e1f

Improved exception message for wanted but not invoked

Currently, Mockito prints following message when specific verification fails: ``` Wanted but not invoked: mock.simpleMethod(); -> at .... However, there were other interactions with this mock: mock.otherMethod(); -> at .... mock.booleanReturningMethod(); -> at .... ``` It would be useful to print the number of invocations: ``` Wanted but not invoked: mock.simpleMethod(); -> at .... However, there were exactly 2 interactions with this mock: mock.otherMethod(); -> at .... mock.booleanReturningMethod(); -> at .... ```

diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java index 02e9a918fb..47505bf4cb 100644 --- a/src/main/java/org/mockito/internal/exceptions/Reporter.java +++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java @@ -8,13 +8,7 @@ import org.mockito.exceptions.base.MockitoAssertionError; import org.mockito.exceptions.base.MockitoException; import org.mockito.exceptions.misusing.*; -import org.mockito.exceptions.verification.NeverWantedButInvoked; -import org.mockito.exceptions.verification.NoInteractionsWanted; -import org.mockito.exceptions.verification.SmartNullPointerException; -import org.mockito.exceptions.verification.TooLittleActualInvocations; -import org.mockito.exceptions.verification.TooManyActualInvocations; -import org.mockito.exceptions.verification.VerificationInOrderFailure; -import org.mockito.exceptions.verification.WantedButNotInvoked; +import org.mockito.exceptions.verification.*; import org.mockito.internal.debugging.LocationImpl; import org.mockito.internal.exceptions.util.ScenarioPrinter; import org.mockito.internal.junit.JUnitTool; @@ -36,6 +30,7 @@ import java.util.List; import static org.mockito.internal.reporting.Pluralizer.pluralize; +import static org.mockito.internal.reporting.Pluralizer.were_exactly_x_interactions; import static org.mockito.internal.util.StringJoiner.join; /** @@ -319,7 +314,8 @@ public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation want if (invocations.isEmpty()) { allInvocations = "Actually, there were zero interactions with this mock.\n"; } else { - StringBuilder sb = new StringBuilder("\nHowever, there were other interactions with this mock:\n"); + StringBuilder sb = new StringBuilder( + "\nHowever, there " + were_exactly_x_interactions(invocations.size()) + " with this mock:\n"); for (DescribedInvocation i : invocations) { sb.append(i.toString()) .append("\n") diff --git a/src/main/java/org/mockito/internal/reporting/Pluralizer.java b/src/main/java/org/mockito/internal/reporting/Pluralizer.java index 5e597f32ec..1e8d0e3f4b 100644 --- a/src/main/java/org/mockito/internal/reporting/Pluralizer.java +++ b/src/main/java/org/mockito/internal/reporting/Pluralizer.java @@ -9,4 +9,12 @@ public class Pluralizer { public static String pluralize(int number) { return number == 1 ? "1 time" : number + " times"; } + + public static String were_exactly_x_interactions(int x) { + if (x == 1) { + return "was exactly 1 interaction"; + } else { + return "were exactly " + x + " interactions"; + } + } }

diff --git a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java b/src/test/java/org/mockito/internal/reporting/PluralizerTest.java index f35c3a8d0a..c2e1333fe9 100644 --- a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java +++ b/src/test/java/org/mockito/internal/reporting/PluralizerTest.java @@ -12,11 +12,17 @@ public class PluralizerTest extends TestBase { @Test - public void shouldGetPluralizedNumber() { - new Pluralizer(); + public void pluralizes_number() { assertEquals("0 times", Pluralizer.pluralize(0)); assertEquals("1 time", Pluralizer.pluralize(1)); assertEquals("2 times", Pluralizer.pluralize(2)); assertEquals("20 times", Pluralizer.pluralize(20)); } + + @Test + public void pluralizes_interactions() { + assertEquals("were exactly 0 interactions", Pluralizer.were_exactly_x_interactions(0)); + assertEquals("was exactly 1 interaction", Pluralizer.were_exactly_x_interactions(1)); + assertEquals("were exactly 100 interactions", Pluralizer.were_exactly_x_interactions(100)); + } } diff --git a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java index b5ea96b7b1..ee99529fab 100644 --- a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java +++ b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java @@ -55,7 +55,7 @@ public void shouldReportWantedButNotInvoked() { exception.expect(WantedButNotInvoked.class); exception.expectMessage("Wanted but not invoked:"); exception.expectMessage("mock.simpleMethod()"); - exception.expectMessage("However, there were other interactions with this mock:"); + exception.expectMessage("However, there was exactly 1 interaction with this mock:"); exception.expectMessage("mock.differentMethod();"); checker.check(invocations, wanted); diff --git a/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java b/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java index d352fabfa1..f6245a3841 100644 --- a/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java +++ b/src/test/java/org/mockitousage/verification/OrdinaryVerificationPrintsAllInteractionsTest.java @@ -21,14 +21,18 @@ public class OrdinaryVerificationPrintsAllInteractionsTest extends TestBase { @Test public void shouldShowAllInteractionsOnMockWhenOrdinaryVerificationFail() throws Exception { + //given firstInteraction(); secondInteraction(); - + + verify(mock).otherMethod(); //verify 1st interaction try { + //when verify(mock).simpleMethod(); fail(); } catch (WantedButNotInvoked e) { - assertContains("However, there were other interactions with this mock", e.getMessage()); + //then + assertContains("However, there were exactly 2 interactions with this mock", e.getMessage()); assertContains("firstInteraction(", e.getMessage()); assertContains("secondInteraction(", e.getMessage()); }

val

train

mockitoguy

train

mockito/mockito/194_510

mockito/mockito

mockito/mockito/194

mockito/mockito/510

2e1e51cf0f9178c68bcba1c97bcbe3213e002f34

68c7812d29e39d0c459ffd21498018d7801561e8

Tweaks Matchers.any family matchers behavior

This issue is a follow up of the work started in #141 by @pimterry. Also here's an extract of a message on [this thread](https://groups.google.com/forum/#!topic/mockito/8_WGBB3Jbtk) of the mailing list : --- The origin of these methods is they come from `anything` i.e. anything matches, later for shortness and cast avoidance the aliases grew, but the API naming thus became inconsistent with what a human would expect. So this behavior is being changed in mockito 2 beta, to be precise here's the status on these API in the version 2.0.5-beta : - `any`, `anyObject`, `any(Class)` won't check anything (at first they were just aliases for _anything_ and for cast avoidance), `null` is a valid value - `anyX` like `anyString` will check the arg is not `null` and that has the correct type - `anyList` will check the argument is not null and a `List` instance - `anyListOf` (and the likes) at the moment are just aliases to their non generic counter part like `anyList` Note this is work in progress (started here in [#141](https://github.com/mockito/mockito/pull/141)), these new behavior can / will change in the beta phase. I'm especially wondering if the `any` family should allow `null` and if not do a type check. For example with these matchers : - `any`, `anyObject` stay the same, they currently allow `null` and don't have to do type check anyway - `any(Class)` currently allows `null` and doesn't do type check => allows `null` and if not checks for the given type - `any<Collection>Of` currently doesn't allow `null` and does a type check of the collection, not elements => allows `null`, if not checks collection type, if not empty checks element type Maybe extend/create a _symmetric_ `isA` family API that won't allow any `null` arguments. ---

diff --git a/src/main/java/org/mockito/ArgumentMatchers.java b/src/main/java/org/mockito/ArgumentMatchers.java index 8c56882540..51a3bf4993 100644 --- a/src/main/java/org/mockito/ArgumentMatchers.java +++ b/src/main/java/org/mockito/ArgumentMatchers.java @@ -13,10 +13,10 @@ import org.mockito.internal.matchers.apachecommons.ReflectionEquals; import org.mockito.internal.util.Primitives; +import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; -import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; @@ -26,379 +26,744 @@ /** * Allow flexible verification or stubbing. See also {@link AdditionalMatchers}. + * * <p> * {@link Mockito} extends ArgumentMatchers so to get access to all matchers just import Mockito class statically. + * * <pre class="code"><code class="java"> * //stubbing using anyInt() argument matcher * when(mockedList.get(anyInt())).thenReturn("element"); - * <p> + * * //following prints "element" * System.out.println(mockedList.get(999)); - * <p> + * * //you can also verify using argument matcher * verify(mockedList).get(anyInt()); * </code></pre> - * Scroll down to see all methods - full list of matchers. + * * <p> - * <b>Warning:</b> + * Since Mockito <code>any(Class)</code> and <code>anyInt</code> family matchers perform a type check, thus they won't + * match <code>null</code> arguments. Instead use the <code>isNull</code> matcher. + * + * <pre class="code"><code class="java"> + * // stubbing using anyBoolean() argument matcher + * when(mock.dryRun(anyBoolean())).thenReturn("state"); + * + * // below the stub won't match, and won't return "state" + * mock.dryRun(null); + * + * // either change the stub + * when(mock.dryRun(isNull())).thenReturn("state"); + * mock.dryRun(null); // ok + * + * // or fix the code ;) + * when(mock.dryRun(anyBoolean())).thenReturn("state"); + * mock.dryRun(true); // ok + * + * </code></pre> + * + * The same apply for verification. + * </p> + * + * + * Scroll down to see all methods - full list of matchers. + * * <p> + * <b>Warning:</b><br/> + * * If you are using argument matchers, <b>all arguments</b> have to be provided by matchers. - * <p> + * * E.g: (example shows verification but the same applies to stubbing): + * </p> + * * <pre class="code"><code class="java"> * verify(mock).someMethod(anyInt(), anyString(), <b>eq("third argument")</b>); * //above is correct - eq() is also an argument matcher - * <p> + * * verify(mock).someMethod(anyInt(), anyString(), <b>"third argument"</b>); * //above is incorrect - exception will be thrown because third argument is given without argument matcher. * </code></pre> + * * <p> * Matcher methods like <code>anyObject()</code>, <code>eq()</code> <b>do not</b> return matchers. * Internally, they record a matcher on a stack and return a dummy value (usually null). * This implementation is due static type safety imposed by java compiler. * The consequence is that you cannot use <code>anyObject()</code>, <code>eq()</code> methods outside of verified/stubbed method. - * <p> + * </p> + * * <h1>Custom Argument ArgumentMatchers</h1> * <p> * It is important to understand the use cases and available options for dealing with non-trivial arguments * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach * for given scenario and produce highest quality test (clean and maintainable). * Please read on in the javadoc for {@link ArgumentMatcher} to learn about approaches and see the examples. + * </p> */ @SuppressWarnings("unchecked") public class ArgumentMatchers { /** - * Any <code>boolean</code> or non-null <code>Boolean</code> + * Matches <strong>anything</strong>, including nulls and varargs. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class * - * @return <code>false</code>. + * This is an alias of: {@link #anyObject()} and {@link #any(java.lang.Class)} + * </p> + * + * <p> + * <strong>Notes : </strong><br/> + * <ul> + * <li>For primitive types use {@link #anyChar()} family or {@link #isA(Class)} or {@link #any(Class)}.</li> + * <li>Since mockito 2.0 {@link #any(Class)} is not anymore an alias of this method.</li> + * </ul> + * </p> + * + * @return <code>null</code>. + * + * @see #any(Class) + * @see #anyObject() + * @see #anyVararg() + * @see #anyChar() + * @see #anyInt() + * @see #anyBoolean() + * @see #anyCollectionOf(Class) */ - public static boolean anyBoolean() { - reportMatcher(new InstanceOf(Boolean.class)); - return false; + public static <T> T any() { + return anyObject(); } /** - * Any <code>byte</code> or non-null <code>Byte</code>. + * Matches anything, including <code>null</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * This is an alias of: {@link #any()} and {@link #any(java.lang.Class)}. + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * - * @return <code>0</code>. + * @return <code>null</code>. + * @see #any() + * @see #any(Class) + * @see #notNull() + * @see #notNull(Class) + * @deprecated This will be removed in Mockito 3.0 (which will be java 8 only) */ - public static byte anyByte() { - reportMatcher(new InstanceOf(Byte.class)); - return 0; + @Deprecated + public static <T> T anyObject() { + reportMatcher(Any.ANY); + return null; } /** - * Any <code>char</code> or non-null <code>Character</code>. + * Matches any object of given type, excluding nulls. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * This matcher will perform a type check with the given type, thus excluding values. + * See examples in javadoc for {@link ArgumentMatchers} class. * - * @return <code>0</code>. + * This is an alias of: {@link #isA(Class)}} + * </p> + * + * <p> + * Since Mockito 2.0, only allow non-null instance of <code></code>, thus <code>null</code> is not anymore a valid value. + * As reference are nullable, the suggested API to <strong>match</strong> <code>null</code> + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p><strong>Notes : </strong><br/> + * <ul> + * <li>For primitive types use {@link #anyChar()} family.</li> + * <li>Since Mockito 2.0 this method will perform a type check thus <code>null</code> values are not authorized.</li> + * <li>Since mockito 2.0 {@link #any()} and {@link #anyObject()} are not anymore aliases of this method.</li> + * </ul> + * </p> + * + * @param <T> The accepted type + * @param type the class of the accepted type. + * @return <code>null</code>. + * @see #any() + * @see #anyObject() + * @see #anyVararg() + * @see #isA(Class) + * @see #notNull() + * @see #notNull(Class) + * @see #isNull() + * @see #isNull(Class) */ - public static char anyChar() { - reportMatcher(new InstanceOf(Character.class)); - return 0; + public static <T> T any(Class<T> type) { + reportMatcher(new InstanceOf.VarArgAware(type, "<any " + type.getCanonicalName() + ">")); + return defaultValue(type); } /** - * Any int or non-null Integer. + * <code>Object</code> argument that implements the given class. * <p> * See examples in javadoc for {@link ArgumentMatchers} class * - * @return <code>0</code>. + * @param <T> the accepted type. + * @param type the class of the accepted type. + * @return <code>null</code>. + * @see #any(Class) */ - public static int anyInt() { - reportMatcher(new InstanceOf(Integer.class)); - return 0; + public static <T> T isA(Class<T> type) { + reportMatcher(new InstanceOf(type)); + return defaultValue(type); } /** - * Any <code>long</code> or non-null <code>Long</code>. + * Any vararg, meaning any number and values of arguments. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Example: + * <pre class="code"><code class="java"> + * //verification: + * mock.foo(1, 2); + * mock.foo(1, 2, 3, 4); * - * @return <code>0</code>. + * verify(mock, times(2)).foo(anyVararg()); + * + * //stubbing: + * when(mock.foo(anyVararg()).thenReturn(100); + * + * //prints 100 + * System.out.println(mock.foo(1, 2)); + * //also prints 100 + * System.out.println(mock.foo(1, 2, 3, 4)); + * </code></pre> + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> + * + * @return <code>null</code>. + * @see #any() + * @see #any(Class) + * @deprecated as of 2.0 use {@link #any()} */ - public static long anyLong() { - reportMatcher(new InstanceOf(Long.class)); - return 0; + @Deprecated + public static <T> T anyVararg() { + any(); + return null; } /** - * Any <code>float</code> or non-null <code>Float</code>. + * Any <code>boolean</code> or <strong>non-null</strong> <code>Boolean</code> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow valued <code>Boolean</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> * - * @return <code>0</code>. + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> + * + * @return <code>false</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static float anyFloat() { - reportMatcher(new InstanceOf(Float.class)); - return 0; + public static boolean anyBoolean() { + reportMatcher(new InstanceOf(Boolean.class, "<any boolean>")); + return false; } /** - * Any <code>double</code> or non-null <code>Double</code>. + * Any <code>byte</code> or <strong>non-null</strong> <code>Byte</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow valued <code>Byte</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static double anyDouble() { - reportMatcher(new InstanceOf(Double.class)); + public static byte anyByte() { + reportMatcher(new InstanceOf(Byte.class, "<any byte>")); return 0; } /** - * Any <code>short</code> or non-null <code>Short</code>. + * Any <code>char</code> or <strong>non-null</strong> <code>Character</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow valued <code>Character</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static short anyShort() { - reportMatcher(new InstanceOf(Short.class)); + public static char anyChar() { + reportMatcher(new InstanceOf(Character.class, "<any char>")); return 0; } /** - * Matches anything, including null. + * Any int or <strong>non-null</strong> <code>Integer</code>. + * * <p> - * This is an alias of: {@link #any()} and {@link #any(java.lang.Class)} + * Since Mockito 2.0, only allow valued <code>Integer</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * - * @return <code>null</code>. + * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static <T> T anyObject() { - reportMatcher(Any.ANY); - return null; + public static int anyInt() { + reportMatcher(new InstanceOf(Integer.class, "<any integer>")); + return 0; } /** - * Any vararg, meaning any number and values of arguments. - * <p> - * Example: - * <pre class="code"><code class="java"> - * //verification: - * mock.foo(1, 2); - * mock.foo(1, 2, 3, 4); - * <p> - * verify(mock, times(2)).foo(anyVararg()); + * Any <code>long</code> or <strong>non-null</strong> <code>Long</code>. + * * <p> - * //stubbing: - * when(mock.foo(anyVararg()).thenReturn(100); + * Since Mockito 2.0, only allow valued <code>Long</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * //prints 100 - * System.out.println(mock.foo(1, 2)); - * //also prints 100 - * System.out.println(mock.foo(1, 2, 3, 4)); - * </code></pre> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * - * @return <code>null</code>. - * @deprecated as of 2.0 use {@link #any()} + * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - @Deprecated - public static <T> T anyVararg() { - any(); - return null; + public static long anyLong() { + reportMatcher(new InstanceOf(Long.class, "<any long>")); + return 0; } /** - * Matches any object, including nulls - * <p> - * This method doesn't do type checks with the given parameter, it is only there - * to avoid casting in your code. This might however change (type checks could - * be added) in a future major release. - * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Any <code>float</code> or <strong>non-null</strong> <code>Float</code>. + * * <p> - * This is an alias of: {@link #any()} and {@link #anyObject()} + * Since Mockito 2.0, only allow valued <code>Float</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * - * @return <code>null</code>. + * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static <T> T any(Class<T> clazz) { - reportMatcher(Any.ANY); - return defaultValue(clazz); + public static float anyFloat() { + reportMatcher(new InstanceOf(Float.class, "<any float>")); + return 0; } /** - * Matches anything, including nulls and varargs + * Any <code>double</code> or <strong>non-null</strong> <code>Double</code>. + * * <p> - * Shorter alias to {@link ArgumentMatchers#anyObject()} + * Since Mockito 2.0, only allow valued <code>Double</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> + * + * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) + */ + public static double anyDouble() { + reportMatcher(new InstanceOf(Double.class, "<any double>")); + return 0; + } + + /** + * Any <code>short</code> or <strong>non-null</strong> <code>Short</code>. + * * <p> - * This is an alias of: {@link #anyObject()} and {@link #any(java.lang.Class)} + * Since Mockito 2.0, only allow valued <code>Short</code>, thus <code>null</code> is not anymore a valid value. + * As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * - * @return <code>null</code>. + * @return <code>0</code>. + * @see #isNull() + * @see #isNull(Class) */ - public static <T> T any() { - return anyObject(); + public static short anyShort() { + reportMatcher(new InstanceOf(Short.class, "<any short>")); + return 0; } /** - * Any non-null <code>String</code> + * Any <strong>non-null</strong> <code>String</code> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>String</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return empty String ("") + * @see #isNull() + * @see #isNull(Class) */ public static String anyString() { - reportMatcher(new InstanceOf(String.class)); + reportMatcher(new InstanceOf(String.class, "<any string>")); return ""; } /** - * Any non-null <code>List</code>. + * Any <strong>non-null</strong> <code>List</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>List</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return empty List. + * @see #anyListOf(Class) + * @see #isNull() + * @see #isNull(Class) */ public static List anyList() { - reportMatcher(new InstanceOf(List.class)); - return new LinkedList(); + reportMatcher(new InstanceOf(List.class, "<any List>")); + return new ArrayList(0); } /** - * Generic friendly alias to {@link ArgumentMatchers#anyList()}. - * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. + * Any <strong>non-null</strong> <code>List</code>. + * + * Generic friendly alias to {@link ArgumentMatchers#anyList()}. It's an alternative to + * <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings. + * * <p> - * Any non-null <code>List</code>. + * This method doesn't do type checks of the list content with the given type parameter, it is only there + * to avoid casting in the code. + * </p> + * * <p> - * This method doesn't do type checks with the given parameter, it is only there - * to avoid casting in your code. This might however change (type checks could - * be added) in a future major release. + * Since Mockito 2.0, only allow non-null <code>List</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @param clazz Type owned by the list to avoid casting * @return empty List. + * @see #anyList() + * @see #isNull() + * @see #isNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> List<T> anyListOf(Class<T> clazz) { return anyList(); } /** - * Any non-null <code>Set</code>. + * Any <strong>non-null</strong> <code>Set</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>Set</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return empty Set + * @see #anySetOf(Class) + * @see #isNull() + * @see #isNull(Class) */ public static Set anySet() { - reportMatcher(new InstanceOf(Set.class)); - return new HashSet(); + reportMatcher(new InstanceOf(Set.class, "<any set>")); + return new HashSet(0); } /** + * Any <strong>non-null</strong> <code>Set</code>. + * + * <p> * Generic friendly alias to {@link ArgumentMatchers#anySet()}. - * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. + * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings. + * </p> + * * <p> - * Any non-null <code>Set</code>. + * This method doesn't do type checks of the set content with the given type parameter, it is only there + * to avoid casting in the code. + * </p> + * * <p> - * This method doesn't do type checks with the given parameter, it is only there - * to avoid casting in your code. This might however change (type checks could - * be added) in a future major release. + * Since Mockito 2.0, only allow non-null <code>Set</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @param clazz Type owned by the Set to avoid casting * @return empty Set + * @see #anySet() + * @see #isNull() + * @see #isNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> Set<T> anySetOf(Class<T> clazz) { return anySet(); } /** - * Any non-null <code>Map</code>. + * Any <strong>non-null</strong> <code>Map</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>Map</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return empty Map. + * @see #anyMapOf(Class, Class) + * @see #isNull() + * @see #isNull(Class) */ public static Map anyMap() { - reportMatcher(new InstanceOf(Map.class)); - return new HashMap(); + reportMatcher(new InstanceOf(Map.class, "<any map>")); + return new HashMap(0); } /** + * Any <strong>non-null</strong> <code>Map</code>. + * + * <p> * Generic friendly alias to {@link ArgumentMatchers#anyMap()}. - * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. + * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings. + * </p> + * * <p> - * Any non-null <code>Map</code>. + * This method doesn't do type checks of the map content with the given type parameter, it is only there + * to avoid casting in the code. + * </p> + * * <p> - * This method doesn't do type checks with the given parameter, it is only there - * to avoid casting in your code. This might however change (type checks could - * be added) in a future major release. + * Since Mockito 2.0, only allow non-null <code>Map</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @param keyClazz Type of the map key to avoid casting * @param valueClazz Type of the value to avoid casting * @return empty Map. + * @see #anyMap() + * @see #isNull() + * @see #isNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <K, V> Map<K, V> anyMapOf(Class<K> keyClazz, Class<V> valueClazz) { return anyMap(); } /** - * Any non-null <code>Collection</code>. + * Any <strong>non-null</strong> <code>Collection</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>Collection</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @return empty Collection. + * @see #anyCollectionOf(Class) + * @see #isNull() + * @see #isNull(Class) */ public static Collection anyCollection() { - reportMatcher(new InstanceOf(Collection.class)); - return new LinkedList(); + reportMatcher(new InstanceOf(Collection.class, "<any collection>")); + return new ArrayList(0); } /** + * Any <strong>non-null</strong> <code>Collection</code>. + * + * <p> * Generic friendly alias to {@link ArgumentMatchers#anyCollection()}. - * It's an alternative to &#064;SuppressWarnings("unchecked") to keep code clean of compiler warnings. + * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings. + * </p> + * * <p> - * Any non-null <code>Collection</code>. + * This method doesn't do type checks of the collection content with the given type parameter, it is only there + * to avoid casting in the code. + * </p> + * * <p> - * This method doesn't do type checks with the given parameter, it is only there - * to avoid casting in your code. This might however change (type checks could - * be added) in a future major release. + * Since Mockito 2.0, only allow non-null <code>Collection</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> * * @param clazz Type owned by the collection to avoid casting * @return empty Collection. + * @see #anyCollection() + * @see #isNull() + * @see #isNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> Collection<T> anyCollectionOf(Class<T> clazz) { return anyCollection(); } /** - * <code>Object</code> argument that implements the given class. + * Any <strong>non-null</strong> <code>Iterable</code>. + * * <p> - * See examples in javadoc for {@link ArgumentMatchers} class + * Since Mockito 2.0, only allow non-null <code>Iterable</code>. + * As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> * - * @param <T> the accepted type. - * @param type the class of the accepted type. - * @return <code>null</code>. + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> + * + * @return empty Iterable. + * @see #anyIterableOf(Class) + * @see #isNull() + * @see #isNull(Class) + * @since 2.0.0 */ - public static <T> T isA(Class<T> type) { - reportMatcher(new InstanceOf(type)); + public static Collection anyIterable() { + reportMatcher(new InstanceOf(Iterable.class, "<any iterable>")); + return new ArrayList(0); + } - return defaultValue(type); + /** + * Any <strong>non-null</strong> <code>Iterable</code>. + * + * <p> + * Generic friendly alias to {@link ArgumentMatchers#anyIterable()}. + * It's an alternative to <code>&#064;SuppressWarnings("unchecked")</code> to keep code clean of compiler warnings. + * </p> + * + * <p> + * This method doesn't do type checks of the iterable content with the given type parameter, it is only there + * to avoid casting in the code. + * </p> + * + * <p> + * Since Mockito 2.0, only allow non-null <code>String</code>. + * As strings are nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper + * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito + * 1.x. + * </p> + * + * <p> + * See examples in javadoc for {@link ArgumentMatchers} class. + * </p> + * + * @param clazz Type owned by the collection to avoid casting + * @return empty Iterable. + * @see #anyIterable() + * @see #isNull() + * @see #isNull(Class) + * @since 2.0.0 + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. + */ + public static <T> Iterable<T> anyIterableOf(Class<T> clazz) { + return anyIterable(); } + + /** * <code>boolean</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -410,8 +775,10 @@ public static boolean eq(boolean value) { /** * <code>byte</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -423,8 +790,10 @@ public static byte eq(byte value) { /** * <code>char</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -436,8 +805,10 @@ public static char eq(char value) { /** * <code>double</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -449,8 +820,10 @@ public static double eq(double value) { /** * <code>float</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -462,8 +835,10 @@ public static float eq(float value) { /** * <code>int</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -475,8 +850,10 @@ public static int eq(int value) { /** * <code>long</code> argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>0</code>. @@ -501,8 +878,10 @@ public static short eq(short value) { /** * Object argument that is equal to the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @return <code>null</code>. @@ -517,16 +896,22 @@ public static <T> T eq(T value) { /** * Object argument that is reflection-equal to the given value with support for excluding * selected fields from a class. + * * <p> * This matcher can be used when equals() is not implemented on compared objects. * Matcher uses java reflection API to compare fields of wanted and actual object. + * </p> + * * <p> - * Works similarly to EqualsBuilder.reflectionEquals(this, other, exlucdeFields) from + * Works similarly to <code>EqualsBuilder.reflectionEquals(this, other, exlucdeFields)</code> from * apache commons library. * <p> * <b>Warning</b> The equality check is shallow! + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param value the given value. * @param excludeFields fields to exclude, if field does not exist it is ignored. @@ -539,8 +924,10 @@ public static <T> T refEq(T value, String... excludeFields) { /** * Object argument that is the same as the given value. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param <T> the type of the object, it is passed through to prevent casts. * @param value the given value. @@ -555,83 +942,123 @@ public static <T> T same(T value) { /** * <code>null</code> argument. + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @return <code>null</code>. + * @see #isNull(Class) + * @see #isNotNull() + * @see #isNotNull(Class) */ - public static Object isNull() { + public static <T> T isNull() { reportMatcher(Null.NULL); return null; } /** * <code>null</code> argument. + * + * <p> * The class argument is provided to avoid casting. + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param clazz Type to avoid casting * @return <code>null</code>. + * @see #isNull() + * @see #isNotNull() + * @see #isNotNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> T isNull(Class<T> clazz) { - reportMatcher(Null.NULL); - return null; + return isNull(); } /** * Not <code>null</code> argument. + * * <p> - * alias to {@link ArgumentMatchers#isNotNull()} + * Alias to {@link ArgumentMatchers#isNotNull()} + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @return <code>null</code>. */ - public static Object notNull() { + public static <T> T notNull() { reportMatcher(NotNull.NOT_NULL); return null; } /** * Not <code>null</code> argument, not necessary of the given class. + * + * <p> * The class argument is provided to avoid casting. + * + * Alias to {@link ArgumentMatchers#isNotNull(Class)} * <p> - * alias to {@link ArgumentMatchers#isNotNull(Class)} + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param clazz Type to avoid casting * @return <code>null</code>. + * @see #isNotNull() + * @see #isNull() + * @see #isNull(Class) + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> T notNull(Class<T> clazz) { - reportMatcher(NotNull.NOT_NULL); - return null; + return notNull(); } /** * Not <code>null</code> argument. + * * <p> - * alias to {@link ArgumentMatchers#notNull()} + * Alias to {@link ArgumentMatchers#notNull()} + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @return <code>null</code>. + * @see #isNotNull(Class) + * @see #isNull() + * @see #isNull(Class) */ - public static Object isNotNull() { + public static <T> T isNotNull() { return notNull(); } /** * Not <code>null</code> argument, not necessary of the given class. - * The class argument is provided to avoid casting. + * * <p> - * alias to {@link ArgumentMatchers#notNull(Class)} + * The class argument is provided to avoid casting. + * Alias to {@link ArgumentMatchers#notNull(Class)} + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatchers} class + * </p> * * @param clazz Type to avoid casting * @return <code>null</code>. + * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic + * friendliness to avoid casting, this is not anymore needed in Java 8. */ public static <T> T isNotNull(Class<T> clazz) { return notNull(clazz); @@ -691,13 +1118,19 @@ public static String startsWith(String prefix) { /** * Allows creating custom argument matchers. + * + * <p> * This API has changed in 2.0, please read {@link ArgumentMatcher} for rationale and migration guide. * <b>NullPointerException</b> auto-unboxing caveat is described below. + * </p> + * * <p> * It is important to understand the use cases and available options for dealing with non-trivial arguments * <b>before</b> implementing custom argument matchers. This way, you can select the best possible approach * for given scenario and produce highest quality test (clean and maintainable). * Please read the documentation for {@link ArgumentMatcher} to learn about approaches and see the examples. + * </p> + * * <p> * <b>NullPointerException</b> auto-unboxing caveat. * In rare cases when matching primitive parameter types you <b>*must*</b> use relevant intThat(), floatThat(), etc. method. @@ -705,8 +1138,11 @@ public static String startsWith(String prefix) { * Due to how java works we don't really have a clean way of detecting this scenario and protecting the user from this problem. * Hopefully, the javadoc describes the problem and solution well. * If you have an idea how to fix the problem, let us know via the mailing list or the issue tracker. + * </p> + * * <p> * See examples in javadoc for {@link ArgumentMatcher} class + * </p> * * @param matcher decides whether argument matches * @return <code>null</code>. @@ -718,6 +1154,7 @@ public static <T> T argThat(ArgumentMatcher<T> matcher) { /** * Allows creating custom <code>char</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>char</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -732,6 +1169,7 @@ public static char charThat(ArgumentMatcher<Character> matcher) { /** * Allows creating custom <code>boolean</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>boolean</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -746,6 +1184,7 @@ public static boolean booleanThat(ArgumentMatcher<Boolean> matcher) { /** * Allows creating custom <code>byte</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>byte</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -760,6 +1199,7 @@ public static byte byteThat(ArgumentMatcher<Byte> matcher) { /** * Allows creating custom <code>short</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>short</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -774,6 +1214,7 @@ public static short shortThat(ArgumentMatcher<Short> matcher) { /** * Allows creating custom <code>int</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>int</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -788,6 +1229,7 @@ public static int intThat(ArgumentMatcher<Integer> matcher) { /** * Allows creating custom <code>long</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>long</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -802,6 +1244,7 @@ public static long longThat(ArgumentMatcher<Long> matcher) { /** * Allows creating custom <code>float</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>float</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class @@ -816,6 +1259,7 @@ public static float floatThat(ArgumentMatcher<Float> matcher) { /** * Allows creating custom <code>double</code> argument matchers. + * * Note that {@link #argThat} will not work with primitive <code>double</code> matchers due to <code>NullPointerException</code> auto-unboxing caveat. * <p> * See examples in javadoc for {@link ArgumentMatchers} class diff --git a/src/main/java/org/mockito/internal/matchers/InstanceOf.java b/src/main/java/org/mockito/internal/matchers/InstanceOf.java index c315c34ee4..2876aa24d0 100644 --- a/src/main/java/org/mockito/internal/matchers/InstanceOf.java +++ b/src/main/java/org/mockito/internal/matchers/InstanceOf.java @@ -6,6 +6,7 @@ package org.mockito.internal.matchers; import org.mockito.ArgumentMatcher; +import org.mockito.internal.util.Primitives; import java.io.Serializable; @@ -13,16 +14,37 @@ public class InstanceOf implements ArgumentMatcher<Object>, Serializable { private final Class<?> clazz; + private String description; public InstanceOf(Class<?> clazz) { + this(clazz, "isA(" + clazz.getCanonicalName() + ")"); + } + + public InstanceOf(Class<?> clazz, String describedAs) { this.clazz = clazz; + this.description = describedAs; } public boolean matches(Object actual) { - return (actual != null) && clazz.isAssignableFrom(actual.getClass()); + return (actual != null) && + (Primitives.isAssignableFromWrapper(actual.getClass(), clazz) + || clazz.isAssignableFrom(actual.getClass())); } public String toString() { - return "isA(" + clazz.getName() + ")"; + return description; + } + + public static class VarArgAware extends InstanceOf implements VarargMatcher { + + public VarArgAware(Class<?> clazz) { + super(clazz); + } + + public VarArgAware(Class<?> clazz, String describedAs) { + super(clazz, describedAs); + } } + + } diff --git a/src/main/java/org/mockito/internal/util/Primitives.java b/src/main/java/org/mockito/internal/util/Primitives.java index e7a2f99c24..1540326129 100644 --- a/src/main/java/org/mockito/internal/util/Primitives.java +++ b/src/main/java/org/mockito/internal/util/Primitives.java @@ -42,6 +42,13 @@ public static boolean isPrimitiveOrWrapper(Class<?> type) { return PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.containsKey(type); } + public static boolean isAssignableFromWrapper(Class<?> valueClass, Class<?> referenceType) { + if(isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) { + return Primitives.primitiveTypeOf(valueClass).isAssignableFrom(referenceType); + } + return false; + } + /** * Returns the boxed default value for a primitive or a primitive wrapper. *

diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java index 64a5a39c52..88e2727b1e 100644 --- a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java +++ b/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java @@ -4,12 +4,13 @@ */ package org.mockito.internal.exceptions.stacktrace; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.base.TraceBuilder; import org.mockito.internal.configuration.ConfigurationAccess; import org.mockitoutil.TestBase; -import static org.mockitoutil.ExtraMatchers.hasOnlyThoseClassesInStackTrace; +import static org.mockitoutil.Conditions.onlyThoseClassesInStackTrace; public class ConditionalStackTraceFilterTest extends TestBase { @@ -26,7 +27,7 @@ public void shouldNotFilterWhenConfigurationSaysNo() { filter.filter(t); - assertThat(t, hasOnlyThoseClassesInStackTrace("org.mockito.Mockito", "org.test.MockitoSampleTest")); + Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.mockito.Mockito", "org.test.MockitoSampleTest")); } @Test @@ -40,6 +41,6 @@ public void shouldFilterWhenConfigurationSaysYes() { filter.filter(t); - assertThat(t, hasOnlyThoseClassesInStackTrace("org.test.MockitoSampleTest")); + Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.test.MockitoSampleTest")); } } diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java index ff33eab770..27ee551479 100644 --- a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java +++ b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java @@ -5,12 +5,13 @@ package org.mockito.internal.exceptions.stacktrace; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.base.TraceBuilder; import org.mockitoutil.TestBase; import static junit.framework.TestCase.assertEquals; -import static org.mockitoutil.ExtraMatchers.hasOnlyThoseClasses; +import static org.mockitoutil.Conditions.onlyThoseClasses; public class StackTraceFilterTest extends TestBase { @@ -25,7 +26,7 @@ public void shouldFilterOutCglibGarbage() { StackTraceElement[] filtered = filter.filter(t, false); - assertThat(filtered, hasOnlyThoseClasses("MockitoExampleTest")); + Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest")); } @Test @@ -37,7 +38,7 @@ public void shouldFilterOutByteBuddyGarbage() { StackTraceElement[] filtered = filter.filter(t, false); - assertThat(filtered, hasOnlyThoseClasses("MockitoExampleTest")); + Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest")); } @@ -49,8 +50,8 @@ public void shouldFilterOutMockitoPackage() { ).toTraceArray(); StackTraceElement[] filtered = filter.filter(t, false); - - assertThat(filtered, hasOnlyThoseClasses("org.test.MockitoSampleTest")); + + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest")); } @Test @@ -64,8 +65,8 @@ public void shouldNotFilterOutTracesMiddleGoodTraces() { ).toTraceArray(); StackTraceElement[] filtered = filter.filter(t, false); - - assertThat(filtered, hasOnlyThoseClasses("org.test.TestSupport", "org.test.TestSupport", "org.test.MockitoSampleTest")); + + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.TestSupport", "org.test.TestSupport", "org.test.MockitoSampleTest")); } @Test @@ -78,8 +79,8 @@ public void shouldKeepRunners() { ).toTraceArray(); StackTraceElement[] filtered = filter.filter(t, false); - - assertThat(filtered, hasOnlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner")); + + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner")); } @Test @@ -95,7 +96,7 @@ public void shouldNotFilterElementsAboveMockitoJUnitRule() { StackTraceElement[] filtered = filter.filter(t, false); - assertThat(filtered, hasOnlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner","org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)")); + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner","org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)")); } @Test @@ -106,8 +107,8 @@ public void shouldKeepInternalRunners() { ).toTraceArray(); StackTraceElement[] filtered = filter.filter(t, false); - - assertThat(filtered, hasOnlyThoseClasses("org.test.MockitoSampleTest", "org.mockito.internal.runners.Runner")); + + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.mockito.internal.runners.Runner")); } @Test @@ -123,7 +124,7 @@ public void shouldStartFilteringAndKeepTop() { StackTraceElement[] filtered = filter.filter(t, true); //then - assertThat(filtered, hasOnlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good")); + Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good")); } @Test @@ -136,8 +137,8 @@ public void shouldKeepGoodTraceFromTheTopBecauseRealImplementationsOfSpiesSometi ).toTraceArray(); StackTraceElement[] filtered = filter.filter(t, true); - - assertThat(filtered, hasOnlyThoseClasses( + + Assertions.assertThat(filtered).has(onlyThoseClasses( "org.test.MockitoSampleTest", "org.yet.another.good.Trace", "org.good.Trace" diff --git a/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java b/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java index 39d1c32024..5c68e7c536 100644 --- a/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java +++ b/src/test/java/org/mockito/internal/invocation/InvocationImplTest.java @@ -5,6 +5,7 @@ package org.mockito.internal.invocation; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; import org.mockito.exceptions.base.MockitoException; @@ -69,45 +70,45 @@ public void shouldPrintMethodName() { @Test public void shouldPrintMethodArgs() { invocation = new InvocationBuilder().args("foo").toInvocation(); - assertThat(invocation.toString(), endsWith("simpleMethod(\"foo\");")); + Assertions.assertThat(invocation.toString()).endsWith("simpleMethod(\"foo\");"); } @Test public void shouldPrintMethodIntegerArgAndString() { invocation = new InvocationBuilder().args("foo", 1).toInvocation(); - assertThat(invocation.toString(), endsWith("simpleMethod(\"foo\", 1);")); + Assertions.assertThat(invocation.toString()).endsWith("simpleMethod(\"foo\", 1);"); } @Test public void shouldPrintNull() { invocation = new InvocationBuilder().args((String) null).toInvocation(); - assertThat(invocation.toString(), endsWith("simpleMethod(null);")); + Assertions.assertThat(invocation.toString()).endsWith("simpleMethod(null);"); } @Test public void shouldPrintArray() { invocation = new InvocationBuilder().method("oneArray").args(new int[] { 1, 2, 3 }).toInvocation(); - assertThat(invocation.toString(), endsWith("oneArray([1, 2, 3]);")); + Assertions.assertThat(invocation.toString()).endsWith("oneArray([1, 2, 3]);"); } @Test public void shouldPrintNullIfArrayIsNull() throws Exception { Method m = IMethods.class.getMethod("oneArray", Object[].class); invocation = new InvocationBuilder().method(m).args((Object) null).toInvocation(); - assertThat(invocation.toString(), endsWith("oneArray(null);")); + Assertions.assertThat(invocation.toString()).endsWith("oneArray(null);"); } @Test public void shouldPrintArgumentsInMultilinesWhenGetsTooBig() { invocation = new InvocationBuilder().args("veeeeery long string that makes it ugly in one line", 1).toInvocation(); - assertThat(invocation.toString(), endsWith( + Assertions.assertThat(invocation.toString()).endsWith( "simpleMethod(" + "\n" + " \"veeeeery long string that makes it ugly in one line\"," + "\n" + " 1" + "\n" + - ");")); + ");"); } @Test diff --git a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java index c34a0258a8..6425ba877b 100644 --- a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java +++ b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java @@ -5,6 +5,7 @@ package org.mockito.internal.invocation; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -20,8 +21,9 @@ import java.util.LinkedList; import java.util.List; -import static junit.framework.TestCase.*; -import static org.mockitoutil.ExtraMatchers.hasExactlyInOrder; +import static junit.framework.TestCase.assertNull; +import static junit.framework.TestCase.assertSame; +import static junit.framework.TestCase.assertTrue; public class InvocationsFinderTest extends TestBase { @@ -48,10 +50,10 @@ public void setup() throws Exception { @Test public void shouldFindActualInvocations() throws Exception { List<Invocation> actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(simpleMethodInvocation)); - assertThat(actual, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo)); + Assertions.assertThat(actual).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo); actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(differentMethodInvocation)); - assertThat(actual, hasExactlyInOrder(differentMethodInvocation)); + Assertions.assertThat(actual).containsSequence(differentMethodInvocation); } @Test @@ -137,11 +139,11 @@ public void shouldGetLastStackTrace() throws Exception { @Test public void shouldFindAllMatchingUnverifiedChunks() throws Exception { List<Invocation> allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context); - assertThat(allMatching, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo)); + Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo); context.markVerified(simpleMethodInvocation); allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context); - assertThat(allMatching, hasExactlyInOrder(simpleMethodInvocationTwo)); + Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocationTwo); context.markVerified(simpleMethodInvocationTwo); allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context); @@ -151,7 +153,7 @@ public void shouldFindAllMatchingUnverifiedChunks() throws Exception { @Test public void shouldFindMatchingChunk() throws Exception { List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 2, context); - assertThat(chunk, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo)); + Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo); } @Test @@ -160,7 +162,7 @@ public void shouldReturnAllChunksWhenModeIsAtLeastOnce() throws Exception { invocations.add(simpleMethodInvocationThree); List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context); - assertThat(chunk, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree)); + Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree); } @Test @@ -169,7 +171,7 @@ public void shouldReturnAllChunksWhenWantedCountDoesntMatch() throws Exception { invocations.add(simpleMethodInvocationThree); List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context); - assertThat(chunk, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree)); + Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree); } @Test diff --git a/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java b/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java new file mode 100644 index 0000000000..4497c7c60a --- /dev/null +++ b/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java @@ -0,0 +1,64 @@ +package org.mockito.internal.matchers; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class InstanceOfTest { + + @Test + public void should_describe_the_matcher() { + assertThat(new InstanceOf(Object.class).toString()).contains("isA") + .contains("Object"); + assertThat(new InstanceOf(Object[].class).toString()).contains("isA") + .contains("Object[]"); + assertThat(new InstanceOf(Object.class, "matches something").toString()).isEqualTo("matches something"); + } + + @Test + public void should_check_instance_type() { + assertThat(new InstanceOf(Object.class).matches(new Object())).isTrue(); + assertThat(new InstanceOf(Object.class).matches(new ArrayList())).isTrue(); + assertThat(new InstanceOf(List.class).matches(new ArrayList())).isTrue(); + assertThat(new InstanceOf(List.class).matches(new Object())).isFalse(); + } + + @Test + public void should_check_for_primitive_wrapper_types() { + assertThat(new InstanceOf(int.class).matches(1000)).isTrue(); + assertThat(new InstanceOf(Integer.class).matches(1000)).isTrue(); + assertThat(new InstanceOf(int.class).matches(new Integer(1000))).isTrue(); + assertThat(new InstanceOf(Integer.class).matches(new Integer(1000))).isTrue(); + + assertThat(new InstanceOf(double.class).matches(1000.1)).isTrue(); + assertThat(new InstanceOf(Double.class).matches(1000.1)).isTrue(); + assertThat(new InstanceOf(double.class).matches(new Double(1000.1))).isTrue(); + assertThat(new InstanceOf(Double.class).matches(new Double(1000.1))).isTrue(); + + assertThat(new InstanceOf(int.class).matches(1000L)).isFalse(); + assertThat(new InstanceOf(Integer.class).matches(1000L)).isFalse(); + assertThat(new InstanceOf(int.class).matches(new Long(1000))).isFalse(); + assertThat(new InstanceOf(Integer.class).matches(new Long(1000))).isFalse(); + + assertThat(new InstanceOf(long.class).matches(1000L)).isTrue(); + assertThat(new InstanceOf(Long.class).matches(1000L)).isTrue(); + assertThat(new InstanceOf(long.class).matches(new Long(1000))).isTrue(); + assertThat(new InstanceOf(Long.class).matches(new Long(1000))).isTrue(); + + assertThat(new InstanceOf(long.class).matches(1000)).isFalse(); + assertThat(new InstanceOf(Long.class).matches(1000)).isFalse(); + assertThat(new InstanceOf(long.class).matches(new Integer(1000))).isFalse(); + assertThat(new InstanceOf(Long.class).matches(new Integer(1000))).isFalse(); + } + + @Test + public void can_be_vararg_aware() { + assertThat(new InstanceOf.VarArgAware(Number[].class)).isInstanceOf(VarargMatcher.class); + assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Integer[0])).isTrue(); + assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Number[0])).isTrue(); + assertThat(new InstanceOf.VarArgAware(Number[].class).matches(new Object[0])).isFalse(); + } +} \ No newline at end of file diff --git a/src/test/java/org/mockito/internal/progress/PrimitivesTest.java b/src/test/java/org/mockito/internal/progress/PrimitivesTest.java deleted file mode 100644 index de24c6a383..0000000000 --- a/src/test/java/org/mockito/internal/progress/PrimitivesTest.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.progress; - -import org.junit.Test; -import org.mockito.internal.util.Primitives; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; - - -public class PrimitivesTest { - - - @Test - public void should_not_return_null_for_primitives_wrappers() throws Exception { - assertNotNull(Primitives.defaultValue(Boolean.class)); - assertNotNull(Primitives.defaultValue(Character.class)); - assertNotNull(Primitives.defaultValue(Byte.class)); - assertNotNull(Primitives.defaultValue(Short.class)); - assertNotNull(Primitives.defaultValue(Integer.class)); - assertNotNull(Primitives.defaultValue(Long.class)); - assertNotNull(Primitives.defaultValue(Float.class)); - assertNotNull(Primitives.defaultValue(Double.class)); - } - - @Test - public void should_not_return_null_for_primitives() throws Exception { - assertNotNull(Primitives.defaultValue(boolean.class)); - assertNotNull(Primitives.defaultValue(char.class)); - assertNotNull(Primitives.defaultValue(byte.class)); - assertNotNull(Primitives.defaultValue(short.class)); - assertNotNull(Primitives.defaultValue(int.class)); - assertNotNull(Primitives.defaultValue(long.class)); - assertNotNull(Primitives.defaultValue(float.class)); - assertNotNull(Primitives.defaultValue(double.class)); - } - - @Test - public void should_default_values_for_primitive() { - assertThat(Primitives.defaultValue(boolean.class)).isFalse(); - assertThat(Primitives.defaultValue(char.class)).isEqualTo('\u0000'); - assertThat(Primitives.defaultValue(byte.class)).isEqualTo((byte) 0); - assertThat(Primitives.defaultValue(short.class)).isEqualTo((short) 0); - assertThat(Primitives.defaultValue(int.class)).isEqualTo(0); - assertThat(Primitives.defaultValue(long.class)).isEqualTo(0L); - assertThat(Primitives.defaultValue(float.class)).isEqualTo(0.0F); - assertThat(Primitives.defaultValue(double.class)).isEqualTo(0.0D); - } - - @Test - public void should_default_values_for_wrapper() { - assertThat(Primitives.defaultValue(Boolean.class)).isFalse(); - assertThat(Primitives.defaultValue(Character.class)).isEqualTo('\u0000'); - assertThat(Primitives.defaultValue(Byte.class)).isEqualTo((byte) 0); - assertThat(Primitives.defaultValue(Short.class)).isEqualTo((short) 0); - assertThat(Primitives.defaultValue(Integer.class)).isEqualTo(0); - assertThat(Primitives.defaultValue(Long.class)).isEqualTo(0L); - assertThat(Primitives.defaultValue(Float.class)).isEqualTo(0.0F); - assertThat(Primitives.defaultValue(Double.class)).isEqualTo(0.0D); - } - - @Test - public void should_return_null_for_everything_else() throws Exception { - assertNull(Primitives.defaultValue(Object.class)); - assertNull(Primitives.defaultValue(String.class)); - assertNull(Primitives.defaultValue(null)); - } -} \ No newline at end of file diff --git a/src/test/java/org/mockito/internal/util/PrimitivesTest.java b/src/test/java/org/mockito/internal/util/PrimitivesTest.java index 839763f820..2ea86c6118 100644 --- a/src/test/java/org/mockito/internal/util/PrimitivesTest.java +++ b/src/test/java/org/mockito/internal/util/PrimitivesTest.java @@ -12,8 +12,6 @@ public class PrimitivesTest { - - @Test public void should_not_return_null_for_primitives_wrappers() throws Exception { assertNotNull(Primitives.defaultValue(Boolean.class)); @@ -68,4 +66,24 @@ public void should_return_null_for_everything_else() throws Exception { assertNull(Primitives.defaultValue(String.class)); assertNull(Primitives.defaultValue(null)); } + + @Test + public void should_check_that_value_type_is_assignable_to_wrapper_reference() { + assertThat(Primitives.isAssignableFromWrapper(int.class, Integer.class)); + assertThat(Primitives.isAssignableFromWrapper(Integer.class, Integer.class)); + assertThat(Primitives.isAssignableFromWrapper(long.class, Long.class)); + assertThat(Primitives.isAssignableFromWrapper(Long.class, Long.class)); + assertThat(Primitives.isAssignableFromWrapper(double.class, Double.class)); + assertThat(Primitives.isAssignableFromWrapper(Double.class, Double.class)); + assertThat(Primitives.isAssignableFromWrapper(float.class, Float.class)); + assertThat(Primitives.isAssignableFromWrapper(Float.class, Float.class)); + assertThat(Primitives.isAssignableFromWrapper(char.class, Character.class)); + assertThat(Primitives.isAssignableFromWrapper(Character.class, Character.class)); + assertThat(Primitives.isAssignableFromWrapper(short.class, Short.class)); + assertThat(Primitives.isAssignableFromWrapper(Short.class, Short.class)); + assertThat(Primitives.isAssignableFromWrapper(byte.class, Byte.class)); + assertThat(Primitives.isAssignableFromWrapper(Byte.class, Byte.class)); + assertThat(Primitives.isAssignableFromWrapper(boolean.class, Boolean.class)); + assertThat(Primitives.isAssignableFromWrapper(Boolean.class, Boolean.class)); + } } \ No newline at end of file diff --git a/src/test/java/org/mockito/internal/util/TimerTest.java b/src/test/java/org/mockito/internal/util/TimerTest.java index e1156688c1..49cd3c7cae 100644 --- a/src/test/java/org/mockito/internal/util/TimerTest.java +++ b/src/test/java/org/mockito/internal/util/TimerTest.java @@ -1,12 +1,11 @@ package org.mockito.internal.util; +import org.assertj.core.api.Assertions; import org.junit.Assert; import org.junit.Test; import org.mockito.exceptions.misusing.FriendlyReminderException; import org.mockitoutil.TestBase; -import static org.hamcrest.CoreMatchers.is; - public class TimerTest extends TestBase { @Test @@ -19,7 +18,7 @@ public void should_return_true_if_task_is_in_acceptable_time_bounds() { timer.start(); //then - assertThat(timer.isCounting(), is(true)); + Assertions.assertThat(timer.isCounting()).isTrue(); } @Test @@ -32,7 +31,7 @@ public void should_return_false_when_time_run_out() throws Exception { oneMillisecondPasses(); //then - assertThat(timer.isCounting(), is(false)); + Assertions.assertThat(timer.isCounting()).isFalse(); } @Test diff --git a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java index 594fbc3d25..fcd4f9704a 100644 --- a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java +++ b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java @@ -5,6 +5,7 @@ package org.mockito.internal.util.collections; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.internal.util.collections.ListUtil.Filter; import org.mockitoutil.TestBase; @@ -14,7 +15,6 @@ import static java.util.Arrays.asList; import static junit.framework.TestCase.assertTrue; -import static org.mockitoutil.ExtraMatchers.hasExactlyInOrder; public class ListUtilTest extends TestBase { @@ -26,8 +26,8 @@ public boolean isOut(String object) { return object == "x"; } }); - - assertThat(filtered, hasExactlyInOrder("one", "two", "three")); + + Assertions.assertThat(filtered).containsSequence("one", "two", "three"); } @Test diff --git a/src/test/java/org/mockitousage/IMethods.java b/src/test/java/org/mockitousage/IMethods.java index a18d04697d..7234bd7976 100644 --- a/src/test/java/org/mockitousage/IMethods.java +++ b/src/test/java/org/mockitousage/IMethods.java @@ -190,6 +190,8 @@ public interface IMethods { String forCollection(Collection<String> collection); + String forIterable(Iterable<String> iterable); + Object[] arrayReturningMethod(); IMethods iMethodsReturningMethod(); @@ -202,6 +204,8 @@ public interface IMethods { Object collectionArgMethod(Collection<String> collection); + Object iterableArgMethod(Iterable<String> collection); + Object setArgMethod(Set<String> set); void longArg(long longArg); diff --git a/src/test/java/org/mockitousage/MethodsImpl.java b/src/test/java/org/mockitousage/MethodsImpl.java index cc4fb4155d..4f4bdcc8d8 100644 --- a/src/test/java/org/mockitousage/MethodsImpl.java +++ b/src/test/java/org/mockitousage/MethodsImpl.java @@ -363,6 +363,10 @@ public String forCollection(Collection<String> collection) { return null; } + public String forIterable(Iterable<String> iterable) { + return null; + } + public Object[] arrayReturningMethod() { return new Object[0]; } @@ -387,6 +391,10 @@ public Object collectionArgMethod(Collection<String> collection) { return null; } + public Object iterableArgMethod(Iterable<String> iterable) { + return null; + } + public Object setArgMethod(Set<String> set) { return null; } diff --git a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java b/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java index bc79a68e5e..dc6258c297 100644 --- a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java +++ b/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java @@ -5,13 +5,12 @@ package org.mockitousage.basicapi; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.Mockito; import org.mockitoutil.TestBase; import static junit.framework.TestCase.assertEquals; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.not; public class ReplacingObjectMethodsTest extends TestBase { @@ -30,12 +29,11 @@ public void shouldProvideMockyImplementationOfToString() { public void shouldReplaceObjectMethods() { Object mock = Mockito.mock(ObjectMethodsOverridden.class); Object otherMock = Mockito.mock(ObjectMethodsOverridden.class); - - assertThat(mock, equalTo(mock)); - assertThat(mock, not(equalTo(otherMock))); - - assertThat(mock.hashCode(), not(equalTo(otherMock.hashCode()))); - + + Assertions.assertThat(mock).isEqualTo(mock); + Assertions.assertThat(mock).isNotEqualTo(otherMock); + Assertions.assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode()); + assertContains("Mock for ObjectMethodsOverridden", mock.toString()); } @@ -43,12 +41,11 @@ public void shouldReplaceObjectMethods() { public void shouldReplaceObjectMethodsWhenOverridden() { Object mock = Mockito.mock(ObjectMethodsOverriddenSubclass.class); Object otherMock = Mockito.mock(ObjectMethodsOverriddenSubclass.class); - - assertThat(mock, equalTo(mock)); - assertThat(mock, not(equalTo(otherMock))); - - assertThat(mock.hashCode(), not(equalTo(otherMock.hashCode()))); - + + Assertions.assertThat(mock).isEqualTo(mock); + Assertions.assertThat(mock).isNotEqualTo(otherMock); + Assertions.assertThat(mock.hashCode()).isNotEqualTo(otherMock.hashCode()); + assertContains("Mock for ObjectMethodsOverriddenSubclass", mock.toString()); } diff --git a/src/test/java/org/mockitousage/internal/invocation/realmethod/CleanTraceRealMethodTest.java b/src/test/java/org/mockitousage/internal/invocation/realmethod/CleanTraceRealMethodTest.java index 48ee1e31be..10ec3da6b5 100644 --- a/src/test/java/org/mockitousage/internal/invocation/realmethod/CleanTraceRealMethodTest.java +++ b/src/test/java/org/mockitousage/internal/invocation/realmethod/CleanTraceRealMethodTest.java @@ -4,6 +4,7 @@ */ package org.mockitousage.internal.invocation.realmethod; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; import org.mockito.internal.invocation.realmethod.CleanTraceRealMethod; @@ -11,7 +12,7 @@ import org.mockitoutil.TestBase; import static junit.framework.TestCase.fail; -import static org.mockitoutil.ExtraMatchers.hasMethodInStackTraceAt; +import static org.mockitoutil.Conditions.methodInStackTraceAt; public class CleanTraceRealMethodTest extends TestBase { @@ -42,9 +43,9 @@ public Object invoke(Object target, Object[] arguments) throws Throwable { fail(); //then } catch (Exception e) { - assertThat(e, hasMethodInStackTraceAt(0, "throwSomething")); - assertThat(e, hasMethodInStackTraceAt(1, "invoke")); - assertThat(e, hasMethodInStackTraceAt(2, "shouldRemoveMockitoInternalsFromStackTraceWhenRealMethodThrows")); + Assertions.assertThat(e).has(methodInStackTraceAt(0, "throwSomething")); + Assertions.assertThat(e).has(methodInStackTraceAt(1, "invoke")); + Assertions.assertThat(e).has(methodInStackTraceAt(2, "shouldRemoveMockitoInternalsFromStackTraceWhenRealMethodThrows")); } } } \ No newline at end of file diff --git a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java index 134bea8944..df90dc10d2 100644 --- a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java +++ b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java @@ -9,12 +9,16 @@ import org.mockito.exceptions.verification.TooLittleActualInvocations; import org.mockito.runners.MockitoJUnitRunner; import org.mockitousage.IMethods; +import org.mockitoutil.JUnitResultAssert; import org.mockitoutil.TestBase; import java.util.List; import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; /** * Created by sfaber on 4/22/16. @@ -29,7 +33,7 @@ public class SilentRunnerTest extends TestBase { SomeFeature.class ); //then - assertThat(result).isSuccessful(); + JUnitResultAssert.assertThat(result).isSuccessful(); } @Test public void failing_test() { @@ -38,7 +42,7 @@ public class SilentRunnerTest extends TestBase { SomeFailingFeature.class ); //then - assertThat(result).fails(1, TooLittleActualInvocations.class); + JUnitResultAssert.assertThat(result).fails(1, TooLittleActualInvocations.class); } @Test public void validates_framework_usage() { @@ -47,7 +51,7 @@ public class SilentRunnerTest extends TestBase { UsesFrameworkIncorrectly.class ); //then - assertThat(result).fails(1, UnfinishedStubbingException.class); + JUnitResultAssert.assertThat(result).fails(1, UnfinishedStubbingException.class); } @Test @@ -56,7 +60,7 @@ public void ignores_unused_stubs() { //when Result result = runner.run(HasUnnecessaryStubs.class); //then - assertThat(result).isSuccessful(); + JUnitResultAssert.assertThat(result).isSuccessful(); } @RunWith(MockitoJUnitRunner.Silent.class) diff --git a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java index bcd298edb1..c12df6acbf 100644 --- a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java +++ b/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java @@ -9,12 +9,14 @@ import org.mockito.exceptions.misusing.UnnecessaryStubbingException; import org.mockito.runners.MockitoJUnitRunner; import org.mockitousage.IMethods; +import org.mockitoutil.JUnitResultAssert; import org.mockitoutil.TestBase; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; + /** * Created by sfaber on 4/22/16. */ @@ -30,7 +32,7 @@ public class StrictRunnerTest extends TestBase { StubbingInTestUsed.class ); //then - assertThat(result).isSuccessful(); + JUnitResultAssert.assertThat(result).isSuccessful(); } @Test public void fails_when_stubs_were_not_used() { @@ -42,7 +44,7 @@ public class StrictRunnerTest extends TestBase { Result result = runner.run(tests); //then - assertThat(result).fails(3, UnnecessaryStubbingException.class); + JUnitResultAssert.assertThat(result).fails(3, UnnecessaryStubbingException.class); } @Test public void does_not_report_unused_stubs_when_different_failure_is_present() { @@ -50,7 +52,7 @@ public class StrictRunnerTest extends TestBase { Result result = runner.run(WithUnrelatedAssertionFailure.class); //then - assertThat(result).fails(1, MyAssertionError.class); + JUnitResultAssert.assertThat(result).fails(1, MyAssertionError.class); } @RunWith(MockitoJUnitRunner.class) diff --git a/src/test/java/org/mockitousage/matchers/MatchersTest.java b/src/test/java/org/mockitousage/matchers/MatchersTest.java index 86f476cc84..46b0caeb52 100644 --- a/src/test/java/org/mockitousage/matchers/MatchersTest.java +++ b/src/test/java/org/mockitousage/matchers/MatchersTest.java @@ -436,6 +436,27 @@ public void nullMatcher() { assertEquals("2", mock.threeArgumentMethod(1, new Object(), "")); } + @Test + public void nullMatcherForPrimitiveWrappers() { + when(mock.forBoolean(isNull(Boolean.class))).thenReturn("ok"); + when(mock.forInteger(isNull(Integer.class))).thenReturn("ok"); + when(mock.forLong(isNull(Long.class))).thenReturn("ok"); + when(mock.forByte(isNull(Byte.class))).thenReturn("ok"); + when(mock.forShort(isNull(Short.class))).thenReturn("ok"); + when(mock.forCharacter(isNull(Character.class))).thenReturn("ok"); + when(mock.forDouble(isNull(Double.class))).thenReturn("ok"); + when(mock.forFloat(isNull(Float.class))).thenReturn("ok"); + + assertEquals("ok", mock.forBoolean(null)); + assertEquals("ok", mock.forInteger(null)); + assertEquals("ok", mock.forLong(null)); + assertEquals("ok", mock.forByte(null)); + assertEquals("ok", mock.forShort(null)); + assertEquals("ok", mock.forCharacter(null)); + assertEquals("ok", mock.forDouble(null)); + assertEquals("ok", mock.forFloat(null)); + } + @Test public void notNullMatcher() { when(mock.threeArgumentMethod(eq(1), notNull(), eq(""))).thenReturn("1"); diff --git a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java index 026905bae6..3471fe0a19 100644 --- a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java +++ b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java @@ -13,6 +13,7 @@ import java.util.*; import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; import static org.mockito.Matchers.*; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -22,22 +23,41 @@ public class MoreMatchersTest extends TestBase { @Mock private IMethods mock; @Test - public void shouldHelpOutWithUnnecessaryCasting() { + public void should_help_out_with_unnecessary_casting() { when(mock.objectArgMethod(any(String.class))).thenReturn("string"); assertEquals("string", mock.objectArgMethod("foo")); } @Test - public void shouldAnyBeActualAliasToAnyObject() { + public void any_should_be_actual_alias_to_anyObject() { mock.simpleMethod((Object) null); + verify(mock).simpleMethod(any()); verify(mock).simpleMethod(anyObject()); - verify(mock).simpleMethod(any(Object.class)); } @Test - public void shouldHelpOutWithUnnecessaryCastingOfLists() { + public void any_class_should_be_actual_alias_to_isA() { + mock.simpleMethod(new ArrayList()); + + verify(mock).simpleMethod(isA(List.class)); + verify(mock).simpleMethod(any(List.class)); + + + mock.simpleMethod((String) null); + try { + verify(mock).simpleMethod(isA(String.class)); + fail(); + } catch (AssertionError ignored) { } + try { + verify(mock).simpleMethod(any(String.class)); + fail(); + } catch (AssertionError ignored) { } + } + + @Test + public void should_help_out_with_unnecessary_casting_of_lists() { //Below yields compiler warning: //when(mock.listArgMethod(anyList())).thenReturn("list"); when(mock.listArgMethod(anyListOf(String.class))).thenReturn("list"); @@ -47,7 +67,7 @@ public void shouldHelpOutWithUnnecessaryCastingOfLists() { } @Test - public void shouldHelpOutWithUnnecessaryCastingOfSets() { + public void should_help_out_with_unnecessary_casting_of_sets() { //Below yields compiler warning: //when(mock.setArgMethod(anySet())).thenReturn("set"); when(mock.setArgMethod(anySetOf(String.class))).thenReturn("set"); @@ -57,7 +77,7 @@ public void shouldHelpOutWithUnnecessaryCastingOfSets() { } @Test - public void shouldHelpOutWithUnnecessaryCastingOfMaps() { + public void should_help_out_with_unnecessary_casting_of_maps() { //Below yields compiler warning: //when(mock.setArgMethod(anySet())).thenReturn("set"); when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("map"); @@ -67,17 +87,27 @@ public void shouldHelpOutWithUnnecessaryCastingOfMaps() { } @Test - public void shouldHelpOutWithUnnecessaryCastingOfCollections() { + public void should_help_out_with_unnecessary_casting_of_collections() { + //Below yields compiler warning: + //when(mock.setArgMethod(anySet())).thenReturn("set"); + when(mock.collectionArgMethod(anyCollectionOf(String.class))).thenReturn("collection"); + + assertEquals("collection", mock.collectionArgMethod(new ArrayList<String>())); + assertEquals("collection", mock.collectionArgMethod(Collections.<String>emptyList())); + } + + @Test + public void should_help_out_with_unnecessary_casting_of_iterables() { //Below yields compiler warning: //when(mock.setArgMethod(anySet())).thenReturn("set"); - when(mock.collectionArgMethod(anyCollectionOf(String.class))).thenReturn("col"); + when(mock.iterableArgMethod(anyIterableOf(String.class))).thenReturn("iterable"); - assertEquals("col", mock.collectionArgMethod(new ArrayList<String>())); - assertEquals("col", mock.collectionArgMethod(Collections.<String>emptyList())); + assertEquals("iterable", mock.iterableArgMethod(new ArrayList<String>())); + assertEquals("iterable", mock.iterableArgMethod(Collections.<String>emptyList())); } @Test - public void shouldHelpOutWithUnnecessaryCastingOfNullityChecks() { + public void should_help_out_with_unnecessary_casting_of_nullity_checks() { when(mock.objectArgMethod(isNull(LinkedList.class))).thenReturn("string"); when(mock.objectArgMethod(notNull(LinkedList.class))).thenReturn("string"); when(mock.objectArgMethod(isNotNull(LinkedList.class))).thenReturn("string"); diff --git a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java b/src/test/java/org/mockitousage/matchers/NewMatchersTest.java index 89b31cf02d..7c1dcffe0b 100644 --- a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java +++ b/src/test/java/org/mockitousage/matchers/NewMatchersTest.java @@ -70,4 +70,14 @@ public void shouldAllowAnySet() { verify(mock, times(1)).forSet(anySet()); } + + @Test + public void shouldAllowAnyIterable() { + when(mock.forIterable(anyIterable())).thenReturn("matched"); + + assertEquals("matched", mock.forIterable(new HashSet<String>())); + assertEquals(null, mock.forIterable(null)); + + verify(mock, times(1)).forIterable(anyIterable()); + } } \ No newline at end of file diff --git a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java b/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java index 89a98fd664..a4c2061058 100644 --- a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java +++ b/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java @@ -5,13 +5,14 @@ package org.mockitousage.puzzlers; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockitoutil.TestBase; import static junit.framework.TestCase.assertEquals; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.mockitoutil.ExtraMatchers.hasBridgeMethod; +import static org.mockitoutil.Conditions.bridgeMethod; /** * Bridge method is generated by compiler when erasure in parent class is @@ -42,8 +43,8 @@ public void shouldHaveBridgeMethod() throws Exception { assertEquals("Dummy says: Hello", s.say("Hello")); - assertThat(Sub.class, hasBridgeMethod("say")); - assertThat(s, hasBridgeMethod("say")); + Assertions.assertThat(Sub.class).has(bridgeMethod("say")); + Assertions.assertThat(s).has(bridgeMethod("say")); } @Test diff --git a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java b/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java index a863f3a368..d70dc14cc5 100644 --- a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java +++ b/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java @@ -5,14 +5,18 @@ package org.mockitousage.spies; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; -import org.mockitoutil.ExtraMatchers; import org.mockitoutil.TestBase; import static junit.framework.TestCase.assertEquals; import static junit.framework.TestCase.fail; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockitoutil.Conditions.methodsInStackTrace; @SuppressWarnings("unchecked") public class PartialMockingWithSpiesTest extends TestBase { @@ -105,7 +109,7 @@ public void shouldStackTraceGetFilteredOnUserExceptions() { fail(); } catch (Throwable t) { // then - assertThat(t, ExtraMatchers.hasMethodsInStackTrace( + Assertions.assertThat(t).has(methodsInStackTrace( "throwSomeException", "getNameButDelegateToMethodThatThrows", "shouldStackTraceGetFilteredOnUserExceptions" diff --git a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java b/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java index 056603db94..22d6b26c77 100644 --- a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java +++ b/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java @@ -11,6 +11,7 @@ import net.bytebuddy.description.modifier.Visibility; import net.bytebuddy.dynamic.loading.ClassLoadingStrategy; import net.bytebuddy.implementation.FixedValue; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.base.MockitoException; import org.mockito.invocation.InvocationOnMock; @@ -20,9 +21,11 @@ import java.util.List; import static junit.framework.TestCase.fail; -import static org.hamcrest.core.Is.is; import static org.junit.Assume.assumeTrue; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; @SuppressWarnings({"unchecked"}) public class SpyingOnInterfacesTest extends TestBase { @@ -77,7 +80,7 @@ public void shouldAllowDelegatingToDefaultMethod() throws Exception { //when when(type.getMethod("foo").invoke(object)).thenCallRealMethod(); //then - assertThat(type.getMethod("foo").invoke(object), is((Object) "bar")); + Assertions.assertThat(type.getMethod("foo").invoke(object)).isEqualTo((Object) "bar"); type.getMethod("foo").invoke(verify(object)); } @@ -103,7 +106,7 @@ public void shouldAllowSpyingOnDefaultMethod() throws Exception { Object object = spy(impl.newInstance()); //when - assertThat(impl.getMethod("foo").invoke(object), is((Object) "bar")); + Assertions.assertThat(impl.getMethod("foo").invoke(object)).isEqualTo((Object) "bar"); //then impl.getMethod("foo").invoke(verify(object)); } diff --git a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java index ee2cd2da85..7c925c0073 100644 --- a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java +++ b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java @@ -5,6 +5,7 @@ package org.mockitousage.stacktrace; +import org.assertj.core.api.Assertions; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -18,8 +19,12 @@ import org.mockitoutil.TestBase; import static junit.framework.TestCase.fail; -import static org.mockito.Mockito.*; -import static org.mockitoutil.ExtraMatchers.hasFirstMethodInStackTrace; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; +import static org.mockitoutil.Conditions.firstMethodInStackTrace; public class StackTraceFilteringTest extends TestBase { @@ -41,7 +46,7 @@ public void shouldFilterStackTraceOnVerify() { verify(mock).simpleMethod(); fail(); } catch (WantedButNotInvoked e) { - assertThat(e, hasFirstMethodInStackTrace("shouldFilterStackTraceOnVerify")); + Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerify")); } } @@ -52,7 +57,7 @@ public void shouldFilterStackTraceOnVerifyNoMoreInteractions() { verifyNoMoreInteractions(mock); fail(); } catch (NoInteractionsWanted e) { - assertThat(e, hasFirstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoMoreInteractions")); + Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoMoreInteractions")); } } @@ -63,7 +68,7 @@ public void shouldFilterStackTraceOnVerifyZeroInteractions() { verifyZeroInteractions(mock); fail(); } catch (NoInteractionsWanted e) { - assertThat(e, hasFirstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions")); + Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions")); } } @@ -74,7 +79,7 @@ public void shouldFilterStacktraceOnMockitoException() { verify(mock).oneArg(true); fail(); } catch (MockitoException expected) { - assertThat(expected, hasFirstMethodInStackTrace("shouldFilterStacktraceOnMockitoException")); + Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException")); } } @@ -89,7 +94,7 @@ public void shouldFilterStacktraceWhenVerifyingInOrder() { inOrder.verify(mock).oneArg(true); fail(); } catch (VerificationInOrderFailure e) { - assertThat(e, hasFirstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder")); + Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder")); } } @@ -99,7 +104,7 @@ public void shouldFilterStacktraceWhenInOrderThrowsMockitoException() { inOrder(); fail(); } catch (MockitoException expected) { - assertThat(expected, hasFirstMethodInStackTrace("shouldFilterStacktraceWhenInOrderThrowsMockitoException")); + Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderThrowsMockitoException")); } } @@ -110,7 +115,7 @@ public void shouldFilterStacktraceWhenInOrderVerifies() { inOrder.verify(null); fail(); } catch (MockitoException expected) { - assertThat(expected, hasFirstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies")); + Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies")); } } @@ -120,7 +125,7 @@ public void shouldFilterStackTraceWhenThrowingExceptionFromMockHandler() { when(mock.oneArg(true)).thenThrow(new Exception()); fail(); } catch (MockitoException expected) { - assertThat(expected, hasFirstMethodInStackTrace("shouldFilterStackTraceWhenThrowingExceptionFromMockHandler")); + Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStackTraceWhenThrowingExceptionFromMockHandler")); } } @@ -132,7 +137,7 @@ public void shouldShowProperExceptionStackTrace() throws Exception { mock.simpleMethod(); fail(); } catch (RuntimeException e) { - assertThat(e, hasFirstMethodInStackTrace("shouldShowProperExceptionStackTrace")); + Assertions.assertThat(e).has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace")); } } } diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index 4a3a7ba7a2..d8e5bd157b 100644 --- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -237,7 +237,7 @@ public void should_print_method_when_matcher_used() throws Exception { "Wanted but not invoked:" + "\n" + "iMethods.twoArgumentMethod(\n" + - " isA(java.lang.Integer),\n" + + " <any integer>,\n" + " 100\n" + ");"; assertContains(expectedMessage, actualMessage); diff --git a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java b/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java index 5e6c8624f5..4149e8b5bc 100644 --- a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java +++ b/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java @@ -5,13 +5,14 @@ package org.mockitousage.verification; +import org.assertj.core.api.Assertions; import org.junit.Test; import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent; import org.mockitousage.IMethods; import org.mockitoutil.TestBase; import static junit.framework.TestCase.fail; -import static org.mockito.Matchers.any; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -21,17 +22,17 @@ public class PrintingVerboseTypesWithArgumentsTest extends TestBase { class Boo { public void withLong(long x) { } - + public void withLongAndInt(long x, int y) { } } - + @Test - public void shouldNotReportArgumentTypesWhenToStringIsTheSame() throws Exception { + public void should_not_report_argument_types_when_to_string_is_the_same() { //given Boo boo = mock(Boo.class); boo.withLong(100); - + try { //when verify(boo).withLong(eq(100)); @@ -42,13 +43,13 @@ public void shouldNotReportArgumentTypesWhenToStringIsTheSame() throws Exception assertContains("withLong((Long) 100);", e.getMessage()); } } - + @Test - public void shouldShowTheTypeOfOnlyTheArgumentThatDoesntMatch() throws Exception { + public void should_show_the_type_of_only_the_argument_that_doesnt_match() { //given Boo boo = mock(Boo.class); boo.withLongAndInt(100, 200); - + try { //when verify(boo).withLongAndInt(eq(100), eq(200)); @@ -59,30 +60,37 @@ public void shouldShowTheTypeOfOnlyTheArgumentThatDoesntMatch() throws Exception assertContains("withLongAndInt((Long) 100, 200)", e.getMessage()); } } - + @Test - public void shouldShowTheTypeOfTheMismatchingArgumentWhenOutputDescriptionsForInvocationsAreDifferent() throws Exception { + public void should_show_the_type_of_the_mismatching_argument_when_output_descriptions_for_invocations_are_different() { //given Boo boo = mock(Boo.class); boo.withLongAndInt(100, 200); - + try { //when verify(boo).withLongAndInt(eq(100), any(Integer.class)); fail(); } catch (ArgumentsAreDifferent e) { //then - assertContains("withLongAndInt((Long) 100, 200)", e.getMessage()); - assertContains("withLongAndInt((Integer) 100, <any>", e.getMessage()); + Assertions.assertThat(e.getMessage()) + .contains("withLongAndInt(\n" + + " (Long) 100,\n" + + " 200\n" + + ")") + .contains("withLongAndInt(\n" + + " (Integer) 100,\n" + + " <any java.lang.Integer>\n" + + ")"); } } - + @Test - public void shouldNotShowTypesWhenArgumentValueIsDifferent() throws Exception { + public void should_not_show_types_when_argument_value_is_different() { //given Boo boo = mock(Boo.class); boo.withLongAndInt(100, 200); - + try { //when verify(boo).withLongAndInt(eq(100L), eq(230)); @@ -93,34 +101,34 @@ public void shouldNotShowTypesWhenArgumentValueIsDifferent() throws Exception { assertContains("withLongAndInt(100, 230)", e.getMessage()); } } - + class Foo { - + private final int x; public Foo(int x) { this.x = x; } - + public boolean equals(Object obj) { return x == ((Foo) obj).x; } - + public int hashCode() { return 1; } - + public String toString() { return "foo"; } } - + @Test - public void shouldNotShowTypesWhenTypesAreTheSameEvenIfToStringGivesTheSameResult() throws Exception { + public void should_not_show_types_when_types_are_the_same_even_if_to_string_gives_the_same_result() { //given IMethods mock = mock(IMethods.class); mock.simpleMethod(new Foo(10)); - + try { //when verify(mock).simpleMethod(new Foo(20)); diff --git a/src/test/java/org/mockitoutil/Conditions.java b/src/test/java/org/mockitoutil/Conditions.java new file mode 100644 index 0000000000..39061cd080 --- /dev/null +++ b/src/test/java/org/mockitoutil/Conditions.java @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2007 Mockito contributors + * This program is made available under the terms of the MIT License. + */ + +package org.mockitoutil; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.Condition; +import org.assertj.core.description.Description; +import org.assertj.core.description.TextDescription; +import org.hamcrest.CoreMatchers; + +import java.lang.reflect.Method; +import java.util.Arrays; + +@SuppressWarnings("unchecked") +public class Conditions { + + public static Condition<Throwable> onlyThoseClassesInStackTrace(final String... classes) { + return new Condition<Throwable>() { + @Override + public boolean matches(Throwable traceElements) { + StackTraceElement[] trace = traceElements.getStackTrace(); + + Assertions.assertThat(trace.length) + .describedAs("Number of classes does not match.\nExpected: %s\nGot: %s", + Arrays.toString(classes), + Arrays.toString(traceElements.getStackTrace())) + .isEqualTo(classes.length); + + for (int i = 0; i < trace.length; i++) { + Assertions.assertThat(trace[i].getClassName()).isEqualTo(classes[i]); + } + + return true; + } + }; + } + + public static Condition<StackTraceElement[]> onlyThoseClasses(final String... classes) { + return new Condition<StackTraceElement[]>() { + + @Override + public boolean matches(StackTraceElement[] traceElements) { + Assertions.assertThat(traceElements.length) + .describedAs("Number of classes does not match.\nExpected: %s\nGot: %s", + Arrays.toString(classes), + Arrays.toString(traceElements)) + .isEqualTo(classes.length); + + for (int i = 0; i < traceElements.length; i++) { + Assertions.assertThat(traceElements[i].getClassName()).isEqualTo(classes[i]); + } + + return true; + } + }; + } + + public static Condition<Throwable> firstMethodInStackTrace(final String method) { + return methodInStackTraceAt(0, method); + } + + public static Condition<Throwable> methodInStackTraceAt(final int stackTraceIndex, final String method) { + return new Condition<Throwable>() { + private String actualMethodAtIndex; + + @Override + public boolean matches(Throwable throwable) { + actualMethodAtIndex = throwable.getStackTrace()[stackTraceIndex].getMethodName(); + + return actualMethodAtIndex.equals(method); + } + + @Override + public Description description() { + return new TextDescription("Method at index: %d\nexpected to be: %s\nbut is: %s", stackTraceIndex, method, actualMethodAtIndex); + } + }; + } + + public static Condition<Object> bridgeMethod(final String methodName) { + return new Condition<Object>() { + + public boolean matches(Object o) { + Class<?> clazz = null; + if (o instanceof Class) { + clazz = (Class<?>) o; + } else { + clazz = o.getClass(); + } + + for (Method m : clazz.getMethods()) { + if (m.isBridge() && m.getName().equals(methodName)) { + return true; + } + } + + Assertions.fail("Bridge method [" + methodName + "]\nnot found in:\n" + o); + return false; + } + }; + } + + public static org.hamcrest.Matcher<Object> clazz(Class<?> type) { + return CoreMatchers.instanceOf(type); + } + + public static Condition<Throwable> methodsInStackTrace(final String... methods) { + return new Condition<Throwable>() { + public boolean matches(Throwable value) { + StackTraceElement[] trace = value.getStackTrace(); + for (int i = 0; i < methods.length; i++) { + Assertions.assertThat(trace[i].getMethodName()).describedAs("Expected methods[%d] to be in the stack trace.", i).isEqualTo(methods[i]); + } + return true; + } + }; + } + + +} \ No newline at end of file diff --git a/src/test/java/org/mockitoutil/ExtraMatchers.java b/src/test/java/org/mockitoutil/ExtraMatchers.java deleted file mode 100644 index c3f80f34c6..0000000000 --- a/src/test/java/org/mockitoutil/ExtraMatchers.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ - -package org.mockitoutil; - -import org.hamcrest.CoreMatchers; -import org.hamcrest.Matcher; - -import java.lang.reflect.Method; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -import static org.junit.Assert.*; - -@SuppressWarnings("unchecked") -public class ExtraMatchers { - - public static <T> Assertor<Throwable> hasFirstMethodInStackTrace(final String method) { - return hasMethodInStackTraceAt(0, method); - } - - public static <T> Assertor<Throwable> hasOnlyThoseClassesInStackTrace(final String ... classes) { - return new Assertor<Throwable>() { - public void assertValue(Throwable traceElements) { - StackTraceElement[] trace = traceElements.getStackTrace(); - - assertEquals("Number of classes does not match." + - "\nExpected: " + Arrays.toString(classes) + - "\nGot: " + Arrays.toString(traceElements.getStackTrace()), - classes.length, trace.length); - - for (int i = 0; i < trace.length; i++) { - assertEquals(classes[i], trace[i].getClassName()); - } - } - }; - } - - public static <T> Assertor<StackTraceElement[]> hasOnlyThoseClasses(final String ... classes) { - return new Assertor<StackTraceElement[]>() { - public void assertValue(StackTraceElement[] traceElements) { - assertEquals("Number of classes does not match." + - "\nExpected: " + Arrays.toString(classes) + - "\nGot: " + Arrays.toString(traceElements), - classes.length, traceElements.length); - - for (int i = 0; i < traceElements.length; i++) { - assertEquals(classes[i], traceElements[i].getClassName()); - } - } - }; - } - - public static <T> Assertor<Throwable> hasMethodInStackTraceAt(final int stackTraceIndex, final String method) { - return new Assertor<Throwable>() { - - private String actualMethodAtIndex; - - public void assertValue(Throwable throwable) { - actualMethodAtIndex = throwable.getStackTrace()[stackTraceIndex].getMethodName(); - assertTrue( - "Method at index: " + stackTraceIndex + - "\n" + - "expected to be: " + method + - "\n" + - "but is: " + actualMethodAtIndex, - actualMethodAtIndex.equals(method)); - } - }; - } - - public static <T> Assertor<Object> hasBridgeMethod(final String methodName) { - return new Assertor<Object>() { - - public void assertValue(Object o) { - Class<?> clazz = null; - if (o instanceof Class) { - clazz = (Class<?>) o; - } else { - clazz = o.getClass(); - } - - for (Method m : clazz.getMethods()) { - if (m.isBridge() && m.getName().equals(methodName)) { - return; - } - } - - fail("Bridge method [" + methodName + "]\nnot found in:\n" + o); - } - }; - } - - public static <T> Assertor<Collection> hasExactlyInOrder(final T ... elements) { - return new Assertor<Collection>() { - - public void assertValue(Collection value) { - assertEquals(elements.length, value.size()); - - boolean containsSublist = Collections.indexOfSubList((List<?>) value, Arrays.asList(elements)) != -1; - assertTrue( - "Elements:" + - "\n" + - Arrays.toString(elements) + - "\n" + - "were not found in collection:" + - "\n" + - value, containsSublist); - } - }; - } - - public static <T> Assertor<Collection> contains(final Matcher<T> ... elements) { - return new Assertor<Collection>() { - - public void assertValue(Collection value) { - int matched = 0; - for (Matcher<T> m : elements) { - for (Object el : value) { - if (m.matches(el)) { - matched++; - continue; - } - } - } - - assertEquals("At least one of the matchers failed to match any of the elements", elements.length, matched); - } - }; - } - - public static org.hamcrest.Matcher<Object> clazz(Class<?> type) { - return CoreMatchers.instanceOf(type); - } - - public static Assertor<Throwable> hasMethodsInStackTrace(final String ... methods) { - return new Assertor<Throwable>() { - public void assertValue(Throwable value) { - StackTraceElement[] trace = value.getStackTrace(); - for (int i = 0; i < methods.length; i++) { - assertEquals("Expected methods[" + i + "] to be in the stack trace.", methods[i], trace[i].getMethodName()); - } - } - }; - } -} \ No newline at end of file diff --git a/src/test/java/org/mockitoutil/JUnitResultAssert.java b/src/test/java/org/mockitoutil/JUnitResultAssert.java index f4fd9f9769..8a425a91c6 100644 --- a/src/test/java/org/mockitoutil/JUnitResultAssert.java +++ b/src/test/java/org/mockitoutil/JUnitResultAssert.java @@ -2,7 +2,6 @@ import org.junit.runner.Result; import org.junit.runner.notification.Failure; -import org.mockito.exceptions.misusing.UnnecessaryStubbingException; import java.util.List; @@ -57,4 +56,11 @@ private static String formatFailures(List<Failure> failures) { } return out.toString(); } + + /** + * Clean assertions for JUnit's result object + */ + public static JUnitResultAssert assertThat(Result result) { + return new JUnitResultAssert(result); + } } diff --git a/src/test/java/org/mockitoutil/TestBase.java b/src/test/java/org/mockitoutil/TestBase.java index 9ad32341bd..348e12f060 100644 --- a/src/test/java/org/mockitoutil/TestBase.java +++ b/src/test/java/org/mockitoutil/TestBase.java @@ -5,10 +5,8 @@ package org.mockitoutil; -import org.hamcrest.Matcher; import org.junit.After; import org.junit.Before; -import org.junit.runner.Result; import org.mockito.MockitoAnnotations; import org.mockito.StateMaster; import org.mockito.internal.MockitoCore; @@ -26,7 +24,6 @@ import java.io.IOException; import java.io.PrintStream; import java.util.Collection; -import java.util.regex.Pattern; import static junit.framework.TestCase.assertFalse; import static junit.framework.TestCase.assertTrue; @@ -68,29 +65,6 @@ protected Invocation getLastInvocation() { return new MockitoCore().getLastInvocation(); } - //I'm really tired of matchers, enter the assertor! - protected static <T> void assertThat(T o, Assertor<T> a) { - a.assertValue(o); - } - - protected static <T> void assertThat(T actual, Matcher<? super T> matcher) { - org.junit.Assert.assertThat(actual, matcher); - } - - protected static <T> void assertThat(String message, T actual, Matcher<T> m) { - org.junit.Assert.assertThat(message, actual, m); - } - - public static <T> Assertor<String> endsWith(final String substring) { - return new Assertor<String>() { - public void assertValue(String value) { - assertTrue("This substring: \n" + substring + - "\nshould be at the end of:\n" + value - , value.endsWith(substring)); - } - }; - } - public static void assertNotEquals(Object expected, Object got) { assertFalse(expected.equals(got)); } @@ -201,11 +175,4 @@ protected String getStackTrace(Throwable e) { protected String filterLineNo(String stackTrace) { return stackTrace.replaceAll("(\\((\\w+\\.java):(\\d)+\\))", "($2:0)"); } - - /** - * Clean assertions for JUnit's result object - */ - protected JUnitResultAssert assertThat(Result result) { - return new JUnitResultAssert(result); - } }

train

train

bric3

train

mockito/mockito/497_549

mockito/mockito

mockito/mockito/497

mockito/mockito/549

4ce9ac2ea38153f4f0c7e272d52fdf9a494ccb14

27bcbbb03709b23d0efaa300dab6cd5b9d345a83

DEEP_STUBS tries to mock final class

``` <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>1.10.19</version> <scope>test</scope> </dependency> ``` ``` $ java -version java version "1.8.0_91" Java(TM) SE Runtime Environment (build 1.8.0_91-b14) Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode) ``` ``` import static org.junit.Assert.assertNull; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; import org.junit.Test; public class MockitoBug { public interface Supplier<T> { public T get(); } public interface StringSupplier extends Supplier<String> {} public interface InheritedSupplier extends StringSupplier {} @Test public void deepStubs() { StringSupplier mock = mock(StringSupplier.class, RETURNS_DEEP_STUBS); String s = mock.get(); assertNull(s); } @Test public void inheritedDeepStubs() { InheritedSupplier mock = mock(InheritedSupplier.class, RETURNS_DEEP_STUBS); String s = mock.get(); // ClassCastException assertNull(s); } } ``` ``` java.lang.ClassCastException: org.mockito.internal.creation.cglib.ClassImposterizer$ClassWithSuperclassToWorkAroundCglibBug$$EnhancerByMockitoWithCGLIB$$322ebf6e cannot be cast to java.lang.String at MockitoBug.inheritedDeepStubs(MockitoBug.java:26) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:678) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192) ``` I expect the behavior for `StringSupplier` and `InheritedSupplier` to be the same: return `null` for `get`. However, `InheritedSupplier` tries to return a mock `Object` for `get`.

diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java index 50baa3c2f6..8d150ff787 100644 --- a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java +++ b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java @@ -62,6 +62,48 @@ public abstract class GenericMetadataSupport { */ protected Map<TypeVariable, Type> contextualActualTypeParameters = new HashMap<TypeVariable, Type>(); + /** + * Registers the type variables for the given type and all of its superclasses and superinterfaces. + */ + protected void registerAllTypeVariables(Type classType) { + Queue<Type> typesToRegister = new LinkedList<Type>(); + Set<Type> registeredTypes = new HashSet<Type>(); + typesToRegister.add(classType); + + while (!typesToRegister.isEmpty()) { + Type typeToRegister = typesToRegister.poll(); + if (typeToRegister == null || registeredTypes.contains(typeToRegister)) { + continue; + } + + registerTypeVariablesOn(typeToRegister); + registeredTypes.add(typeToRegister); + + Class<?> rawType = extractRawTypeOf(typeToRegister); + typesToRegister.add(rawType.getGenericSuperclass()); + typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces())); + } + } + + protected Class<?> extractRawTypeOf(Type type) { + if (type instanceof Class) { + return (Class<?>) type; + } + if (type instanceof ParameterizedType) { + return (Class<?>) ((ParameterizedType) type).getRawType(); + } + if (type instanceof BoundedType) { + return extractRawTypeOf(((BoundedType) type).firstBound()); + } + if (type instanceof TypeVariable) { + /* + * If type is a TypeVariable, then it is needed to gather data elsewhere. Usually TypeVariables are declared + * on the class definition, such as such as List<E>. + */ + return extractRawTypeOf(contextualActualTypeParameters.get(type)); + } + throw new MockitoException("Raw extraction not supported for : '" + type + "'"); + } protected void registerTypeVariablesOn(Type classType) { if (!(classType instanceof ParameterizedType)) { @@ -270,28 +312,8 @@ private static class FromClassGenericMetadataSupport extends GenericMetadataSupp public FromClassGenericMetadataSupport(Class<?> clazz) { this.clazz = clazz; - for (Class<?> currentExploredClass = clazz; - currentExploredClass != null && currentExploredClass != Object.class; - currentExploredClass = superClassOf(currentExploredClass)) { - readActualTypeParametersOnDeclaringClass(currentExploredClass); - } - } - - private Class superClassOf(Class<?> currentExploredClass) { - Type genericSuperclass = currentExploredClass.getGenericSuperclass(); - if (genericSuperclass instanceof ParameterizedType) { - Type rawType = ((ParameterizedType) genericSuperclass).getRawType(); - return (Class<?>) rawType; - } - return (Class<?>) genericSuperclass; - } - - private void readActualTypeParametersOnDeclaringClass(Class<?> clazz) { registerTypeParametersOn(clazz.getTypeParameters()); - registerTypeVariablesOn(clazz.getGenericSuperclass()); - for (Type genericInterface : clazz.getGenericInterfaces()) { - registerTypeVariablesOn(genericInterface); - } + registerAllTypeVariables(clazz); } @Override @@ -321,8 +343,7 @@ public FromParameterizedTypeGenericMetadataSupport(ParameterizedType parameteriz } private void readActualTypeParameters() { - registerTypeVariablesOn(parameterizedType.getRawType()); - registerTypeVariablesOn(parameterizedType); + registerAllTypeVariables(parameterizedType); } @Override @@ -403,26 +424,6 @@ public Class<?> rawType() { return rawType; } - private Class<?> extractRawTypeOf(Type type) { - if (type instanceof Class) { - return (Class<?>) type; - } - if (type instanceof ParameterizedType) { - return (Class<?>) ((ParameterizedType) type).getRawType(); - } - if (type instanceof BoundedType) { - return extractRawTypeOf(((BoundedType) type).firstBound()); - } - if (type instanceof TypeVariable) { - /* - * If type is a TypeVariable, then it is needed to gather data elsewhere. Usually TypeVariables are declared - * on the class definition, such as such as List<E>. - */ - return extractRawTypeOf(contextualActualTypeParameters.get(type)); - } - throw new MockitoException("Raw extraction not supported for : '" + type + "'"); - } - @Override public List<Type> extraInterfaces() { Type type = extractActualBoundedTypeOf(typeVariable);

diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java index 44066b8ced..f580b359a3 100644 --- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java +++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java @@ -19,6 +19,8 @@ public class ReturnsGenericDeepStubsTest { interface ListOfInteger extends List<Integer> {} + interface AnotherListOfInteger extends ListOfInteger {} + interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> { Set<Number> remove(Object key); // override with fixed ParameterizedType List<? super Number> returningWildcard(); @@ -93,9 +95,11 @@ public void can_still_work_with_raw_type_in_the_return_type() throws Exception { public void will_return_default_value_on_non_mockable_nested_generic() throws Exception { GenericsNest<?> genericsNest = mock(GenericsNest.class, RETURNS_DEEP_STUBS); ListOfInteger listOfInteger = mock(ListOfInteger.class, RETURNS_DEEP_STUBS); + AnotherListOfInteger anotherListOfInteger = mock(AnotherListOfInteger.class, RETURNS_DEEP_STUBS); assertThat(genericsNest.returningNonMockableNestedGeneric().keySet().iterator().next()).isNull(); assertThat(listOfInteger.get(25)).isEqualTo(0); + assertThat(anotherListOfInteger.get(25)).isEqualTo(0); } @Test(expected = ClassCastException.class) diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java index d068e043d5..dff0d7f3ea 100644 --- a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java +++ b/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java @@ -28,6 +28,11 @@ interface UpperBoundedTypeWithInterfaces<E extends Comparable<E> & Cloneable> { E get(); } interface ListOfNumbers extends List<Number> {} + interface AnotherListOfNumbers extends ListOfNumbers {} + + abstract class ListOfNumbersImpl implements ListOfNumbers {} + abstract class AnotherListOfNumbersImpl extends ListOfNumbersImpl {} + interface ListOfAnyNumbers<N extends Number & Cloneable> extends List<N> {} interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> { @@ -76,6 +81,13 @@ public void can_get_type_variables_from_Class() throws Exception { assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty(); } + @Test + public void can_resolve_type_variables_from_ancestors() throws Exception { + Method listGet = List.class.getMethod("get", int.class); + assertThat(inferFrom(AnotherListOfNumbers.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class); + assertThat(inferFrom(AnotherListOfNumbersImpl.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class); + } + @Test public void can_get_type_variables_from_ParameterizedType() throws Exception { assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V");

train

train

JeffFaer

train

mockito/mockito/538_550

mockito/mockito

mockito/mockito/538

mockito/mockito/550

f80dd4a95d78d15dfea814877d143e8e31cfd880

fea4074f8d4a7b1f7b8e89d4819bef25b1b6228f

Improve error message when @InjectMocks is uses on an interface or enum field

By accident a tests delares a field of an interface type instead of the implementing class. ``` @InjectMocks public InterfaceType unitUnderTest; ``` Injection is not possible on interfaces or enums. The error message should make this clear, the currenta message that doesn't help much: ``` org.mockito.exceptions.base.MockitoException: Cannot instantiate @InjectMocks field named 'configurationManager'. You haven't provided the instance at field declaration so I tried to construct the instance. However, I failed because: the type 'ConfigurationManager' is an interface. Examples of correct usage of @InjectMocks: @InjectMocks Service service = new Service(); @InjectMocks Service service; //also, don't forget about MockitoAnnotations.initMocks(); //and... don't forget about some @Mocks for injection :) ``` The error message should be someting like: `The field 'unitUnderTest' can not be annotated with @InjectMocks cause the type 'InterfaceType ' not a class! `

diff --git a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java index 92e5868913..5b52a71262 100644 --- a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java +++ b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java @@ -98,7 +98,7 @@ private FieldInitializationReport initializeInjectMocksField(Field field, Object Throwable realCause = e.getCause().getCause(); throw fieldInitialisationThrewException(field, realCause); } - throw cannotInitializeForInjectMocksAnnotation(field.getName(), e); + throw cannotInitializeForInjectMocksAnnotation(field.getName(),e.getMessage()); } } diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java index 3a63d69ddc..8a28e67f89 100644 --- a/src/main/java/org/mockito/internal/exceptions/Reporter.java +++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java @@ -627,16 +627,14 @@ public static MockitoException cannotInitializeForSpyAnnotation(String fieldName ""), details); } - public static MockitoException cannotInitializeForInjectMocksAnnotation(String fieldName, Exception details) { - return new MockitoException(join("Cannot instantiate @InjectMocks field named '" + fieldName + "'.", + public static MockitoException cannotInitializeForInjectMocksAnnotation(String fieldName, String causeMessage) { + return new MockitoException(join("Cannot instantiate @InjectMocks field named '" + fieldName + "'! Cause: "+causeMessage, "You haven't provided the instance at field declaration so I tried to construct the instance.", - "However, I failed because: " + details.getMessage(), "Examples of correct usage of @InjectMocks:", " @InjectMocks Service service = new Service();", " @InjectMocks Service service;", - " //also, don't forget about MockitoAnnotations.initMocks();", " //and... don't forget about some @Mocks for injection :)", - ""), details); + "")); } public static MockitoException atMostAndNeverShouldNotBeUsedWithTimeout() { diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java b/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java index 7a49e1f6b5..fdc6975498 100644 --- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java +++ b/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java @@ -7,6 +7,7 @@ import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.util.MockUtil; +import static java.lang.reflect.Modifier.isStatic; import static org.mockito.internal.util.reflection.FieldSetter.setField; import java.lang.reflect.Constructor; @@ -68,7 +69,9 @@ private FieldInitializer(Object fieldOwner, Field field, ConstructorInstantiator checkNotLocal(field); checkNotInner(field); checkNotInterface(field); + checkNotEnum(field); checkNotAbstract(field); + } this.fieldOwner = fieldOwner; this.field = field; @@ -100,8 +103,9 @@ private void checkNotLocal(Field field) { } private void checkNotInner(Field field) { - if(field.getType().isMemberClass() && !Modifier.isStatic(field.getType().getModifiers())) { - throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an inner class."); + Class<?> type = field.getType(); + if(type.isMemberClass() && !isStatic(type.getModifiers())) { + throw new MockitoException("the type '" + type.getSimpleName() + "' is an inner non static class."); } } @@ -113,10 +117,17 @@ private void checkNotInterface(Field field) { private void checkNotAbstract(Field field) { if(Modifier.isAbstract(field.getType().getModifiers())) { - throw new MockitoException("the type '" + field.getType().getSimpleName() + " is an abstract class."); + throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an abstract class."); + } + } + + private void checkNotEnum(Field field) { + if(field.getType().isEnum()) { + throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an enum."); } } + private FieldInitializationReport acquireFieldInstance() throws IllegalAccessException { Object fieldInstance = field.get(fieldOwner); if(fieldInstance != null) {

diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java index 4ae5590012..a11a3a7332 100644 --- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java +++ b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java @@ -5,9 +5,24 @@ package org.mockitousage.annotation; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; + +import java.util.AbstractCollection; +import java.util.List; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import org.assertj.core.api.Assertions; import org.junit.Ignore; +import org.junit.Rule; import org.junit.Test; import org.junit.internal.TextListener; +import org.junit.rules.ExpectedException; import org.junit.runner.JUnitCore; import org.junit.runner.RunWith; import org.mockito.InjectMocks; @@ -17,17 +32,11 @@ import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.util.MockUtil; import org.mockito.runners.MockitoJUnitRunner; +import org.mockitousage.IMethods; import org.mockitousage.examples.use.ArticleCalculator; import org.mockitousage.examples.use.ArticleDatabase; import org.mockitousage.examples.use.ArticleManager; -import java.util.List; -import java.util.Set; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.*; -import static org.mockito.Mockito.when; - @RunWith(MockitoJUnitRunner.class) public class MockInjectionUsingConstructorTest { @@ -37,8 +46,8 @@ public class MockInjectionUsingConstructorTest { @InjectMocks private ArticleManager articleManager; @Spy @InjectMocks private ArticleManager spiedArticleManager; - -// @InjectMocks private ArticleVisitor should_be_initialized_3_times; + @Rule + public ExpectedException exception = ExpectedException.none(); @Test public void shouldNotFailWhenNotInitialized() { @@ -120,5 +129,91 @@ private static class ATest { @InjectMocks FailingConstructor failingConstructor; } + + @Test + public void injectMocksMustFailWithInterface() throws Exception { + class TestCase { + @InjectMocks + IMethods f; + } + + exception.expect(MockitoException.class); + exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface"); + + + initMocks(new TestCase()); + } + + @Test + public void injectMocksMustFailWithEnum() throws Exception { + class TestCase { + @InjectMocks + TimeUnit f; + } + + exception.expect(MockitoException.class); + exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum"); + + initMocks(new TestCase()); + } + + @Test + public void injectMocksMustFailWithAbstractClass() throws Exception { + class TestCase { + @InjectMocks + AbstractCollection<?> f; + } + + exception.expect(MockitoException.class); + exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class"); + + initMocks(new TestCase()); + } + + @Test + public void injectMocksMustFailWithNonStaticInnerClass() throws Exception { + class TestCase { + class InnerClass {} + @InjectMocks + InnerClass f; + } + + + exception.expect(MockitoException.class); + exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class"); + + initMocks(new TestCase()); + } + + static class StaticInnerClass {} + @Test + public void injectMocksMustSucceedWithStaticInnerClass() throws Exception { + class TestCase { + @InjectMocks + StaticInnerClass f; + } + + TestCase testClass = new TestCase(); + initMocks(testClass); + + assertThat(testClass.f).isInstanceOf(StaticInnerClass.class); + } + + @Test + public void injectMocksMustSucceedWithInstance() throws Exception { + class TestCase { + @InjectMocks + StaticInnerClass f = new StaticInnerClass(); + } + + TestCase testClass = new TestCase(); + StaticInnerClass original = testClass.f; + initMocks(testClass); + + assertThat(testClass.f).isSameAs(original); + } + + + } diff --git a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java index 7d6ae465ba..5915fe71cd 100644 --- a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java +++ b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java @@ -6,7 +6,9 @@ package org.mockitousage.basicapi; import org.junit.Test; +import org.mockito.InjectMocks; import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; import org.mockito.exceptions.base.MockitoException; import org.mockito.exceptions.verification.SmartNullPointerException; import org.mockito.internal.debugging.LocationImpl; @@ -16,6 +18,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Set; +import java.util.concurrent.TimeUnit; import static junit.framework.TestCase.*; import static org.assertj.core.api.Assertions.assertThat;

train

train

ChristianSchwarz

train

mockito/mockito/551_556

mockito/mockito

mockito/mockito/551

mockito/mockito/556

4ce9ac2ea38153f4f0c7e272d52fdf9a494ccb14

669a05c1dcc6423ae15d5cf04f40720e3a8f0765

Unexpected new public API: VerificationWrapper, VerificationWrapperInOrder, VerificationCollectorImpl

It looks like some classes leaked to the public API: VerificationWrapper, VerificationWrapperInOrder, VerificationCollectorImpl They seem like internal classes because: a) they are concrete implementation where public API should be an interface b) no javadoc c) looking at their API, they don't seem like something we want to expose to the users :) We need to fix it before 2.0, perhaps it's just the matter of moving it to internal packages.

diff --git a/src/main/java/org/mockito/internal/InOrderImpl.java b/src/main/java/org/mockito/internal/InOrderImpl.java index cb3442f373..ce37b23da4 100644 --- a/src/main/java/org/mockito/internal/InOrderImpl.java +++ b/src/main/java/org/mockito/internal/InOrderImpl.java @@ -14,8 +14,8 @@ import org.mockito.internal.verification.api.VerificationInOrderMode; import org.mockito.invocation.Invocation; import org.mockito.verification.VerificationMode; -import org.mockito.verification.VerificationWrapper; -import org.mockito.verification.VerificationWrapperInOrderWrapper; +import org.mockito.internal.verification.VerificationWrapper; +import org.mockito.internal.verification.VerificationWrapperInOrderWrapper; import static org.mockito.internal.exceptions.Reporter.inOrderRequiresFamiliarMock; diff --git a/src/main/java/org/mockito/junit/VerificationCollectorImpl.java b/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java similarity index 94% rename from src/main/java/org/mockito/junit/VerificationCollectorImpl.java rename to src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java index b1ffeb8946..da9c4515f6 100644 --- a/src/main/java/org/mockito/junit/VerificationCollectorImpl.java +++ b/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java @@ -1,4 +1,4 @@ -package org.mockito.junit; +package org.mockito.internal.junit; import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress; @@ -7,18 +7,19 @@ import org.mockito.exceptions.base.MockitoAssertionError; import org.mockito.internal.progress.MockingProgressImpl; import org.mockito.internal.verification.api.VerificationData; +import org.mockito.junit.VerificationCollector; import org.mockito.verification.VerificationMode; import org.mockito.verification.VerificationStrategy; /** * Mockito implementation of VerificationCollector. */ -class VerificationCollectorImpl implements VerificationCollector { +public class VerificationCollectorImpl implements VerificationCollector { private StringBuilder builder; private int numberOfFailures; - VerificationCollectorImpl() { + public VerificationCollectorImpl() { this.resetBuilder(); } diff --git a/src/main/java/org/mockito/verification/VerificationWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapper.java similarity index 93% rename from src/main/java/org/mockito/verification/VerificationWrapper.java rename to src/main/java/org/mockito/internal/verification/VerificationWrapper.java index d32fab221d..13ad8d8164 100644 --- a/src/main/java/org/mockito/verification/VerificationWrapper.java +++ b/src/main/java/org/mockito/internal/verification/VerificationWrapper.java @@ -1,7 +1,7 @@ -package org.mockito.verification; +package org.mockito.internal.verification; -import org.mockito.internal.verification.VerificationModeFactory; import org.mockito.internal.verification.api.VerificationData; +import org.mockito.verification.VerificationMode; public abstract class VerificationWrapper<WrapperType extends VerificationMode> implements VerificationMode { diff --git a/src/main/java/org/mockito/verification/VerificationWrapperInOrderWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java similarity index 91% rename from src/main/java/org/mockito/verification/VerificationWrapperInOrderWrapper.java rename to src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java index e04cfd749d..f04ebadbfb 100644 --- a/src/main/java/org/mockito/verification/VerificationWrapperInOrderWrapper.java +++ b/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java @@ -1,12 +1,10 @@ -package org.mockito.verification; +package org.mockito.internal.verification; import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.InOrderImpl; -import org.mockito.internal.verification.InOrderWrapper; -import org.mockito.internal.verification.VerificationModeFactory; -import org.mockito.internal.verification.VerificationOverTimeImpl; import org.mockito.internal.verification.api.VerificationData; import org.mockito.internal.verification.api.VerificationInOrderMode; +import org.mockito.verification.VerificationMode; public class VerificationWrapperInOrderWrapper implements VerificationMode { private final VerificationMode delegate; diff --git a/src/main/java/org/mockito/junit/MockitoJUnit.java b/src/main/java/org/mockito/junit/MockitoJUnit.java index 8c6c32ea6e..fac86b4572 100644 --- a/src/main/java/org/mockito/junit/MockitoJUnit.java +++ b/src/main/java/org/mockito/junit/MockitoJUnit.java @@ -1,6 +1,7 @@ package org.mockito.junit; import org.mockito.internal.junit.JUnitRule; +import org.mockito.internal.junit.VerificationCollectorImpl; import org.mockito.internal.util.ConsoleMockitoLogger; /** diff --git a/src/main/java/org/mockito/verification/After.java b/src/main/java/org/mockito/verification/After.java index cc63dfbfd5..089324ebcc 100644 --- a/src/main/java/org/mockito/verification/After.java +++ b/src/main/java/org/mockito/verification/After.java @@ -2,6 +2,7 @@ import org.mockito.internal.verification.VerificationModeFactory; import org.mockito.internal.verification.VerificationOverTimeImpl; +import org.mockito.internal.verification.VerificationWrapper; /** * See the javadoc for {@link VerificationAfterDelay} diff --git a/src/main/java/org/mockito/verification/Timeout.java b/src/main/java/org/mockito/verification/Timeout.java index dcb8b46c9b..f49765a270 100644 --- a/src/main/java/org/mockito/verification/Timeout.java +++ b/src/main/java/org/mockito/verification/Timeout.java @@ -9,6 +9,7 @@ import org.mockito.internal.util.Timer; import org.mockito.internal.verification.VerificationModeFactory; import org.mockito.internal.verification.VerificationOverTimeImpl; +import org.mockito.internal.verification.VerificationWrapper; /** * See the javadoc for {@link VerificationWithTimeout}

train

train

mockitoguy

train

mockito/mockito/533_557

mockito/mockito

mockito/mockito/533

mockito/mockito/557

4ce9ac2ea38153f4f0c7e272d52fdf9a494ccb14

a8c9b1c9a40a3702979b6feace16e1acd6349281

Remove code.google.com from javadoc

Looks like the javadoc still has some references to code.google.com, let's replace them with up to date links.

diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md index ebab07f5f0..1fe4857285 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/CONTRIBUTING.md @@ -27,7 +27,7 @@ * Also, don't hesitate to ask questions on the [mailing list](https://groups.google.com/forum/#!forum/mockito) - that helps us improve javadocs/FAQ. * Please suggest changes to javadoc/exception messages when you find something unclear. * If you miss a particular feature in Mockito - browse or ask on the mailing list, show us a sample code and describe the problem. -* Wondering what to work on? See [task/bug list](https://github.com/mockito/mockito/issues/) [(old task/bug list)](http://code.google.com/p/mockito/issues/list) and pick up something you would like to work on. Remember that some feature requests we somewhat not agree with so not everything we want to work on :) +* Wondering what to work on? See [task/bug list](https://github.com/mockito/mockito/issues/) and pick up something you would like to work on. Remember that some feature requests we somewhat not agree with so not everything we want to work on :) * Mockito currently uses GitHub for versioning so you can *create a fork of Mockito in no time*. Go to the [github project](https://github.com/mockito/mockito) and "Create your own fork". Create a new branch, commit, ..., when you're ready let us know about your pull request so we can discuss it and merge the PR! * Note the project now uses *gradle*, when your Gradle install is ready, make your IDE project's files (for example **`gradle idea`**). Other gradle commands are listed via **`gradle tasks`**. @@ -38,18 +38,18 @@ For that reason each pull request has to go through a thorough review and/or dis Things we pay attention in a PR : -* On pull requests, please document the change, what it brings, what is the benefit. If the issue exists on the old issue tracker on [Google Code](https://code.google.com/p/mockito/issues/list), please add cross links. But don't create a new one there. +* On pull requests, please document the change, what it brings, what is the benefit. * **Clean commit history** in the topic branch in your fork of the repository, even during review. That means that commits are _rebased_ and _squashed_ if necessary, so that each commit clearly changes one things and there are no extraneous fix-ups. For that matter it's possible to commit [_semantic_ changes](http://lemike-de.tumblr.com/post/79041908218/semantic-commits). _Tests are an asset, so is history_. - + _Exemple gratia_: - + ``` Fixes #73 : The new feature Fixes #73 : Refactors this part of Mockito to make feature possible ``` - + * In the code, always test your feature / change, in unit tests and in our `acceptance test suite` located in `org.mockitousage`. Older tests will be migrated when a test is modified. * New test methods should follow a snake case convention (`ensure_that_stuff_is_doing_that`), this allows the test name to be fully expressive on intent while still readable. * When reporting errors to the users, if it's a user report report it gently and explain how a user should deal with it, see the `Reporter` class. However not all errors should go there, some unlikely technical errors don't need to be in the `Reporter` class. @@ -58,4 +58,3 @@ Things we pay attention in a PR : _If you are unsure about git you can have a look on our [git tips to have a clean history](https://github.com/mockito/mockito/wiki/Using git to prepare your PR to have a clean history)._ - diff --git a/src/main/java/org/mockito/AdditionalAnswers.java b/src/main/java/org/mockito/AdditionalAnswers.java index fd97305ef2..9ee4a20013 100644 --- a/src/main/java/org/mockito/AdditionalAnswers.java +++ b/src/main/java/org/mockito/AdditionalAnswers.java @@ -122,8 +122,7 @@ public static <T> Answer<T> returnsArgAt(int position) { * <li>Already custom proxied object</li> * <li>Special objects with a finalize method, i.e. to avoid executing it 2 times</li> * </ul> - * For more details including the use cases reported by users take a look at - * <a link="http://code.google.com/p/mockito/issues/detail?id=145">issue 145</a>. + * * <p> * The difference with the regular spy: * <ul> diff --git a/src/main/java/org/mockito/MockSettings.java b/src/main/java/org/mockito/MockSettings.java index 2b5f934694..137764c35f 100644 --- a/src/main/java/org/mockito/MockSettings.java +++ b/src/main/java/org/mockito/MockSettings.java @@ -40,7 +40,6 @@ public interface MockSettings extends Serializable { /** * Specifies extra interfaces the mock should implement. Might be useful for legacy code or some corner cases. - * For background, see issue 51 <a href="http://code.google.com/p/mockito/issues/detail?id=51">here</a> * <p> * This mysterious feature should be used very occasionally. * The object under test should know exactly its collaborators & dependencies. diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index ec953791d2..f92ff50d51 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -674,8 +674,7 @@ * <p> * The only reason we added <code>reset()</code> method is to * make it possible to work with container-injected mocks. - * See issue 55 (<a href="http://code.google.com/p/mockito/issues/detail?id=55">here</a>) - * or FAQ (<a href="http://code.google.com/p/mockito/wiki/FAQ">here</a>). + * For more information see FAQ (<a href="https://github.com/mockito/mockito/wiki/FAQ">here</a>). * <p> * <b>Don't harm yourself.</b> <code>reset()</code> in the middle of the test method is a code smell (you're probably testing too much). * <pre class="code"><code class="java"> @@ -693,7 +692,7 @@ * <h3 id="18">18. <a class="meaningful_link" href="#framework_validation">Troubleshooting & validating framework usage</a> (Since 1.8.0)</h3> * * First of all, in case of any trouble, I encourage you to read the Mockito FAQ: - * <a href="http://code.google.com/p/mockito/wiki/FAQ">http://code.google.com/p/mockito/wiki/FAQ</a> + * <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a> * <p> * In case of questions you may also post to mockito mailing list: * <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a> @@ -1812,8 +1811,7 @@ public static <T> T verify(T mock, VerificationMode mode) { * <p> * The only reason we added <code>reset()</code> method is to * make it possible to work with container-injected mocks. - * See issue 55 (<a href="http://code.google.com/p/mockito/issues/detail?id=55">here</a>) - * or FAQ (<a href="http://code.google.com/p/mockito/wiki/FAQ">here</a>). + * For more information see the FAQ (<a href="https://github.com/mockito/mockito/wiki/FAQ">here</a>). * <p> * <b>Don't harm yourself.</b> <code>reset()</code> in the middle of the test method is a code smell (you're probably testing too much). * <pre class="code"><code class="java"> @@ -2202,8 +2200,8 @@ public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext) * Also, you can create InOrder object passing only mocks that are relevant for in-order verification. * <p> * <code>InOrder</code> verification is 'greedy', but you will hardly ever notice it. - * If you want to find out more, search for 'greedy' in the Mockito - * <a href="http://code.google.com/p/mockito/w/list">wiki pages</a>. + * If you want to find out more, read + * <a href="https://github.com/mockito/mockito/wiki/Greedy-algorithm-of-verfication-InOrder">this wiki page</a>. * <p> * As of Mockito 1.8.4 you can verifyNoMoreInvocations() in order-sensitive way. Read more: {@link InOrder#verifyNoMoreInteractions()} * <p> @@ -2485,7 +2483,7 @@ public static VerificationAfterDelay after(long millis) { } /** - * First of all, in case of any trouble, I encourage you to read the Mockito FAQ: <a href="http://code.google.com/p/mockito/wiki/FAQ">http://code.google.com/p/mockito/wiki/FAQ</a> + * First of all, in case of any trouble, I encourage you to read the Mockito FAQ: <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a> * <p> * In case of questions you may also post to mockito mailing list: <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a> * <p>

val

train

bric3

train

mockito/mockito/554_560

mockito/mockito

mockito/mockito/554

mockito/mockito/560

d5fec63dd1268fae0cdd91e3e8f760e4b806af55

38610245f27225fb7ce1b50dd355bd7b0ac86792

Checks.checkNotNull should emit IllegalArgumentException instead of NPE

Checks.checkNotNull emits NPE. I think it is better to emit IAE, because: - IAE is more specific whereas NPE is more generic. Specific exception is easier to test. - Specific exception gives better experience for users, NPE is often assumed to be developer error. This change is not backwards compatible. @bric3, thoughts?

diff --git a/src/main/java/org/mockito/internal/util/Checks.java b/src/main/java/org/mockito/internal/util/Checks.java index 00ed8a8f22..acb8e914b0 100644 --- a/src/main/java/org/mockito/internal/util/Checks.java +++ b/src/main/java/org/mockito/internal/util/Checks.java @@ -12,7 +12,7 @@ public class Checks { public static <T> T checkNotNull(T value, String checkedValue) { if(value == null) { - throw new NullPointerException(checkedValue + " should not be null"); + throw new IllegalArgumentException(checkedValue + " should not be null"); } return value; }

diff --git a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java b/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java index ed20c9ccc2..4abb528042 100644 --- a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java +++ b/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java @@ -29,22 +29,22 @@ public void reset() throws Exception { withoutConstructor = null; } - @Test(expected = NullPointerException.class) + @Test(expected = IllegalArgumentException.class) public void should_not_allow_null_on_field() { MockInjection.onField((Field) null, this); } - @Test(expected = NullPointerException.class) + @Test(expected = IllegalArgumentException.class) public void should_not_allow_null_on_fields() { MockInjection.onFields((Set<Field>) null, this); } - @Test(expected = NullPointerException.class) + @Test(expected = IllegalArgumentException.class) public void should_not_allow_null_on_instance_owning_the_field() throws Exception { MockInjection.onField(field("withConstructor"), null); } - @Test(expected = NullPointerException.class) + @Test(expected = IllegalArgumentException.class) public void should_not_allow_null_on_mocks() throws Exception { MockInjection.onField(field("withConstructor"), this).withMocks(null); }

test

train

mockitoguy

train

mockito/mockito/541_569

mockito/mockito

mockito/mockito/541

mockito/mockito/569

e38764fa0c5fb0373b8a82120b12a2b635e363a9

18d421778e1952f8e8f291201207702ac590edc9

improve Mockito.mockingDetails API

In order to make the API cleaner & expose useful information: 1. MockingDetails.getInvocations() throws meaningful exception when passed object is not a mock and documents this behavior 2. getMockedType() and getExtraInterfaces() are replaced with getMockCreationSettings() that returns MockCreationSettings instance.

diff --git a/src/main/java/org/mockito/MockingDetails.java b/src/main/java/org/mockito/MockingDetails.java index ee8496380e..534cbd02f8 100644 --- a/src/main/java/org/mockito/MockingDetails.java +++ b/src/main/java/org/mockito/MockingDetails.java @@ -5,9 +5,9 @@ package org.mockito; import org.mockito.invocation.Invocation; +import org.mockito.mock.MockCreationSettings; import java.util.Collection; -import java.util.Set; /** * Provides mocking information. @@ -36,27 +36,24 @@ public interface MockingDetails { /** * All method invocations on this mock. * Can be empty - it means there were no interactions with the mock. + * <p> + * This method is useful for framework integrators and for certain edge cases. * * @since 1.10.0 */ Collection<Invocation> getInvocations(); /** - * Returns the type that is mocked. It is the type originally passed to - * the <code>{@link Mockito#mock(Class)}</code> or <code>{@link Mockito#spy(Class)}</code> function, - * or the type referenced by a Mockito annotation. - * - * @return The mocked type - * @since 2.0.0 - */ - Class<?> getMockedType(); - - /** - * Returns the extra-interfaces of the mock. The interfaces that were configured at the mock creation - * with the <code>{@link MockSettings#extraInterfaces(Class[])}</code>. - * - * @return The extra-interfaces + * Returns various mock settings provided when the mock was created, for example: + * mocked class, mock name (if any), any extra interfaces (if any), etc. + * See also {@link MockCreationSettings}. + * <p> + * This method is useful for framework integrators and for certain edge cases. + * <p> + * If <code>null</code> or non-mock was passed to {@link Mockito#mockingDetails(Object)} + * then this method will throw with an appropriate exception. + * After all, non-mock objects do not have any mock creation settings. * @since 2.0.0 */ - Set<Class<?>> getExtraInterfaces(); + MockCreationSettings<?> getMockCreationSettings(); } diff --git a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java index f7a91dfbba..5117ccbf96 100644 --- a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java +++ b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java @@ -5,12 +5,14 @@ package org.mockito.internal.util; import org.mockito.MockingDetails; +import org.mockito.exceptions.misusing.NotAMockException; +import org.mockito.internal.InternalMockHandler; import org.mockito.invocation.Invocation; - -import static org.mockito.internal.util.MockUtil.getMockHandler; +import org.mockito.mock.MockCreationSettings; import java.util.Collection; -import java.util.Set; + +import static org.mockito.internal.util.MockUtil.getMockHandler; /** * Class to inspect any object, and identify whether a particular object is either a mock or a spy. This is @@ -36,17 +38,25 @@ public boolean isSpy(){ @Override public Collection<Invocation> getInvocations() { - return getMockHandler(toInspect).getInvocationContainer().getInvocations(); + return mockHandler().getInvocationContainer().getInvocations(); } @Override - public Class<?> getMockedType() { - return getMockHandler(toInspect).getMockSettings().getTypeToMock(); + public MockCreationSettings<?> getMockCreationSettings() { + return mockHandler().getMockSettings(); } - @Override - public Set<Class<?>> getExtraInterfaces() { - return getMockHandler(toInspect).getMockSettings().getExtraInterfaces(); + private InternalMockHandler<Object> mockHandler() { + assertGoodMock(); + return getMockHandler(toInspect); + } + + private void assertGoodMock() { + if (toInspect == null) { + throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is null!"); + } else if (!isMock()) { + throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of " + toInspect.getClass() + "!"); + } } }

diff --git a/src/test/java/org/mockito/MockingDetailsTest.java b/src/test/java/org/mockito/MockingDetailsTest.java deleted file mode 100644 index ba870517a3..0000000000 --- a/src/test/java/org/mockito/MockingDetailsTest.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.mockito; - -import org.junit.Test; -import org.mockito.internal.MockitoCore; -import org.mockito.invocation.Invocation; -import org.mockitoutil.TestBase; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import static junit.framework.TestCase.*; -import static org.mockito.Mockito.mock; - -public class MockingDetailsTest extends TestBase { - - @Test - public void should_provide_invocations() { - List<String> methodsInvoked = new ArrayList<String>() {{ - add("add"); - add("remove"); - add("clear"); - }}; - - @SuppressWarnings("unchecked") - List<String> mockedList = (List<String>) mock(List.class); - - mockedList.add("one"); - mockedList.remove(0); - mockedList.clear(); - - MockingDetails mockingDetails = new MockitoCore().mockingDetails(mockedList); - Collection<Invocation> invocations = mockingDetails.getInvocations(); - - assertNotNull(invocations); - assertEquals(invocations.size(),3); - for (Invocation method : invocations) { - assertTrue(methodsInvoked.contains(method.getMethod().getName())); - if (method.getMethod().getName().equals("add")) { - assertEquals(method.getArguments().length,1); - assertEquals(method.getArguments()[0],"one"); - } - } - } - - @Test - public void should_handle_null_input() { - //TODO 541, decide how to handle it and ensure the there is a top level integ test for the mockingDetails().getInvocations() - //assertTrue(new MockitoCore().mockingDetails(null).getInvocations().isEmpty()); - } -} diff --git a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java b/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java index 3c151a96f5..225f1a0b48 100644 --- a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java +++ b/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java @@ -1,16 +1,17 @@ package org.mockito.internal.util; +import junit.framework.TestCase; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Spy; import org.mockito.exceptions.misusing.NotAMockException; import org.mockito.runners.MockitoJUnitRunner; +import org.mockitousage.IMethods; -import java.util.*; - +import static junit.framework.TestCase.fail; import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.mockingDetails; @SuppressWarnings("unchecked") @RunWith(MockitoJUnitRunner.class) @@ -18,6 +19,7 @@ public class DefaultMockingDetailsTest { @Mock private Foo foo; @Mock private Bar bar; + @Mock private IMethods mock; @Spy private Gork gork; @Test @@ -42,28 +44,51 @@ public void should_check_that_a_spy_is_also_a_mock() throws Exception { } @Test - public void should_get_mocked_type() throws Exception { - assertEquals(Bar.class, mockingDetails(bar).getMockedType()); - } + public void provides_invocations() { + //when + mock.simpleMethod(10); + mock.otherMethod(); - @Test(expected = NotAMockException.class) - public void should_report_when_not_a_mockito_mock_on_getMockedType() throws Exception { - mockingDetails("not a mock").getMockedType(); + //then + assertEquals(0, mockingDetails(foo).getInvocations().size()); + assertEquals("[mock.simpleMethod(10);, mock.otherMethod();]", mockingDetails(mock).getInvocations().toString()); } @Test - public void should_get_extra_interfaces() throws Exception { - Bar loup = mock(Bar.class, withSettings().extraInterfaces(List.class, Observer.class)); - assertEquals(setOf(Observer.class, List.class), mockingDetails(loup).getExtraInterfaces()); + public void provides_mock_creation_settings() { + //smoke test some creation settings + assertEquals(Foo.class, mockingDetails(foo).getMockCreationSettings().getTypeToMock()); + assertEquals(Bar.class, mockingDetails(bar).getMockCreationSettings().getTypeToMock()); + assertEquals(0, mockingDetails(mock).getMockCreationSettings().getExtraInterfaces().size()); } @Test(expected = NotAMockException.class) - public void should_report_when_not_a_mockito_mock_on_getExtraInterfaces() throws Exception { - mockingDetails("not a mock").getExtraInterfaces(); + public void fails_when_getting_creation_settings_for_incorrect_input() { + mockingDetails(null).getMockCreationSettings(); } - private <T> Set<T> setOf(T... items) { - return new HashSet<T>(Arrays.asList(items)); + @Test + public void fails_when_getting_invocations_when_null() { + try { + //when + mockingDetails(null).getInvocations(); + //then + fail(); + } catch (NotAMockException e) { + TestCase.assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is null!", e.getMessage()); + } + } + + @Test + public void fails_when_getting_invocations_when_not_mock() { + try { + //when + mockingDetails(new Object()).getInvocations(); + //then + fail(); + } catch (NotAMockException e) { + TestCase.assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage()); + } } public class Foo { }

train

train

mockitoguy

train

mockito/mockito/570_571

mockito/mockito

mockito/mockito/570

mockito/mockito/571

92d71605142dda602d7f6032c187d223695f29d8

78214f71330b74fc436fe2f932647df39dbf03a0

Hard to understand argument difference between int and long

check that - [x] The mockito message in the stacktrace have useful information, but it didn't help - [x] The problematic code (if that's possible) is copied here; Note that some configuration are impossible to mock via Mockito - [x] Provide versions (mockito / jdk / os / any other relevant information) - [x] Provide a [Short, Self Contained, Correct (Compilable), Example](http://sscce.org) of the issue (same as any question on stackoverflow.com) - [x] Read the [contributing guide](https://github.com/mockito/mockito/blob/master/.github/CONTRIBUTING.md) JDK: 1.8 OS: linux mockito: master branch Sample code: ``` package com.example; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.runners.MockitoJUnitRunner; import java.util.HashMap; import java.util.Map; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; public class HogeTest { @Test public void test() { Hello hello = mock(Hello.class); hello.greeting(new HashMap<String, Object>() {{ put("hello", 3L); }}); verify(hello).greeting(new HashMap<String, Object>() {{ put("hello", 3); }}); } public static class Hello { void greeting(Map<String, Object> l) { } } } ``` Output: ``` Testing started at 8:37 AM ... 8:37:01 AM: Executing external tasks ':cleanTest :test --tests "com.example.HogeTest.test"'... :cleanTest :compileJava UP-TO-DATE :processResources UP-TO-DATE :classes UP-TO-DATE :compileTestJava :processTestResources UP-TO-DATE :testClasses :test com.example.HogeTest > test FAILED org.mockito.exceptions.verification.junit.ArgumentsAreDifferent at HogeTest.java:31 Argument(s) are different! Wanted: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:31) Actual invocation has different arguments: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:26) Argument(s) are different! Wanted: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:31) Actual invocation has different arguments: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:26) at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at com.example.HogeTest.test(HogeTest.java:31) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:47) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:44) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:271) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:70) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229) at org.junit.runners.ParentRunner.run(ParentRunner.java:309) at org.mockito.internal.runners.JUnit45AndHigherRunnerImpl.run(JUnit45AndHigherRunnerImpl.java:37) at org.mockito.runners.MockitoJUnitRunner.run(MockitoJUnitRunner.java:62) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.runTestClass(JUnitTestClassExecuter.java:105) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.execute(JUnitTestClassExecuter.java:56) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassProcessor.processTestClass(JUnitTestClassProcessor.java:64) at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:50) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35) at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24) at org.gradle.messaging.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32) at org.gradle.messaging.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93) at com.sun.proxy.$Proxy2.processTestClass(Unknown Source) at org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:106) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35) at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24) at org.gradle.messaging.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:360) at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:54) at org.gradle.internal.concurrent.StoppableExecutorImpl$1.run(StoppableExecutorImpl.java:40) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) at java.lang.Thread.run(Thread.java:745) 1 test completed, 1 failed :test FAILED FAILURE: Build failed with an exception. * What went wrong: Execution failed for task ':test'. > There were failing tests. See the report at: file:///Users/tokuhirom/dev/mockito-sample/build/reports/tests/index.html * Try: Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. BUILD FAILED Total time: 1.713 secs There were failing tests. See the report at: file:///Users/tokuhirom/dev/mockito-sample/build/reports/tests/index.html ``` In this case, user can't understand the difference between _wanted_ and _actual_. Since 2 dumps are same! ``` Argument(s) are different! Wanted: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:31) Actual invocation has different arguments: hello.greeting(() {hello=3}); -> at com.example.HogeTest.test(HogeTest.java:26) ``` If there's a _L_ suffix for long value, user can understand the difference.

diff --git a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java index f382c39ffb..10575d3ae1 100644 --- a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java +++ b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java @@ -1,6 +1,7 @@ package org.mockito.internal.matchers.text; import java.util.Iterator; +import java.util.Map; import static java.lang.String.valueOf; @@ -21,6 +22,16 @@ public static String print(Object value) { return "\"" + value + "\""; } else if (value instanceof Character) { return printChar((Character) value); + } else if (value instanceof Long) { + return value + "L"; + } else if (value instanceof Double) { + return value + "d"; + } else if (value instanceof Float) { + return value + "f"; + } else if (value instanceof Byte) { + return String.format("0x%02X", (Byte) value); + } else if (value instanceof Map) { + return printMap((Map) value); } else if (value.getClass().isArray()) { return printValues("[", ", ", "]", new org.mockito.internal.matchers.text.ArrayIterator(value)); } else if (value instanceof FormattedText) { @@ -30,6 +41,19 @@ public static String print(Object value) { return descriptionOf(value); } + private static String printMap(Map<?,?> map) { + StringBuilder result = new StringBuilder(); + Iterator<? extends Map.Entry<?, ?>> iterator = map.entrySet().iterator(); + while (iterator.hasNext()) { + Map.Entry<?, ?> entry = iterator.next(); + result.append(print(entry.getKey())).append(" = ").append(print(entry.getValue())); + if (iterator.hasNext()) { + result.append(", "); + } + } + return "{" + result.toString() + "}"; + } + /** * Print values in a nice format, e.g. (1, 2, 3) *

diff --git a/src/test/java/org/mockito/internal/matchers/EqualsTest.java b/src/test/java/org/mockito/internal/matchers/EqualsTest.java index d0d92d6a75..6664f68bb7 100644 --- a/src/test/java/org/mockito/internal/matchers/EqualsTest.java +++ b/src/test/java/org/mockito/internal/matchers/EqualsTest.java @@ -39,7 +39,7 @@ public void shouldDescribeWithExtraTypeInfo() throws Exception { public void shouldDescribeWithExtraTypeInfoOfLong() throws Exception { String descStr = new Equals(100L).toStringWithType(); - assertEquals("(Long) 100", descStr); + assertEquals("(Long) 100L", descStr); } @Test diff --git a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java b/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java index efbf377621..eaeea5ec5e 100644 --- a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java +++ b/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java @@ -36,7 +36,7 @@ public void shouldDescribeTypeInfoOnlyMarkedMatchers() { //when String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(1)); //then - assertEquals("(1, (Integer) 2);", line); + assertEquals("(1L, (Integer) 2);", line); } @Test @@ -44,7 +44,7 @@ public void shouldDescribeStringMatcher() { //when String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals("x")), PrintSettings.verboseMatchers(1)); //then - assertEquals("(1, (String) \"x\");", line); + assertEquals("(1L, (String) \"x\");", line); } @Test @@ -52,7 +52,7 @@ public void shouldGetVerboseArgumentsInBlock() { //when String line = printer.getArgumentsBlock((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(0, 1)); //then - assertEquals("(\n (Long) 1,\n (Integer) 2\n);", line); + assertEquals("(\n (Long) 1L,\n (Integer) 2\n);", line); } @Test @@ -60,6 +60,6 @@ public void shouldGetVerboseArgumentsEvenIfSomeMatchersAreNotVerbose() { //when String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), NotNull.NOT_NULL), PrintSettings.verboseMatchers(0)); //then - assertEquals("((Long) 1, notNull());", line); + assertEquals("((Long) 1L, notNull());", line); } } \ No newline at end of file diff --git a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java b/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java index 1ecc8cfb3e..ac7235b345 100644 --- a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java +++ b/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java @@ -3,6 +3,8 @@ import org.junit.Test; +import java.util.LinkedHashMap; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.mockito.internal.matchers.text.ValuePrinter.print; @@ -14,7 +16,26 @@ public void prints_values() throws Exception { assertEquals("null", print(null)); assertEquals("\"str\"", print("str")); assertEquals("\"x\ny\"", print("x\ny")); + assertEquals("3", print(3)); + assertEquals("3L", print(3L)); + assertEquals("3.14d", print(3.14d)); + assertEquals("3.14f", print(3.14f)); assertEquals("[1, 2]", print(new int[]{1, 2})); + assertEquals("{\"foo\" = 2L}", print(new LinkedHashMap<String, Object>() { + { + put("foo", 2L); + } + })); + assertEquals("{\"byte\" = 0x01, \"short\" = 2, \"int\" = 3, \"long\" = 4L, \"float\" = 2.71f, \"double\" = 3.14d}", print(new LinkedHashMap<String, Object>() { + { + put("byte", (byte)1); + put("short", (short)2); + put("int", 3); + put("long", 4L); + put("float", 2.71f); + put("double", 3.14d); + } + })); assertTrue(print(new UnsafeToString()).contains("UnsafeToString")); assertEquals("ToString", print(new ToString())); assertEquals("formatted", print(new FormattedText("formatted"))); diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index 1a2a10cde4..c75b6b05d3 100644 --- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -374,7 +374,7 @@ public void should_print_method_name_and_arguments_of_other_interactions_with_di assertThat(e) .hasMessageContaining("iMethods.threeArgumentMethod(12, foo, \"xx\")") .hasMessageContaining("iMethods.arrayMethod([\"a\", \"b\", \"c\"])") - .hasMessageContaining("iMethods.forByte(25)"); + .hasMessageContaining("iMethods.forByte(0x19)"); } } diff --git a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java b/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java index 233ea4dabb..2c44d9bb44 100644 --- a/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java +++ b/src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java @@ -42,7 +42,7 @@ public void should_not_report_argument_types_when_to_string_is_the_same() { //then assertThat(e) .hasMessageContaining("withLong((Integer) 100);") - .hasMessageContaining("withLong((Long) 100);"); + .hasMessageContaining("withLong((Long) 100L);"); } } @@ -60,7 +60,7 @@ public void should_show_the_type_of_only_the_argument_that_doesnt_match() { //then assertThat(e) .hasMessageContaining("withLongAndInt((Integer) 100, 200)") - .hasMessageContaining("withLongAndInt((Long) 100, 200)"); + .hasMessageContaining("withLongAndInt((Long) 100L, 200)"); } } @@ -78,7 +78,7 @@ public void should_show_the_type_of_the_mismatching_argument_when_output_descrip //then Assertions.assertThat(e.getMessage()) .contains("withLongAndInt(\n" + - " (Long) 100,\n" + + " (Long) 100L,\n" + " 200\n" + ")") .contains("withLongAndInt(\n" + @@ -101,8 +101,8 @@ public void should_not_show_types_when_argument_value_is_different() { } catch (ArgumentsAreDifferent e) { //then assertThat(e) - .hasMessageContaining("withLongAndInt(100, 200)") - .hasMessageContaining("withLongAndInt(100, 230)"); + .hasMessageContaining("withLongAndInt(100L, 200)") + .hasMessageContaining("withLongAndInt(100L, 230)"); } }

train

train

tokuhirom

train

mockito/mockito/564_576

mockito/mockito

mockito/mockito/564

mockito/mockito/576

cc9f19cceb40c7f9fa66d9495f95d2c4dc2f47f8

64be0917781a12f42eeea44f199d7340b5693f73

Publish Mockito build results to Gradle Build Scans

Let's start publishing Mockito build results to Gradle Build Scans. This way we have extra intel about Gradle builds. This also helps friends at Gradle as they will have more projects on board!

diff --git a/.travis.yml b/.travis.yml index 7ec6b9b61d..46a81e5c81 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,7 +49,7 @@ branches: install: - true script: - - ./gradlew ciBuild release + - ./gradlew ciBuild release -Dscan after_success: - ./gradlew --stacktrace coverageReport && cp build/reports/jacoco/mockitoCoverage/mockitoCoverage.xml jacoco.xml || echo "Code coverage failed" - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports" diff --git a/build.gradle b/build.gradle index 9d40980a89..ea9a70728e 100644 --- a/build.gradle +++ b/build.gradle @@ -8,6 +8,11 @@ buildscript { classpath 'org.codehaus.groovy.modules.http-builder:http-builder:0.5.2' //rest calls to bintray api } } + +plugins { + id 'com.gradle.build-scan' version '1.0' +} + apply plugin: 'java' group = 'org.mockito' description = 'Core API and implementation.' @@ -117,7 +122,7 @@ apply from: 'gradle/release.gradle' apply from: "gradle/pom.gradle" task wrapper(type: Wrapper) { - gradleVersion = '2.4' + gradleVersion = '2.14.1' } task ciBuild { @@ -128,3 +133,9 @@ task ciBuild { //Making sure that release task is only invoked after the entire ciBuild validation release.mustRunAfter ciBuild + +//Posting Build scans to https://scans.gradle.com +buildScan { + licenseAgreementUrl = 'https://gradle.com/terms-of-service' + licenseAgree = 'yes' +} diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 0b5a32f1e1..69ef29851a 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Wed Jul 06 11:31:59 CEST 2016 +#Fri Aug 19 18:41:31 PDT 2016 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.11-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-bin.zip diff --git a/gradlew b/gradlew index 91a7e269e1..9d82f78915 100755 --- a/gradlew +++ b/gradlew @@ -42,11 +42,6 @@ case "`uname`" in ;; esac -# For Cygwin, ensure paths are in UNIX format before anything is touched. -if $cygwin ; then - [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` -fi - # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" @@ -61,9 +56,9 @@ while [ -h "$PRG" ] ; do fi done SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >&- +cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" -cd "$SAVED" >&- +cd "$SAVED" >/dev/null CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar @@ -114,6 +109,7 @@ fi if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` diff --git a/gradlew.bat b/gradlew.bat index 8a0b282aa6..5f192121eb 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -46,7 +46,7 @@ echo location of your Java installation. goto fail :init -@rem Get command-line arguments, handling Windowz variants +@rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args if "%@eval[2+2]" == "4" goto 4NT_args diff --git a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java b/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java index 31a14646a0..53f48b2e2f 100644 --- a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java +++ b/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java @@ -27,7 +27,6 @@ public void format(String testName, MockitoLogger logger) { } StubbingHint hint = new StubbingHint(testName); - //TODO 544 it would be nice to make the String look good if x goes multiple digits (padding) int x = 1; for (Map.Entry<Invocation, Set<Invocation>> m : mismatches.entrySet()) { hint.appendLine(x++, ". Unused... ", m.getKey().getLocation()); diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java index 1f415ca776..baaf0516ec 100644 --- a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java +++ b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java @@ -21,7 +21,6 @@ void format(String testName, MockitoLogger logger) { return; } - //TODO 544 it would be nice to make the String look good if x goes multiple digits (padding) StubbingHint hint = new StubbingHint(testName); int x = 1; for (Stubbing candidate : unused) {

train

train

mockitoguy

train

mockito/mockito/552_589

mockito/mockito

mockito/mockito/552

mockito/mockito/589

229790dc71e8ef2257c4a74cc7b13d6e6c3dd01f

8ee3284cf86e8fecd810f564557cd05131c16b62

Fix again javadoc stylesheet

Previously we had a nice javadoc stylesheet. That worked well with JDK6. Then we used travis that was only allowing OracleJDK7, that came with a better javadoc stylesheet so we dropped ours. Now since the release of mockito 2.x is using openjdk6, we should reintroduce a better stylesheet. Current state ❌ http://site.mockito.org/mockito/docs/2.0.100-beta/org/mockito/Mockito.html <img width="712" alt="screen shot 2016-08-13 at 19 41 59" src="https://cloud.githubusercontent.com/assets/803621/17644719/cecc5ec4-618e-11e6-912e-9b0dcd7e94db.png"> Previous ✅ http://site.mockito.org/mockito/docs/2.0.0-beta/org/mockito/Mockito.html <img width="877" alt="screen shot 2016-08-13 at 19 45 32" src="https://cloud.githubusercontent.com/assets/803621/17644722/d71bcd08-618e-11e6-831a-a01c47e8cc61.png">

diff --git a/gradle/javadoc.gradle b/gradle/javadoc.gradle index 51f4cd4e1d..921589844d 100644 --- a/gradle/javadoc.gradle +++ b/gradle/javadoc.gradle @@ -52,7 +52,7 @@ task mockitoJavadoc(type: Javadoc) { } </script> """.replaceAll(/\r|\n/, "")) -// options.stylesheetFile file("src/javadoc/stylesheet.css") + options.stylesheetFile file("src/javadoc/stylesheet.css") // options.addStringOption('top', 'some html') if (JavaVersion.current().isJava8Compatible()) { options.addStringOption('Xdoclint:none', '-quiet') diff --git a/src/javadoc/stylesheet.css b/src/javadoc/stylesheet.css new file mode 100644 index 0000000000..f17de4f9fa --- /dev/null +++ b/src/javadoc/stylesheet.css @@ -0,0 +1,63 @@ +/* Javadoc style sheet */ + +/* Define colors, fonts and other style attributes here to override the defaults */ + +/* Page background color */ +body { background-color: #FFFFFF; color:#333; font-size: 100%; } + +body { font-size: 0.875em; line-height: 1.286em; font-family: "Helvetica", "Arial", sans-serif; } + +code { color: #777; line-height: 1.286em; font-family: "Consolas", "Lucida Console", "Droid Sans Mono", "Andale Mono", "Monaco", "Lucida Sans Typewriter"; } + +pre { color: #555; line-height: 1.0em; font-family: "Consolas", "Lucida Console", "Droid Sans Mono", "Andale Mono", "Monaco", "Lucida Sans Typewriter"; } + + +a { text-decoration: none; color: #16569A; /* also try #2E85ED, #0033FF, #6C93C6, #1D7BBE, #1D8DD2 */ } +a:hover, a:hover code { color: #EEEEEE; background-color: #16569A; } +a:visited, a:visited code { color: #CC3300; } +a:visited:hover, a:visited:hover code { color: #fff; background-color: #CC3300; } + +a.meaningful_link { text-decoration: none; color: #333333; background-color: #EAF9DD; border-bottom: 1px dashed #006400 } +a.meaningful_link code { text-decoration: none; color: #777; border-bottom: 1px dashed #006400 } +a.meaningful_link:hover, a.meaningful_link:hover code { background-color: #E0F9C9; } +a.meaningful_link:visited, a.meaningful_link:visited code { color: #4B0012; } +a.meaningful_link:visited:hover, a.meaningful_link:visited:hover code{ color: #4B0012; background-color: #ADE78B; } + +table[border="1"] { border: 1px solid #ddd; } +table[border="1"] td, table[border="1"] th { border: 1px solid #ddd; } +table[cellpadding="3"] td { padding: 0.5em; } + +font[size="-1"] { font-size: 0.85em; line-height: 1.5em; } +font[size="-2"] { font-size: 0.8em; } +font[size="+2"] { font-size: 1.4em; line-height: 1.3em; padding: 0.4em 0; } + +/* Headings */ +h1 { font-size: 1.5em; line-height: 1.286em;} + +/* Table colors */ +.TableHeadingColor { background: #ccc; color:#444; } /* Dark mauve */ +.TableSubHeadingColor { background: #ddd; color:#444; } /* Light mauve */ +.TableRowColor { background: #FFFFFF; color:#666; font-size: 0.95em; } /* White */ +.TableRowColor code { color:#000; } /* White */ + +/* Font used in left-hand frame lists */ +.FrameTitleFont { font-size: 100%; } +.FrameHeadingFont { font-size: 90%; } +.FrameItemFont { font-size: 0.9em; line-height: 1.3em; +} +/* Java Interfaces */ +.FrameItemFont a i { + font-style: normal; color: #666; +} +.FrameItemFont a:hover i { + font-style: normal; color: #fff; background-color: #666; +} + +/* Navigation bar fonts and colors */ +.NavBarCell1 { background-color:#E0E6DF; } /* Light mauve */ +.NavBarCell1Rev { background-color:#16569A; color:#FFFFFF} /* Dark Blue */ +.NavBarFont1 { } +.NavBarFont1Rev { color:#FFFFFF; } + +.NavBarCell2 { background-color:#FFFFFF; color:#000000} +.NavBarCell3 { background-color:#FFFFFF; color:#000000} \ No newline at end of file

train

train

bric3

train

mockito/mockito/593_597

mockito/mockito

mockito/mockito/593

mockito/mockito/597

e18b07576f8f85c2c5d654a3ccb566adb13c85e7

8adcac947b6656431046c88770c4d04f965d8c09

Mockito Javadoc has a TODO about hamcrest

``` java * TODO rework the documentation, write about hamcrest. * */ @SuppressWarnings("unchecked") public class Mockito extends ArgumentMatchers { ``` https://github.com/bric3/mockito/blob/18133aa0cb5b51c0472fb8b33ab0a22aa9f0fbf3/src/main/java/org/mockito/Mockito.java#L1207-L1207 Let's remove it or fix it.

diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index ffcc5caa12..8ff34cada5 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -1203,9 +1203,6 @@ * return input1 + input2; * }})).when(mock).execute(anyString(), anyString()); * </code></pre> - * - * TODO rework the documentation, write about hamcrest. - * */ @SuppressWarnings("unchecked") public class Mockito extends ArgumentMatchers { @@ -2579,7 +2576,8 @@ public static VerificationMode description(String description) { } /** - * TODO 543 move to MockingDetails + * This API will move soon to a different place. + * See <a href="https://github.com/mockito/mockito/issues/577">issue 577</a>. */ @Deprecated static MockitoDebugger debug() { diff --git a/src/main/java/org/mockito/internal/creation/util/SearchingClassLoader.java b/src/main/java/org/mockito/internal/creation/util/SearchingClassLoader.java deleted file mode 100644 index 645acb4a97..0000000000 --- a/src/main/java/org/mockito/internal/creation/util/SearchingClassLoader.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.creation.util; - -import static java.lang.Thread.*; - -import java.util.ArrayList; -import java.util.List; - -/** - * Inspired on jMock (thanks jMock guys!!!) - */ -public class SearchingClassLoader extends ClassLoader { - - //TODO SF potentially not needed - - private final ClassLoader nextToSearch; - - public SearchingClassLoader(ClassLoader parent, ClassLoader nextToSearch) { - super(parent); - this.nextToSearch = nextToSearch; - } - - public static ClassLoader combineLoadersOf(Class<?>... classes) { - return combineLoadersOf(classes[0], classes); - } - - private static ClassLoader combineLoadersOf(Class<?> first, Class<?>... others) { - List<ClassLoader> loaders = new ArrayList<ClassLoader>(); - - addIfNewElement(loaders, first.getClassLoader()); - for (Class<?> c : others) { - addIfNewElement(loaders, c.getClassLoader()); - } - - // To support Eclipse Plug-in tests. - // In an Eclipse plug-in, we will not be on the system class loader - // but in the class loader of the plug-in. - // - // Note: I've been unable to reproduce the error in the test suite. - addIfNewElement(loaders, SearchingClassLoader.class.getClassLoader()); - - // To support the Maven Surefire plugin. - // Note: I've been unable to reproduce the error in the test suite. - addIfNewElement(loaders, currentThread().getContextClassLoader()); - - //Had to comment that out because it didn't work with in-container Spring tests - //addIfNewElement(loaders, ClassLoader.getSystemClassLoader()); - - return combine(loaders); - } - - private static ClassLoader combine(List<ClassLoader> parentLoaders) { - ClassLoader loader = parentLoaders.get(parentLoaders.size()-1); - - for (int i = parentLoaders.size()-2; i >= 0; i--) { - loader = new SearchingClassLoader(parentLoaders.get(i), loader); - } - - return loader; - } - - private static void addIfNewElement(List<ClassLoader> loaders, ClassLoader c) { - if (c != null && !loaders.contains(c)) { - loaders.add(c); - } - } - - @Override - protected Class<?> findClass(String name) throws ClassNotFoundException { - if (nextToSearch != null) { - return nextToSearch.loadClass(name); - } else { - return super.findClass(name); // will throw ClassNotFoundException - } - } -} \ No newline at end of file

train

train

bric3

train

mockito/mockito/598_599

mockito/mockito

mockito/mockito/598

mockito/mockito/599

434579ef4b68311fc58bae28d6dfcae52a26350a

6da1e65a4ea014b1594efc90ab0841b254efee2a

Generated release notes contain unsorted and duplicate committers

Generated release notes contain unsorted and duplicate committers

diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Commit.java b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Commit.java index ebe7913890..c6d9218bee 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Commit.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Commit.java @@ -7,12 +7,12 @@ public interface Commit { /** * Author identifier. For git it would be 'email' */ - String getAuthorId(); + String getAuthorEmail(); /** * Author display name. For git it would be 'author' */ - String getAuthor(); + String getAuthorName(); /** * Commit message diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Contribution.java b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Contribution.java index b26290659b..5f83408445 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Contribution.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/Contribution.java @@ -7,28 +7,31 @@ class Contribution implements Comparable<Contribution> { //email identifies the contributor, author alias not necessarily - final String authorId; - final String author; + final String authorEmail; + final String authorName; final List<Commit> commits = new LinkedList<Commit>(); Contribution(Commit commit) { - authorId = commit.getAuthorId(); - author = commit.getAuthor(); + authorEmail = commit.getAuthorEmail(); + authorName = commit.getAuthorName(); commits.add(commit); } Contribution add(Commit commit) { - assert authorId.equals(commit.getAuthorId()); commits.add(commit); return this; } public String toText() { - return commits.size() + ": " + author; + return commits.size() + ": " + authorName; } public int compareTo(Contribution other) { - return Integer.valueOf(other.getCommits().size()).compareTo(commits.size()); + int byCommitCount = Integer.valueOf(other.getCommits().size()).compareTo(commits.size()); + if (byCommitCount != 0) { + return byCommitCount; + } + return this.authorName.toUpperCase().compareTo(other.authorName.toUpperCase()); } public Collection<Commit> getCommits() { diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/DefaultContributionSet.java b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/DefaultContributionSet.java index 65d27c33c0..d0c31fd452 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/DefaultContributionSet.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/DefaultContributionSet.java @@ -5,7 +5,9 @@ import java.util.*; class DefaultContributionSet implements ContributionSet { - private final Map<String, Contribution> contributions = new HashMap<String, Contribution>(); + + private final List<Contribution> contributions = new LinkedList<Contribution>(); + private final Collection<Commit> commits = new LinkedList<Commit>(); private final Predicate<Commit> ignoreCommit; private final Set<String> tickets = new LinkedHashSet<String>(); @@ -20,12 +22,29 @@ void add(Commit commit) { } commits.add(commit); tickets.addAll(commit.getTickets()); - Contribution c = contributions.get(commit.getAuthorId()); - if (c == null) { - contributions.put(commit.getAuthorId(), new Contribution(commit)); + + Contribution existing = findContribution(commit, contributions); + if (existing != null) { + existing.add(commit); } else { - c.add(commit); + contributions.add(new Contribution(commit)); + } + } + + private static Contribution findContribution(Commit commit, Iterable<Contribution> contributions) { + for (Contribution c : contributions) { + //From Git Log we don't know the GitHub user ID, only the email and name. + //Sometimes contributors have different email addresses while the same name + //This leads to awkward looking release notes, where same author is shown multiple times + //We consider the contribution to be the same if any of: email or name is the same + // + //This approach comes with a caveat. What if the user have same author name, different email and indeed it is a different user? + // This scenario is not handled well but it is unlikely and we consider it a trade-off + if (c.authorEmail.equals(commit.getAuthorEmail()) || c.authorName.equals(commit.getAuthorName())) { + return c; + } } + return null; } public Collection<Commit> getAllCommits() { @@ -40,23 +59,11 @@ public String toText() { StringBuilder sb = new StringBuilder("* Authors: ").append(contributions.size()) .append("\n* Commits: ").append(commits.size()); - for (Map.Entry<String, Contribution> entry : sortByValue(contributions)) { - Contribution c = entry.getValue(); + Collections.sort(contributions); + for (Contribution c : contributions) { sb.append("\n * ").append(c.toText()); } return sb.toString(); } - - public static <K, V extends Comparable<V>> List<Map.Entry<K, V>> sortByValue(Map<K, V> map) { - List<Map.Entry<K, V>> entries = new ArrayList<Map.Entry<K, V>>(map.entrySet()); - Collections.sort(entries, new ByValue<K, V>()); - return entries; - } - - private static class ByValue<K, V extends Comparable<V>> implements Comparator<Map.Entry<K, V>> { - public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) { - return o1.getValue().compareTo(o2.getValue()); - } - } } \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitCommit.java b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitCommit.java index 5c4f4973c2..f1dfc91669 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitCommit.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitCommit.java @@ -17,11 +17,11 @@ public GitCommit(String email, String author, String message) { this.tickets = TicketParser.parseTickets(message); } - public String getAuthorId() { + public String getAuthorEmail() { return email; } - public String getAuthor() { + public String getAuthorName() { return author; } diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitContributionsProvider.java b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitContributionsProvider.java index 93d5d78901..8e5ba8f050 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitContributionsProvider.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/vcs/GitContributionsProvider.java @@ -32,6 +32,7 @@ public ContributionSet getContributionsBetween(String fromRev, String toRev) { String email = entryParts[0].trim(); String author = entryParts[1].trim(); String message = entryParts[2].trim(); + LOG.info("Loaded commit - email: {}, author: {}, message (trimmed): {}", email, author, message.replaceAll("\n.*", "")); contributions.add(new GitCommit(email, author, message)); } }

diff --git a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/ContributionTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/ContributionTest.groovy index 37d0bd0931..152f1ede5f 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/ContributionTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/ContributionTest.groovy @@ -8,8 +8,8 @@ class ContributionTest extends Specification { def c = new Contribution(new GitCommit("a@b", "lad", "m1")) expect: - c.author == "lad" - c.authorId == "a@b" + c.authorName == "lad" + c.authorEmail == "a@b" c.toText() == "1: lad" when: c.add(new GitCommit("a@b", "lad", "m2")) @@ -32,6 +32,16 @@ class ContributionTest extends Specification { set as List == [c3, c2, c1] } + def "sorted by commits and uppercase name"() { + def d = new Contribution(new GitCommit("d", "d", "")).add(new GitCommit("d", "d", "")) + def c = new Contribution(new GitCommit("c", "c", "")) + def b = new Contribution(new GitCommit("B", "B", "")) + def a = new Contribution(new GitCommit("a", "a", "")) + + expect: + new TreeSet([d, c, b, a]) as List == [d, a, b, c] + } + def "has String representation"() { def c = new GitCommit("john.doe@gmail.com", "John Doe", "some message") expect: diff --git a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/DefaultContributionSetTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/DefaultContributionSetTest.groovy index bac80a590a..26d73c5220 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/DefaultContributionSetTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/DefaultContributionSetTest.groovy @@ -49,6 +49,35 @@ class DefaultContributionSetTest extends Specification { then: c.size() == 1 c[0].message == "good one" - c[0].author == "A" + c[0].authorName == "A" + } + + def "contributions by same author with different email"() { + contributions.add(new GitCommit("john@x", "john", "")) + contributions.add(new GitCommit("john@x", "john", "")) + contributions.add(new GitCommit("john@y", "john", "")) //same person, different email + contributions.add(new GitCommit("x@y", "x", "")) //different person + + expect: + contributions.toText() == """* Authors: 2 +* Commits: 4 + * 3: john + * 1: x""" + } + + def "contributions sorted by name if number of commits the same"() { + contributions.add(new GitCommit("d@d", "d", "")) + contributions.add(new GitCommit("d@d", "d", "")) + contributions.add(new GitCommit("c@c", "c", "")) + contributions.add(new GitCommit("B@B", "B", "")) + contributions.add(new GitCommit("a@a", "a", "")) + + expect: + contributions.toText() == """* Authors: 4 +* Commits: 5 + * 2: d + * 1: a + * 1: B + * 1: c""" } } diff --git a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/GitContributionsProviderTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/GitContributionsProviderTest.groovy index b074506aea..8027e9344b 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/GitContributionsProviderTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/notes/vcs/GitContributionsProviderTest.groovy @@ -30,8 +30,8 @@ john@doe@@info@@John R. Doe@@info@@dummy commit and: def commits = c.allCommits as List - commits[0].author == "Szczepan Faber" - commits[0].authorId == "szczepiq@gmail.com" + commits[0].authorName == "Szczepan Faber" + commits[0].authorEmail == "szczepiq@gmail.com" commits[0].message == "Tidy-up in buildSrc\nnext line" }

val

train

mockitoguy

train

mockito/mockito/603_604

mockito/mockito

mockito/mockito/603

mockito/mockito/604

d32a754abd9bb457cd3146d480a42b76e3fcb179

b669b4fa790171149b8383cc8f9c55cec32de934

Release notes group improvements by labels

For clearer release notes overlook we should group improvements by labels. This was originally contributed by @szpak, then lost during the early days of continuous integration, now it's back and it will rock!!!

diff --git a/buildSrc/src/main/groovy/org/mockito/release/gradle/notes/ReleaseNotesExtension.groovy b/buildSrc/src/main/groovy/org/mockito/release/gradle/notes/ReleaseNotesExtension.groovy index 305609be99..05a6c47aaf 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/gradle/notes/ReleaseNotesExtension.groovy +++ b/buildSrc/src/main/groovy/org/mockito/release/gradle/notes/ReleaseNotesExtension.groovy @@ -17,6 +17,9 @@ class ReleaseNotesExtension { private final File workDir; private final String version; + //TODO SF document the behavior + Map labels = new LinkedHashMap<String, String>() + ReleaseNotesExtension(File workDir, String version) { this.workDir = workDir this.version = version @@ -49,7 +52,7 @@ class ReleaseNotesExtension { def prev = "v" + getPreviousVersion() def current = "HEAD" LOG.lifecycle("Building notes for revisions: {} -> {}", prev, current) - def newContent = builder.buildNotes(version, prev, current) + def newContent = builder.buildNotes(version, prev, current, labels) newContent } diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/GitNotesBuilder.java b/buildSrc/src/main/groovy/org/mockito/release/notes/GitNotesBuilder.java index 071e550e35..352c603cab 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/GitNotesBuilder.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/GitNotesBuilder.java @@ -2,8 +2,8 @@ import org.mockito.release.exec.Exec; import org.mockito.release.notes.improvements.ImprovementSet; -import org.mockito.release.notes.improvements.ImprovementsProvider; import org.mockito.release.notes.improvements.Improvements; +import org.mockito.release.notes.improvements.ImprovementsProvider; import org.mockito.release.notes.vcs.ContributionSet; import org.mockito.release.notes.vcs.ContributionsProvider; import org.mockito.release.notes.vcs.Vcs; @@ -12,6 +12,7 @@ import java.io.File; import java.util.Date; +import java.util.Map; class GitNotesBuilder implements NotesBuilder { @@ -29,14 +30,14 @@ class GitNotesBuilder implements NotesBuilder { this.authTokenEnvVar = authTokenEnvVar; } - public String buildNotes(String version, String fromRevision, String toRevision) { + public String buildNotes(String version, String fromRevision, String toRevision, Map<String, String> labels) { LOG.info("Getting release notes between {} and {}", fromRevision, toRevision); ContributionsProvider contributionsProvider = Vcs.getGitProvider(Exec.getProcessRunner(workDir)); ContributionSet contributions = contributionsProvider.getContributionsBetween(fromRevision, toRevision); ImprovementsProvider improvementsProvider = Improvements.getGitHubProvider(authTokenEnvVar); - ImprovementSet improvements = improvementsProvider.getImprovements(contributions); + ImprovementSet improvements = improvementsProvider.getImprovements(contributions, labels); return new NotesPrinter().printNotes(version, new Date(), contributions, improvements); } diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/NotesBuilder.java b/buildSrc/src/main/groovy/org/mockito/release/notes/NotesBuilder.java index 7c3cee6c4d..10da616846 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/NotesBuilder.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/NotesBuilder.java @@ -1,5 +1,7 @@ package org.mockito.release.notes; +import java.util.Map; + /** * Builds the release notes text */ @@ -11,6 +13,8 @@ public interface NotesBuilder { * @param version the version of the release we're building the notes * @param fromRevision valid git revision (can be tag name or HEAD) * @param toRevision valid git revision (can be tag name or HEAD) + * @param labels GitHub labels to caption mapping + * TODO SF the labels better, currently they are coupled way too much with more generic interfaces, vcs agnostic */ - String buildNotes(String version, String fromRevision, String toRevision); + String buildNotes(String version, String fromRevision, String toRevision, Map<String, String> labels); } \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/DefaultImprovements.java b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/DefaultImprovements.java index bf7d55520a..dc605aeb68 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/DefaultImprovements.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/DefaultImprovements.java @@ -1,29 +1,73 @@ package org.mockito.release.notes.improvements; -import java.util.LinkedList; -import java.util.List; +import org.mockito.release.util.MultiMap; +import java.util.*; + +//TODO SF split the formatting from the data structure class DefaultImprovements implements ImprovementSet { - private final List<Improvement> improvements = new LinkedList<Improvement>(); + final List<Improvement> improvements = new LinkedList<Improvement>(); + private final Map<String, String> labels; + + public DefaultImprovements(Map<String, String> labels) { + this.labels = labels; + } public String toText() { if (improvements.isEmpty()) { - //TODO SF we should break the build if there are no notable improvements yet the binaries have changed return "* No notable improvements. See the commits for detailed changes."; } StringBuilder sb = new StringBuilder("* Improvements: ").append(improvements.size()); - for (Improvement i : improvements) { - sb.append("\n * ").append(i.toText()); + MultiMap<String, Improvement> byLabel = new MultiMap<String, Improvement>(); + Set<Improvement> remainingImprovements = new LinkedHashSet<Improvement>(improvements); + + //Step 1, find improvements that match input labels + //Iterate label first because the input labels determine the order + for (String label : labels.keySet()) { + for (Improvement i : improvements) { + if (i.labels.contains(label) && remainingImprovements.contains(i)) { + remainingImprovements.remove(i); + byLabel.put(label, i); + } + } + } + + //Step 2, print out the improvements that match input labels + for (String label : byLabel.keySet()) { + String labelCaption = labels.get(label); + Collection<Improvement> labelImprovements = byLabel.get(label); + sb.append("\n * ").append(labelCaption).append(": ").append(labelImprovements.size()); + for (Improvement i : labelImprovements) { + sb.append("\n * ").append(i.toText()); + } + } + + //Step 3, print out remaining changes + if (!remainingImprovements.isEmpty()) { + String indent; + //We want clean view depending if there are labelled improvements or not + if (byLabel.size() > 0) { + indent = " "; + sb.append("\n * Remaining changes: ").append(remainingImprovements.size()); + } else { + indent = ""; + } + + for (Improvement i : remainingImprovements) { + sb.append("\n").append(indent).append(" * ").append(i.toText()); + } } return sb.toString(); } - public void add(Improvement improvement) { + public DefaultImprovements add(Improvement improvement) { improvements.add(improvement); + return this; } - public void addAll(List<Improvement> improvements) { + public DefaultImprovements addAll(List<Improvement> improvements) { this.improvements.addAll(improvements); + return this; } } diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubImprovementsProvider.java b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubImprovementsProvider.java index c81e2c70ff..8258f6964a 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubImprovementsProvider.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubImprovementsProvider.java @@ -4,6 +4,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.util.Map; + class GitHubImprovementsProvider implements ImprovementsProvider { private static final Logger LOGGER = LoggerFactory.getLogger(GitHubImprovementsProvider.class); @@ -13,9 +15,9 @@ public GitHubImprovementsProvider(String authToken) { this.authToken = authToken; } - public ImprovementSet getImprovements(ContributionSet contributions) { + public ImprovementSet getImprovements(ContributionSet contributions, Map<String, String> labels) { LOGGER.info("Parsing {} commits with {} tickets", contributions.getAllCommits().size(), contributions.getAllTickets().size()); - DefaultImprovements out = new DefaultImprovements(); + DefaultImprovements out = new DefaultImprovements(labels); new GitHubTicketFetcher().fetchTickets(authToken, contributions.getAllTickets(), out); return out; } diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcher.java b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcher.java index f3e3396f92..fcce09f99a 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcher.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcher.java @@ -1,22 +1,18 @@ package org.mockito.release.notes.improvements; -import java.io.IOException; -import java.io.InputStream; -import java.net.URL; -import java.net.URLConnection; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.PriorityQueue; -import java.util.Queue; +import org.json.simple.JSONArray; import org.json.simple.JSONObject; import org.json.simple.JSONValue; import org.mockito.release.notes.util.IOUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.net.URLConnection; +import java.util.*; + class GitHubTicketFetcher { private static final Logger LOG = LoggerFactory.getLogger(GitHubTicketFetcher.class); @@ -70,6 +66,7 @@ private Queue<Long> queuedTicketNumbers(Collection<String> ticketIds) { return longs; } + //TODO SF we should be able to unit test the code that parsers JSONObjects private List<Improvement> wantedImprovements(Collection<Long> tickets, List<JSONObject> issues) { if(tickets.isEmpty()) { return Collections.emptyList(); @@ -81,7 +78,8 @@ private List<Improvement> wantedImprovements(Collection<Long> tickets, List<JSON if (tickets.remove(id)) { String issueUrl = (String) issue.get("html_url"); String title = (String) issue.get("title"); - pagedImprovements.add(new Improvement(id, title, issueUrl, new HashSet<String>())); + Collection<String> labels = extractLabels(issue); + pagedImprovements.add(new Improvement(id, title, issueUrl, labels)); if (tickets.isEmpty()) { return pagedImprovements; @@ -91,6 +89,15 @@ private List<Improvement> wantedImprovements(Collection<Long> tickets, List<JSON return pagedImprovements; } + private static Collection<String> extractLabels(JSONObject issue) { + Set<String> out = new HashSet<String>(); + JSONArray labels = (JSONArray) issue.get("labels"); + for (Object o : labels.toArray()) { + JSONObject label = (JSONObject) o; + out.add((String) label.get("name")); + } + return out; + } private static class GitHubIssues { public static final String RELATIVE_LINK_NOT_FOUND = "none"; diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/Improvement.java b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/Improvement.java index 4df57c3ad2..b5d7329cb5 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/Improvement.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/Improvement.java @@ -4,10 +4,10 @@ class Improvement { - private final long id; + private final long id; //TODO SF String private final String title; private final String url; - private final Collection<String> labels; + final Collection<String> labels; public Improvement(long id, String title, String url, Collection<String> labels) { this.id = id; diff --git a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/ImprovementsProvider.java b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/ImprovementsProvider.java index ca459628a1..f6e0c73529 100644 --- a/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/ImprovementsProvider.java +++ b/buildSrc/src/main/groovy/org/mockito/release/notes/improvements/ImprovementsProvider.java @@ -2,7 +2,9 @@ import org.mockito.release.notes.vcs.ContributionSet; +import java.util.Map; + public interface ImprovementsProvider { - ImprovementSet getImprovements(ContributionSet contributions); + ImprovementSet getImprovements(ContributionSet contributions, Map<String, String> labels); } diff --git a/buildSrc/src/main/groovy/org/mockito/release/util/MultiMap.java b/buildSrc/src/main/groovy/org/mockito/release/util/MultiMap.java new file mode 100644 index 0000000000..59b54e3169 --- /dev/null +++ b/buildSrc/src/main/groovy/org/mockito/release/util/MultiMap.java @@ -0,0 +1,35 @@ +package org.mockito.release.util; + +import java.util.*; + +/** + * Basic multi-map that contains multiple values per key + */ +public class MultiMap<K, V> { + + private final Map<K, Collection<V>> data = new LinkedHashMap<K, Collection<V>>(); + + /** + * If the key does not exist, null is returned + */ + public Collection<V> get(K key) { + return data.get(key); + } + + public void put(K key, V value) { + Collection<V> elements = get(key); + if (elements == null) { + elements = new LinkedHashSet<V>(); + } + elements.add(value); + data.put(key, elements); + } + + public Set<K> keySet() { + return data.keySet(); + } + + public int size() { + return data.size(); + } +} diff --git a/gradle/release.gradle b/gradle/release.gradle index 5b0c5e9701..c2913179f0 100644 --- a/gradle/release.gradle +++ b/gradle/release.gradle @@ -25,7 +25,19 @@ apply plugin: 'release-notes' apply plugin: 'release' notes { - notesFile = project.file("doc/release-notes/official.md") + notesFile = file("doc/release-notes/official.md") + //label captions, in order of importance - this is the order they will appear in the release notes + labels = [ + '1.* incompatible': 'Incompatible changes with previous major version (v1.x)', + 'java-9': "Java 9 support", + 'java-8': "Java 8 support", + 'new feature': "New features", + 'BDD': 'Behavior-Driven Development support', + 'bug': "Bugfixes", + 'enhancement': "Enhancements", + 'android': "Android support", + 'docs': 'Documentation' + ] } def dryRun = project.hasProperty('dryRun')

diff --git a/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/DefaultImprovementsTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/DefaultImprovementsTest.groovy index 5557bb3610..410a96cfe0 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/DefaultImprovementsTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/DefaultImprovementsTest.groovy @@ -1,28 +1,69 @@ package org.mockito.release.notes.improvements import spock.lang.Specification -import spock.lang.Subject class DefaultImprovementsTest extends Specification { - @Subject improvements = new DefaultImprovements() - def "empty improvements"() { expect: - improvements.toText() == "* No notable improvements. See the commits for detailed changes." + new DefaultImprovements([:]).toText() == "* No notable improvements. See the commits for detailed changes." } - def "with improvements"() { - improvements.add(new Improvement(100, "Fix bug x", "http://issues/100", ["bug"])) - improvements.add(new Improvement(122, "Javadoc update", "http://url/122", [])) - improvements.add(new Improvement(125, "Some enh", "http://issues/125", ["enhancement", "custom"])) - improvements.add(new Improvement(126, "Some other enh", "http://issues/126", ["enhancement"])) + def "set of improvements in order"() { + def is = new DefaultImprovements([bug: "Bugfixes", enhancement: "Enhancements"]) + .add(new Improvement(100, "Fix bug x", "http://issues/100", ["bug"])) + .add(new Improvement(122, "Javadoc update", "http://url/122", [])) + .add(new Improvement(125, "Some enh", "http://issues/125", ["java-8", "enhancement", "bug"])) + .add(new Improvement(126, "Some other enh", "http://issues/126", ["enhancement"])) + .add(new Improvement(130, "Refactoring", "http://issues/130", ["java-8", "refactoring"])) expect: - improvements.toText() == """* Improvements: 4 - * Fix bug x [(#100)](http://issues/100) - * Javadoc update [(#122)](http://url/122) - * Some enh [(#125)](http://issues/125) - * Some other enh [(#126)](http://issues/126)""" + is.toText() == """* Improvements: 5 + * Bugfixes: 2 + * Fix bug x [(#100)](http://issues/100) + * Some enh [(#125)](http://issues/125) + * Enhancements: 1 + * Some other enh [(#126)](http://issues/126) + * Remaining changes: 2 + * Javadoc update [(#122)](http://url/122) + * Refactoring [(#130)](http://issues/130)""" + } + + def "no matching labels"() { + given: + def is = new DefaultImprovements([bug: "Bugfixes"]) + .add(new Improvement(10, "Issue 10", "10", [])) + + expect: "the formatting is simplified" + is.toText() == """* Improvements: 1 + * Issue 10 [(#10)](10)""" + } + + def "no duplicated improvements"() { + given: + def is = new DefaultImprovements([bug: "Bugfixes", refactoring: "Refactorings"]) + .add(new Improvement(10, "Issue 10", "10", ["bug", "refactoring"])) + .add(new Improvement(11, "Issue 11", "11", ["refactoring", "bug"])) + + expect: "no duplication even though labels are overused" + is.toText() == """* Improvements: 2 + * Bugfixes: 2 + * Issue 10 [(#10)](10) + * Issue 11 [(#11)](11)""" + } + + def "the order of labels is determined"() { + given: + //input label captions determine the order of labels: + def labels = [p0: "Priority 0", p1: "Priority 1"] + def imp1 = new Improvement(10, "Issue 10", "10", ["p0"]) + def imp2 = new Improvement(11, "Issue 11", "11", ["p1"]) + + when: + def improvements = new DefaultImprovements(labels).addAll([imp1, imp2]).toText() + def reordered = new DefaultImprovements(labels).addAll([imp2, imp1]).toText() + + then: "The order of labels is determined" + improvements == reordered } } diff --git a/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcherTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcherTest.groovy index 9021379993..3a41b136bb 100644 --- a/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcherTest.groovy +++ b/buildSrc/src/test/groovy/org/mockito/release/notes/improvements/GitHubTicketFetcherTest.groovy @@ -10,12 +10,15 @@ class GitHubTicketFetcherTest extends Specification { @Subject fetcher = new GitHubTicketFetcher() - //TODO SF tidy up this and the test subject + //This is an integration test + //It's not ideal but it gives us a good smoke test + //So far it is not problematic to maintain :) def "fetches improvements from GitHub"() { - def impr = new DefaultImprovements() + def impr = new DefaultImprovements([:]) def readOnlyToken = "a0a4c0f41c200f7c653323014d6a72a127764e17" when: fetcher.fetchTickets(readOnlyToken, ['109', '108', '99999', '112'], impr) then: + impr.improvements.get(0).labels == ["enhancement"] as Set impr.toText() == """* Improvements: 2 * Allow instances of other classes in AdditionalAnswers.delegatesTo [(#112)](https://github.com/mockito/mockito/issues/112) * Clarify Spy vs Mock CALLS_REAL_METHODS [(#108)](https://github.com/mockito/mockito/issues/108)""" diff --git a/buildSrc/src/test/groovy/org/mockito/release/util/MultiMapTest.groovy b/buildSrc/src/test/groovy/org/mockito/release/util/MultiMapTest.groovy new file mode 100644 index 0000000000..5a7b03fe48 --- /dev/null +++ b/buildSrc/src/test/groovy/org/mockito/release/util/MultiMapTest.groovy @@ -0,0 +1,30 @@ +package org.mockito.release.util + +import spock.lang.Specification + +class MultiMapTest extends Specification { + + def "empty multi map"() { + def map = new MultiMap<String, String>() + + expect: + map.size() == 0 + map.keySet().empty + } + + def "contains multiple values per key"() { + def map = new MultiMap<String, String>(); + map.put("1", "x") + map.put("1", "y") + map.put("2", "z") + + expect: + map.get("1") == ["x", "y"] as Set + map.get("2") == ["z"] as Set + map.size() == 2 + map.keySet() == ["1", "2"] as Set + + //questionable but I decided to keep the impl simple: + map.get("3") == null + } +}

val

train

mockitoguy

train

mockito/mockito/497_615

mockito/mockito

mockito/mockito/497

mockito/mockito/615

b669b4fa790171149b8383cc8f9c55cec32de934

aef4dad12079a919d3813a5c690c7608032d5740

DEEP_STUBS tries to mock final class

``` <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>1.10.19</version> <scope>test</scope> </dependency> ``` ``` $ java -version java version "1.8.0_91" Java(TM) SE Runtime Environment (build 1.8.0_91-b14) Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode) ``` ``` import static org.junit.Assert.assertNull; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.mock; import org.junit.Test; public class MockitoBug { public interface Supplier<T> { public T get(); } public interface StringSupplier extends Supplier<String> {} public interface InheritedSupplier extends StringSupplier {} @Test public void deepStubs() { StringSupplier mock = mock(StringSupplier.class, RETURNS_DEEP_STUBS); String s = mock.get(); assertNull(s); } @Test public void inheritedDeepStubs() { InheritedSupplier mock = mock(InheritedSupplier.class, RETURNS_DEEP_STUBS); String s = mock.get(); // ClassCastException assertNull(s); } } ``` ``` java.lang.ClassCastException: org.mockito.internal.creation.cglib.ClassImposterizer$ClassWithSuperclassToWorkAroundCglibBug$$EnhancerByMockitoWithCGLIB$$322ebf6e cannot be cast to java.lang.String at MockitoBug.inheritedDeepStubs(MockitoBug.java:26) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:678) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192) ``` I expect the behavior for `StringSupplier` and `InheritedSupplier` to be the same: return `null` for `get`. However, `InheritedSupplier` tries to return a mock `Object` for `get`.

diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java index eedfebd76b..8efd384992 100644 --- a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java +++ b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java @@ -251,7 +251,7 @@ public GenericMetadataSupport resolveGenericReturnType(Method method) { private GenericMetadataSupport resolveGenericType(Type type, Method method) { if (type instanceof Class) { - return new NotGenericReturnTypeSupport(type); + return new NotGenericReturnTypeSupport(this, type); } if (type instanceof ParameterizedType) { return new ParameterizedReturnType(this, method.getTypeParameters(), (ParameterizedType) type); @@ -494,8 +494,11 @@ public Class<?> rawType() { private static class NotGenericReturnTypeSupport extends GenericMetadataSupport { private final Class<?> returnType; - public NotGenericReturnTypeSupport(Type genericReturnType) { + public NotGenericReturnTypeSupport(GenericMetadataSupport source, Type genericReturnType) { returnType = (Class<?>) genericReturnType; + this.contextualActualTypeParameters = source.contextualActualTypeParameters; + + registerAllTypeVariables(returnType); } @Override

diff --git a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java b/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java index fba55af035..e20f36c29d 100644 --- a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java +++ b/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java @@ -14,6 +14,7 @@ import java.io.ByteArrayOutputStream; import java.io.OutputStream; import java.net.Socket; +import java.util.List; import java.util.Locale; import static junit.framework.TestCase.*; @@ -64,7 +65,15 @@ public String getLongName() { } static final class FinalClass {} - + + interface First { + Second getSecond(); + + String getString(); + } + + interface Second extends List<String> {} + @Test public void myTest() throws Exception { SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS); @@ -310,4 +319,11 @@ public void shouldFailGracefullyWhenClassIsFinal() throws Exception { //then assertEquals(value, person.getFinalClass()); } + + @Test + public void deep_stub_does_not_try_to_mock_generic_final_classes() { + First first = mock(First.class, RETURNS_DEEP_STUBS); + assertNull(first.getString()); + assertNull(first.getSecond().get(0)); + } }

val

train

JeffFaer

train

mockito/mockito/625_626

mockito/mockito

mockito/mockito/625

mockito/mockito/626

310a0f3d7c004523a62c85f65cf9047acd855a8b

732a3208cc853b6c1ccd96a2a309903c85bd2059

Tweak javadoc

- some feature indicates 2.1.0 in javadoc but it should 3.0.0

diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java index 5d37aacbfa..2c20525057 100644 --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java @@ -13,7 +13,7 @@ import java.lang.reflect.Array; /** - * It's likely this implementation will be used by default by every Mockito 2.1.0 mock. + * It's likely this implementation will be used by default by every Mockito 3.0.0 mock. * <p> * Currently <b>used only</b> by {@link Mockito#RETURNS_SMART_NULLS} * <p>

train

train

mockitoguy

train

mockito/mockito/594_627

mockito/mockito

mockito/mockito/594

mockito/mockito/627

9b08c0834fe5cfcab1f188c3a5511e08c0268904

15cf2312df360f11282f3dec7915d4648e4ffb21

Make the build script aware of the release branch

Releasing from the `master` branch has advantages developer wise, however when users that are hit by a bug and that `master` has significantly changed we cannot propose a stable enough release (example 2.0 betas releases, even the 1.10.x series had some instabilities API wise). In order to enable the team and contributors in general to fix issues while still allowing bigger work on the next version I propose the following change in branch and release _process_. 1. Branch out to `release/2.x` 1. Release `2.0.0` 2. Patch issue 3. Release `2.0.1` 4. Additional work on 2.1 5. Release `2.1.0` 6. ... 7. Forget about `2.1.x` 8. Critical fixes only get released 2. Upgrade `master` to `3.0.0-beta-<build number>` 1. Start mockito `3.0.0` progress there (like java 8 only, drop APIs) Also with recent change in the build script we could now release and check the release version with the branch. See - https://github.com/mockito/mockito/commit/b6a402f16e9222605638efe9b57eccc80a197f9e#diff-33cf41d9669aaef72ca19c641dc57d47R68 - https://github.com/mockito/mockito/issues/586#issuecomment-242076979 - https://github.com/mockito/mockito/pull/483#issuecomment-231323266

diff --git a/doc/release-notes/official.md b/doc/release-notes/official.md index ce90a6ede3..5058739575 100644 --- a/doc/release-notes/official.md +++ b/doc/release-notes/official.md @@ -1,3 +1,26 @@ +### 2.1.0-beta.125 (2016-09-08 03:42 UTC) + +* Authors: 4 +* Commits: 24 + * 15: Szczepan Faber + * 5: Continuous Delivery Drone + * 3: Brice Dutheil + * 1: Divyansh Gupta +* Improvements: 3 + * Documentation: 1 + * Update documentation links in travis config comments [(#558)](https://github.com/mockito/mockito/pull/558) + * Remaining changes: 2 + * Ensured javadocs are correct [(#626)](https://github.com/mockito/mockito/pull/626) + * Tweak javadoc [(#625)](https://github.com/mockito/mockito/issues/625) + +### 2.1.0-beta.124 (2016-09-07 04:36 UTC) + +* Authors: 2 +* Commits: 12 + * 11: Szczepan Faber + * 1: Continuous Delivery Drone +* No notable improvements. See the commits for detailed changes. + ### 2.1.0-beta.123 (2016-09-06 15:01 UTC) * Authors: 4 diff --git a/gradle/release.gradle b/gradle/release.gradle index 78ed82995b..d8005a59a8 100644 --- a/gradle/release.gradle +++ b/gradle/release.gradle @@ -83,8 +83,8 @@ task("releaseNeeded") { def skippedByCommitMessage = commitMessage?.contains(skipReleaseCommitMessage) def customVersion = (commitMessage =~ customReleaseVersionPattern) ext.needed = dryRun || customVersion.matches() || (pr == 'false' && isReleasableBranch(branch) && !comparePublications.publicationsEqual && skipEnvVariable != 'true' && !skippedByCommitMessage) - logger.lifecycle("Release needed: {}, branch: {}, pull request: {}, dry run: {}, publications equal: {}, skip env variable: {}, skipped by message: {}, customVersion: {}.", - needed, branch, pr, dryRun, comparePublications.publicationsEqual, skipEnvVariable, skippedByCommitMessage, customVersion.matches()) + logger.lifecycle("Release needed: {}, releasable branch: {}, pull request: {}, dry run: {}, publications equal: {}, skip env variable: {}, skipped by message: {}, customVersion: {}.", + needed, isReleasableBranch(branch), pr, dryRun, comparePublications.publicationsEqual, skipEnvVariable, skippedByCommitMessage, customVersion.matches()) } } @@ -94,7 +94,7 @@ bintrayUpload { doFirst { logger.lifecycle troubleshootingInfo if (dryRun) { - logger.lifecycle "Dry-running the release" + logger.lifecycle "Dry-running the release! Although 'bintrayUpload' is executed, it won't upload any binaries ('bintrayUpload.dryRun' property is set)." } } } @@ -118,7 +118,8 @@ releaseSteps { step("ensure good chunk of recent commits is pulled for release notes automation") { //Travis default clone is pretty shallow - run "git", "pull", "--depth", "500" + //Loading extra 1K commits (1.x -> 2.x had ~700 commits) + run "git", "pull", "--depth", "1000" } def gitAuthor @@ -128,7 +129,8 @@ releaseSteps { step("commit updated javadoc into gh-pages branch") { commitUpdatedJavadoc(buildInfo) } /* - Now we'll start operating on master. This introduces a problem - someone might have pushed changes *after* release process has started + Now we'll start operating on branch that we want to release. + This introduces a problem - someone might have pushed changes *after* release process has started What can happen: - bintrayUpload will fail saying that the version is already released - git push fails saying that the pull is needed @@ -136,7 +138,7 @@ releaseSteps { - see 'TROUBLESHOOTING' section at the top of this file */ - step("start operating on master") { run "git", "checkout", "master" } + step("start operating on $System.env.TRAVIS_BRANCH") { run "git", "checkout", System.env.TRAVIS_BRANCH } step("update release notes") { project.notes.updateReleaseNotes() } @@ -146,11 +148,11 @@ releaseSteps { step("create new version tag") { createTag(buildInfo, "v${currentVersion}".toString()) } .rollback { run "git", "tag", "-d", "v${currentVersion}".toString()} - step("commit incremented version on master") { commitIncrementedVersion(currentVersion, buildInfo, project.versionFile) } + step("commit incremented version on $System.env.TRAVIS_BRANCH") { commitIncrementedVersion(currentVersion, buildInfo, project.versionFile) } .rollback { run "git", "reset", "--hard", "HEAD^" } step("push changes to all involved branches") { - def pushCommandLine = ["git", "push", pushTarget, "master", "gh-pages", "v$currentVersion", "-q"] + def pushCommandLine = ["git", "push", pushTarget, System.env.TRAVIS_BRANCH, "gh-pages", "v$currentVersion", "-q"] if (dryRun) { pushCommandLine << '--dry-run' } diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index 35c06f5496..7baeea8cbe 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -73,14 +73,14 @@ * * <h3 id="0">0. <a class="meaningful_link" href="#verification">Migrating to 2.1.0</a></h3> * - * In order to continue improving Mockito and further improve the unit testing experience, we want you to upgrade to 2.0. + * In order to continue improving Mockito and further improve the unit testing experience, we want you to upgrade to 2.1.0! * Mockito follows <a href="http://semver.org/">semantic versioning</a> * and contains breaking changes only on major version upgrades. * In the lifecycle of a library, breaking changes are necessary * to roll out a set of brand new features that alter the existing behavior or even change the API. * We hope that you enjoy Mockito 2.1.0! * <p> - * List of breaking changes: + * List of breaking changes: TODO 596 * <ul> * <li>Mockito is decoupled from Hamcrest and custom matchers API has changed, see {@link ArgumentMatcher} * for rationale and migration guide.</li> @@ -1233,7 +1233,7 @@ public class Mockito extends ArgumentMatchers { * <code>ReturnsSmartNulls</code> first tries to return ordinary return values (see {@link ReturnsMoreEmptyValues}) * then it tries to return SmartNull. If the return type is final then plain null is returned. * <p> - * <code>ReturnsSmartNulls</code> will be probably the default return values strategy in Mockito 2.0. + * <code>ReturnsSmartNulls</code> will be probably the default return values strategy in Mockito 3.0.0 * <p> * Example: * <pre class="code"><code class="java"> diff --git a/version.properties b/version.properties index b0469d5032..0035f85bad 100644 --- a/version.properties +++ b/version.properties @@ -1,2 +1,2 @@ -version=2.1.0-beta.124 +version=2.1.0-beta.126 mockito.testng.version=1.0

test

train

bric3

train

mockito/mockito/596_628

mockito/mockito

mockito/mockito/596

mockito/mockito/628

15cf2312df360f11282f3dec7915d4648e4ffb21

bffa8f2c1dd9e9399e5268f8b7b4604e163c6e6f

Review and update documentation for 2.1.0

- [x] update the migration guide (should be easy, there are not many breaking changes, if we miss out we can update in following RC) - [x] add information about bytebuddy in the migration guide - [x] mention noteworthy 2.0.0 features (should be easy, there are not many, plus they are already documented :) - [x] fix odd TODO #593 - [x] review/update @since tags so that they say 2.1.0 Final steps I plan doing (by the EOD Wednesday, tomorrow), in order: - [x] Test release from release/test (in progress, see Travis CI) - [x] Merge/cherry-pick changes from "release/test" to master - [x] Move announcement / motivation text (https://github.com/mockito/mockito/blob/rc-release-notes-demo/doc/release-notes/official.md) to top of "What's new in Mockito 2" - [x] Final pass over "What's new in Mockito 2", make the information exciting and compelling, emphasize use cases, add missing links - [x] Update the 2.1.0 information in main Mockito class to link to "What's new in Mockito 2". See "TODO 596" in code - [x] Review Continuous Delivery [wiki page](https://github.com/mockito/mockito/wiki/Mockito-Continuous-Delivery) - [x] Update the announcement text (https://github.com/mockito/mockito/blob/rc-release-notes-demo/doc/release-notes/official.md) so that instead of tons of text it just links to "What's new in Mockito 2" - [x] Review release checklist (mostly done) - #620 - [x] Optional - Add some info in the 'What's new in Mockito 2' about the next steps for engs (e.g. ask to use the new version and give feedback).

diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java index 7baeea8cbe..92ca4cf668 100644 --- a/src/main/java/org/mockito/Mockito.java +++ b/src/main/java/org/mockito/Mockito.java @@ -30,7 +30,7 @@ * <h1>Contents</h1> * * <b> - * <a href="#0">0. Migrating to 2.1.0</a><br/> + * <a href="#0">0. Migrating to Mockito 2</a><br/> * <a href="#1">1. Let's verify some behaviour! </a><br/> * <a href="#2">2. How about some stubbing? </a><br/> * <a href="#3">3. Argument matchers </a><br/> @@ -68,36 +68,25 @@ * <a href="#35">35. (new) Custom verification failure message (Since 2.1.0)</a><br/> * <a href="#36">36. (new) Java 8 Lambda Matcher Support (Since 2.1.0)</a><br/> * <a href="#37">37. (new) Java 8 Custom Answer Support (Since 2.1.0)</a><br/> - * * </b> * - * <h3 id="0">0. <a class="meaningful_link" href="#verification">Migrating to 2.1.0</a></h3> + * <h3 id="0">0. <a class="meaningful_link" href="#mockito2">Migrating to Mockito 2</a></h3> * * In order to continue improving Mockito and further improve the unit testing experience, we want you to upgrade to 2.1.0! * Mockito follows <a href="http://semver.org/">semantic versioning</a> * and contains breaking changes only on major version upgrades. * In the lifecycle of a library, breaking changes are necessary * to roll out a set of brand new features that alter the existing behavior or even change the API. - * We hope that you enjoy Mockito 2.1.0! - * <p> - * List of breaking changes: TODO 596 - * <ul> - * <li>Mockito is decoupled from Hamcrest and custom matchers API has changed, see {@link ArgumentMatcher} - * for rationale and migration guide.</li> - * <li>Stubbing API has been tweaked to avoid unavoidable compilation warnings that appeared on JDK7+ platform. - * This will only affect binary compatibility, compilation compatibility remains unaffected.</li> - * </ul> + * For comprehensive information about the new release including incompatible changes, + * see '<a href="https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2">What's new in Mockito 2</a>' wiki page. + * We hope that you enjoy Mockito 2! + * + * <h3 id="1">1. <a class="meaningful_link" href="#verification">Let's verify some behaviour!</a></h3> * - * <p> * The following examples mock a List, because most people are familiar with the interface (such as the * <code>add()</code>, <code>get()</code>, <code>clear()</code> methods). <br> * In reality, please don't mock the List class. Use a real instance instead. * - * - * - * - * <h3 id="1">1. <a class="meaningful_link" href="#verification">Let's verify some behaviour!</a></h3> - * * <pre class="code"><code class="java"> * //Let's import Mockito statically so that the code looks clearer * import static org.mockito.Mockito.*;

train

train

mockitoguy

train

mockito/mockito/629_630

mockito/mockito

mockito/mockito/629

mockito/mockito/630

15cf2312df360f11282f3dec7915d4648e4ffb21

6003d4ec9625735acfd38782dd984f3817febc25

Javadoc CSS width issue

There is some minor problem with element width (CSS) on javadoc site. Some elements are too wide and are causing horizontal scroll bar to show up. I post picture to show what is going on. https://s9.postimg.io/xlbg2e0ul/mockito_javadoc.png

diff --git a/src/javadoc/stylesheet.css b/src/javadoc/stylesheet.css index b33442208a..f4b3dd7fd5 100644 --- a/src/javadoc/stylesheet.css +++ b/src/javadoc/stylesheet.css @@ -246,15 +246,16 @@ Heading styles ul.blockList ul.blockList li.blockList h3, ul.blockList ul.blockList li.blockList h3 { background:#E0E6DF; border:1px solid #C0C0C0; - width: 110%; - margin-left: -1em; - padding-left: 1em; + width: 100%; + margin-left: 0; + padding-left: 0; } div.summary ul.blockList ul.blockList li.blockList h3 { background:#E0E6DF; - border:0; - border:1px solid #C0C0C0; - padding-left:5px; + border: 0 solid #C0C0C0; + padding: 0; + margin: 0; + width: 100%; } div.summary ul.blockList ul.blockList ul.blockList li.blockList h3 { background:#E0E6DF;

train

train

lukasz-szewc

train

mockito/mockito/439_635

mockito/mockito

mockito/mockito/439

mockito/mockito/635

0fcad43a0a341fc4e3698c9b30faf377018b7b7e