用JUnit比較兩個對象顯示出奇怪的行為

Question

我正在為AbsorptionScheme類編寫一個JUnit測試方法，該方法采用了所謂的AbsorptionBlocks並將它們分類為AbsorptionBlocks數組。 我要測試的是排序是否正常。 因此，我創建了兩個吸收方案對象，並用相同的吸收塊填充了它們，但是第一個未排序，第二個已預先排序。 然后，我想使用JUnit的assertEquals(Object expected, Object actual)函數來確保兩個AbsorptionScheme對象相同。 盡管toSting方法返回的字符串相同，但是JUnit仍然告訴我兩個對象都不相同。

這是JUnits評估：

java.lang.AssertionError: expected: info.rueth.fpucalculator.calc.AbsorptionScheme<Absorption Scheme: (1FPU -> 3h) (2FPU -> 4h) (3FPU -> 5h) (4FPU -> 6h) (6FPU -> 8h)> but was: info.rueth.fpucalculator.calc.AbsorptionScheme<Absorption Scheme: (1FPU -> 3h) (2FPU -> 4h) (3FPU -> 5h) (4FPU -> 6h) (6FPU -> 8h)>
Expected :info.rueth.fpucalculator.calc.AbsorptionScheme<Absorption Scheme: (1FPU -> 3h) (2FPU -> 4h) (3FPU -> 5h) (4FPU -> 6h) (6FPU -> 8h)> 
Actual   :info.rueth.fpucalculator.calc.AbsorptionScheme<Absorption Scheme: (1FPU -> 3h) (2FPU -> 4h) (3FPU -> 5h) (4FPU -> 6h) (6FPU -> 8h)>

我可以看到的唯一區別是，在“預期”字符串的末尾有一個空格，但沒有在“實際”字符串的末尾。

這是我要測試的課程：

package info.rueth.fpucalculator.calc;

import java.util.Arrays;

/**
 * Holds an absorption scheme, connecting FPUs to recommended absorption times.
 */
public class AbsorptionScheme {
    private AbsorptionBlock[] absorptionBlocks;

    AbsorptionScheme() {
        // Create empty array
        absorptionBlocks = new AbsorptionBlock[0];
    }

    /**
     * Adds a new absorption block to the absorption scheme.
     * @param maxFPU The maximum FPU for the absorption time
     * @param absorptionTime The absorption time for that FPU.
     */
    public void addBlock(int maxFPU, int absorptionTime) {
        // Copy existing array into new array with one more empty element at the end ...
        AbsorptionBlock[] newArray = Arrays.copyOf(absorptionBlocks, absorptionBlocks.length + 1);

        // ... and put new AbsorptionBlock into that empty element
        newArray[absorptionBlocks.length] = new AbsorptionBlock(maxFPU, absorptionTime);

        // Sort by maxFPU and replace object variable
        Arrays.sort(newArray, new AbsorptionBlockSorter());
        absorptionBlocks = newArray;
    }

    /**
     * Picks the absorption time associated to the number of FPUs, e.g.:
     * <p>absorptionScheme: 0-1 FPU - 3 hours; 1-2 FPU - 4 hours; 2-3 FPUs - 5 hours; 3-4 FPUs - 6 hours; >4 FPUs - 8 hours</p>
     * <p>The fpu value is commercially rounded to 0 digits, i.e. 2.49 will be rounded to 2, 2.50 will be rounded to 3.</p>
     * <p>If the fpu value is beyond the last scheme block, the time of the last scheme block in the array is returned.</p>
     * 
     * @param fpus The calculated FPUs.
     * @return The associated absorption time.
     */
    public int getAbsorptionTime(double fpus) {
        // Round up the fpus - it's more secure to get a longer insulin interval
        long roundedFPUs = Math.round(fpus);

        // Find associated absorption time
        for (int i = 0; i < absorptionBlocks.length; i++) {
            if (roundedFPUs <= absorptionBlocks[i].getMaxFPU()) {
                return absorptionBlocks[i].getAbsorptionTime();
            }
        }

        // Seems to be beyond the last block, so return time of the last block
        return absorptionBlocks[absorptionBlocks.length - 1].getAbsorptionTime();
    }

    @Override
    public String toString() {
        String returnString = "Absorption Scheme:";
        for (int i = 0; i < absorptionBlocks.length; i++) {
            returnString += " (" + absorptionBlocks[i].getMaxFPU() + "FPU -> " + absorptionBlocks[i].getAbsorptionTime() + "h)";
        }
        return returnString;
    }
}

這是我的測試代碼：

    @Test
    public void addBlock() {
        // Create absorption scheme
        AbsorptionScheme absorptionSchemeActual = new AbsorptionScheme();

        // Add absorption blocks - unsorted on purpose to test sorting!
        absorptionSchemeActual.addBlock(2, 4);
        absorptionSchemeActual.addBlock(3, 5);
        absorptionSchemeActual.addBlock(6, 8);
        absorptionSchemeActual.addBlock(1, 3);
        absorptionSchemeActual.addBlock(4, 6);

        // Create another absorption scheme ...
        AbsorptionScheme absorptionSchemeExpected = new AbsorptionScheme();

        // ... and add blocks, this time sorted!
        absorptionSchemeExpected.addBlock(1, 3);
        absorptionSchemeExpected.addBlock(2, 4);
        absorptionSchemeExpected.addBlock(3, 5);
        absorptionSchemeExpected.addBlock(4, 6);
        absorptionSchemeExpected.addBlock(6, 8);

        // Assert both schemes: They should be identical!
        assertEquals(absorptionSchemeExpected, absorptionSchemeActual);
    }

我看不出有什么區別，所以我做錯了什么？

Answer 1

assertEquals(Object, Object)方法使用給定對象的equals()檢查是否相等。 由於尚未在AbsorptionScheme類中重寫equals() ，因此assertEquals()使用java.lang.Object equals()實現。

僅當兩個對象相同（對象引用相同）時， Object.equals()返回true 。 請參閱Javadoc中Object.equals()以下文本。

類Object的equals方法在對象上實現了最有區別的對等關系。 也就是說，對於任何非空參考值x和y，當且僅當x和y引用同一個對象（x == y的值為true）時，此方法才返回true。

在您的測試用例中， absorptionSchemeActual和absorptionSchemeExpected是兩個不同的對象。 因此assertEquals()失敗。