Native types are not being compared properly

[ishomersimpson]

If I have a bean with native types, the comparison is not being performed properly in some cases.
For what I could understand, it does not work if the value in the "working" bean is the default value for the given data type (e.g 0 for int or false for boolean).

Odd as it may seem, it all works if the given bean class has private access (inner class), but does not work if is public.

Check the following test case where I show three examples.

By the way, this is a nice piece of software!

import de.danielbechler.diff.ObjectDiffer;
import de.danielbechler.diff.ObjectDifferFactory;
import de.danielbechler.diff.node.Node;
import de.danielbechler.diff.visitor.PrintingVisitor;

public class TestCase {

    // class has public access
    public static class TestIntBeanPublic {

        private int value;

        public int getValue() {
            return this.value;
        }

        public void setValue(final int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "TestIntBeanPublic [value=" + this.value + "]";
        }
    }

    // class has private access
    private static class TestIntBeanPrivate {

        private int value;

        public int getValue() {
            return this.value;
        }

        public void setValue(final int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "TestIntBeanPrivate [value=" + this.value + "]";
        }
    }

    public static void testIntegerFailsPublic() {

        TestIntBeanPublic working = new TestIntBeanPublic();
        working.setValue(0);

        TestIntBeanPublic base = new TestIntBeanPublic();
        base.setValue(1);

        ObjectDiffer differ = ObjectDifferFactory.getInstance();
        final Node root = differ.compare(working, base);

        root.visit(new PrintingVisitor(working, base));
    }

    public static void testIntegerWorksPrivate() {

        TestIntBeanPrivate working = new TestIntBeanPrivate();
        working.setValue(0);

        TestIntBeanPrivate base = new TestIntBeanPrivate();
        base.setValue(1);

        ObjectDiffer differ = ObjectDifferFactory.getInstance();
        final Node root = differ.compare(working, base);

        root.visit(new PrintingVisitor(working, base));
    }

    public static void testIntegerWorksPublic() {

        TestIntBeanPublic working = new TestIntBeanPublic();
        working.setValue(2);

        TestIntBeanPublic base = new TestIntBeanPublic();
        base.setValue(1);

        ObjectDiffer differ = ObjectDifferFactory.getInstance();
        final Node root = differ.compare(working, base);

        root.visit(new PrintingVisitor(working, base));
    }

    public static void main(final String[] args) {

        System.out.println("The following comparison works properly (detects change)");
        TestCase.testIntegerWorksPublic();
        System.out.println("The following comparison does not work properly (detects removal)");
        TestCase.testIntegerFailsPublic();
        System.out
                .println("The following comparison works properly bewcause the class has private access (detects change)");
        TestCase.testIntegerWorksPrivate();
    }
}

[gembin]

+1

[ishomersimpson]

The private static inner class works because the Classes.freshInstanceOf(working.getClass()) returns null (it cannot instantiate the object). As such, the further comparisons end up producing the right results.

Anyway, the problem is still there for primitive types.

[SQiShER]

Hey, thanks for the compliment and the helpful test case. I'll look into it as soon as I can!

[SQiShER]

Just a quick update: I'm working on this issue right now and found a solution, but I'll need a little bit more time to implement it properly.

The goal is to make it configurable whether default values of primitive types should be treated as "not assigned" or "assigned". "Not assigned" would cause changes from and to a default value to be marked as additions and removals, whereas "assigned" would cause default values to be treated like any other value (resulting in every change being marked as "changed").

However, this should only apply to real primitives and not their wrapper types (Integer, Boolean, etc.). Wrapper types should be treated like any other object.

Default values don't always have to be 0 or false, but can be any value the property has in a new instance of its containing class. I also added support to determine those default values more reliably in classes with private default constructors.

Since this is a pretty big change, I'll need some extra time to test it thoroughly.

[SQiShER]

I fixed it and released a new version. Here is the change log: https://github.com/SQiShER/java-object-diff/wiki/Changelog

Let me know if everything is working fine now!