JUnit de Java: el método X es ambiguo para el tipo Y

Question

Tuve algunas pruebas trabajando bien. Luego, lo cambié a un paquete diferente, y ahora estoy recibiendo errores. Aquí está el código:

import static org.junit.Assert.*;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.jgrapht.Graphs;
import org.jgrapht.WeightedGraph;
import org.jgrapht.graph.DefaultWeightedEdge;
import org.jgrapht.graph.SimpleWeightedGraph;
import org.junit.*; 

@Test
    public void testEccentricity() {
        WeightedGraph<String, DefaultWeightedEdge> g = generateSimpleCaseGraph();
        Map<String, Double> eccen = JGraphtUtilities.eccentricities(g);

        assertEquals(70, eccen.get("alpha"));
        assertEquals(80, eccen.get("l"));
        assertEquals(130, eccen.get("l-0"));
        assertEquals(100, eccen.get("l-1"));
        assertEquals(90, eccen.get("r"));
        assertEquals(120, eccen.get("r-0"));
        assertEquals(130, eccen.get("r-1"));
    }

El mensaje de error es este:

El método assertEquals (Object, Object) es ambiguo para el tipo JGraphtUtilitiesTest

¿Cómo puedo solucionar esto? ¿Por qué ocurrió este problema cuando moví la clase a un paquete diferente?

Answer 1

El método assertEquals (Object, Object) es ambiguo para el tipo ...

Lo que significa este error es que estás pasando un double y un Double a un método que tiene dos firmas diferentes: assertEquals (Objeto, Objeto) y assertEquals (double, double) que se podrían llamar, gracias al autoboxing.

Para evitar la ambigüedad, asegúrese de llamar a assertEquals (Object, Object) (pasando dos Dobles) o assertEquals (double, double) (al pasar dos dobles).

Entonces, en tu caso, deberías usar:

assertEquals(Double.valueOf(70), eccen.get("alpha"));

O:

assertEquals(70.0d, eccen.get("alpha").doubleValue());

Answer 2

Puedes usar el método

assertEquals(double expected, double actual, double delta)

Lo que tomará en cuenta el error de redondeo que se encuentra en el punto flotante (vea este post por ejemplo). Puedes escribir

assertEquals(70, eccen.get("alpha"), 0.0001);

Esto significa que siempre que los dos valores difieran por menos de 0.0001 se consideran iguales. Esto tiene dos ventajas:

• Compara los valores de punto flotante como se supone que deben
• No es necesario lanzar, ya que los tres argumentos que se afirman solo se aplican a los dobles, no a los objetos genéricos

Answer 3

La solución más sencilla a este problema es convertir el segundo parámetro en una primitiva:

assertEquals(70, (double)eccen.get("alpha"));

Eliminación de la ambigüedad.

Esto es válido para cualquiera de las subclases de números, por ejemplo:

assertEquals(70, (int)new Integer(70));

También resolvería una ambigüedad.

Sin embargo, assertEquals (double, double) está obsoleto desde ahora y por buenas razones, por lo que lo invito a usar el método con un delta como ya han sugerido otros.

Por buenas razones, quiero decir que, dada la representación interna de los números dobles, dos números dobles aparentemente iguales pueden diferir en una fracción infinitesimal irrelevante y no aprobarían una prueba, pero eso no significa que haya algún problema con su código.