[JAVA] So testen Sie den privaten Bereich mit JUnit

Testen Sie den privaten Bereich

Rufen Sie in Java Felder, Methoden und innere Klassen des privaten Bereichs extern auf Testen wir es mit JUnit.

• Dies ist ein Artikel darüber, wie viele Abkochungen gemacht werden.

Versuchen wir zunächst, mit JUnit zu testen.

Es liegt ein Kompilierungsfehler vor. Es ist eine Spezifikation. Kann nicht ausgeführt werden. Da es privat ist, kann es nicht wie öffentlich aufgerufen werden.

Also verwenden wir Reflection, um etwas Privates zu nennen.

Was ist Reflexion?

Reflection ist eine Art Java-Standardbibliothek. Es handelt sich um Informationen über die Klasse selbst. Als konkretes Beispiel Mit einer Zeichenfolge aus Klassenname, Methodenname und Feldname Generieren Sie diese Klasse, führen Sie Methoden aus und greifen Sie auf Felder zu Ich kann es schaffen

Das Folgende ist eine externe Site, aber es sieht zum Beispiel so aus. http://java.keicode.com/lang/reflection.php

"Wenn es so bequem ist, benutze es positiv." Sie können das denken. Reflection ist jedoch ein zweischneidiges Schwert. Seien Sie vorsichtig beim Umgang. ** Aber ich werde es vorstellen. ** **.

Probleme mit der Reflexion

Die Reflexion hängt davon ab, wie Sie es verwenden

• Das Klassendesign bricht zusammen
• Code ist schwer zu schreiben und schwer zu lesen
• Die Leistung ist schlechter als das normale Aufrufen einer Methode

Es gibt auch Probleme wie. ** Aber ich werde es vorstellen. ** **.

"Testen Sie den privaten Bereich mit JUnit" Dies liegt daran, dass es für einen begrenzten Zweck verwendet wird.

Kehren Sie zum Hauptthema zurück

Korrigieren wir die JUnit-Testklasse, die voller Fehler ist.

package jp.co.illmatics.sample;
/**
 *Zu testende Klasse
 */
@SuppressWarnings("unused")
public class PrivateSample {

    private String field = "Hello field!";

    private final String finalField = "Hello final field!";

    private String doIt()    {
        return "Hello method!";
    }

    private class InnerClass {
        public InnerClass() {

        }
        public String getInnerMethod() {
            return "Hello inner method!";
        }
    }
}

package jp.co.illmatics.sample;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Test;

import junit.framework.TestCase;

/**
 *Testklasse
 */
public class PrivateSampleTest extends TestCase {

    PrivateSample privateSample = new PrivateSample();
    String expected = "";
    String actual = "";

    @Test
    public void testField() throws Exception {
        final String fieldName = "field";
        expected = "Hello field!";
        actual = (String) getFieldValue(privateSample, fieldName);
        assertEquals(expected, actual);
    }

    @Test
    public void testFinalField() throws Exception {
        final String finalFieldName = "finalField";
        expected = "Hello updated final Field!";
        actual = (String) getUpdatedFinalFieldValue(privateSample, expected, finalFieldName);
        assertEquals(expected, actual);
    }

    @Test
    public void testMethod() throws Exception {
        final String methodName = "doIt";
        expected = "Hello method!";
        actual = (String) getMethodValue(privateSample, methodName);
        assertEquals(expected, actual);
    }

    @Test
    public void testInnerClassMethod() throws Exception {
        final String innerClassName = "jp.co.illmatics.sample.PrivateSample$InnerClass";
        final String innerMethodName = "getInnerMethod";
        expected = "Hello inner method!";
        actual = (String) getInnerClassMethod(privateSample, innerClassName, innerMethodName);
        assertEquals(expected, actual);
    }

    private Object getFieldValue(PrivateSample privateSample, String fieldName)
            throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException,
            SecurityException {
        return getPrivateField(privateSample, fieldName).get(privateSample);
    }

    private Field getPrivateField(PrivateSample privateSample, String fieldName)
            throws NoSuchFieldException, SecurityException, IllegalArgumentException,
            IllegalAccessException {
        Class<?> clazz = privateSample.getClass();
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field;
    }

    private Object getUpdatedFinalFieldValue(PrivateSample privateSample, String newValue,
            String fieldName) throws NoSuchFieldException, SecurityException,
                    IllegalArgumentException, IllegalAccessException {
        Field finalField = getPrivateField(privateSample, fieldName);
        finalField.set(privateSample, newValue);
        return finalField.get(privateSample);
    }

    private Object getMethodValue(PrivateSample privateSample, String name)
            throws NoSuchMethodException, SecurityException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        Method doIt = PrivateSample.class.getDeclaredMethod(name);
        doIt.setAccessible(true);
        return doIt.invoke(privateSample);
    }

    private Object getInnerClassMethod(PrivateSample parent, String classFullName,
            String methodName) throws ClassNotFoundException, NoSuchMethodException,
                    SecurityException, InstantiationException, IllegalAccessException,
                    IllegalArgumentException, InvocationTargetException {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class<?> innerClazz = loader.loadClass(classFullName);
        Constructor<?> constructor = innerClazz.getDeclaredConstructor(parent.getClass());
        constructor.setAccessible(true);
        Object innerObj = constructor.newInstance(parent);
        return innerClazz.getDeclaredMethod(methodName).invoke(innerObj);
    }
}

Ich konnte es reparieren.

Prüfung

Es ist fertig.