Question

场景：具有一些可观察字段的类（无论是简单属性还是observableList，并不重要），并且该字段具有侦听器。如果客户端代码尝试将可观察的值更改为任何无效的值，则侦听器会抛出异常。

测试此行为时，会按预期抛出异常（显示在控制台上），但测试方法没有看到它。这是一个期待异常失败的测试。

感觉我错过了一些明显的东西：

为什么会这样？
我的设置/期望有什么问题？
如何修复：要么通过测试，要么更改设置或其他任何内容？

示例：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

import javafx.beans.property.Property;
import javafx.beans.property.SimpleObjectProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener;
import javafx.collections.ListChangeListener.Change;
import javafx.collections.ObservableList;

/**
 * Trying to dig into issue with expected exceptions. They are shown
 * on the console, but not seen by test runner.
 * 
 * @author Jeanette Winzenburg, Berlin
 */
@RunWith(JUnit4.class)

public class ExceptionFailingTest {

    @Test (expected = IllegalStateException.class)
    public void testExceptionFromListChangeListener() {
        ListOwner owner = new ListOwner();
        owner.getObjects().clear();
    }

    /**
     * Exception thrown in a ChangeListener is not seen by test.
     */
    @Test (expected = IllegalStateException.class)
    public void testExceptionFromPropertyListener() {
        ListOwner owner = new ListOwner();
        owner.getProperty().setValue(null);
    }

    public static class ListOwner {

        private ObservableList objects;
        private Property property;

        public ListOwner() {
            objects = FXCollections.observableArrayList("some", "things", "in", "me");
            objects.addListener((ListChangeListener)c -> objectsChanged(c));
            property = new SimpleObjectProperty(this, "property", "initial");
            property.addListener((src, ov, nv) -> propertyChanged(ov));
        }

        public Property getProperty() {
            return property;
        }

        protected void propertyChanged(Object ov) {
            if (property.getValue() == null)
                throw new IllegalStateException("property must not be empty");
        }

        public ObservableList getObjects() {
            return objects;
        }

        protected void objectsChanged(Change c) {
            if (c.getList().isEmpty())
                throw new IllegalStateException("objects must not be empty");
        }
    }
}

Answer 1

正如评论中所提到的，侦听器抛出的异常基本上被抑制了。这实际上似乎是一个合理的API设计选择（虽然一些文档会很好）：当调用更改侦听器（或列表更改侦听器）时，属性或列表的值已更改。因此，如果您有多个侦听器，则抛出异常的一个侦听器将有效地否决观察此更改的其他侦听器，但不会否决更改本身。还很难看出如何实现（JPA风格）“回滚”：如果第二个侦听器抛出异常，第一个侦听器必须以某种方式“未被注意”。

所以我认为否决更改的方法根本不是监听器，而是通过继承适当的属性/列表类并覆盖修改observable的适当方法。

例如，要拥有一个永远不会为空的可观察列表，您可以执行以下操作[CAVEAT：不是生产质量，只是方法的说明]：

import java.util.List;

import javafx.collections.ModifiableObservableListBase;

public class NonEmptyObservableList<E> extends ModifiableObservableListBase<E> {

    private final List<E> source ;

    public NonEmptyObservableList(List<E> source) {
        if (source.isEmpty()) {
            throw new IllegalStateException("List cannot be empty");
        }
        this.source = source ;
    }


    @Override
    public E get(int index) {
        return source.get(index);
    }

    @Override
    public int size() {
        return source.size();
    }

    @Override
    protected void doAdd(int index, E element) {
        source.add(index, element);
    }

    @Override
    protected E doSet(int index, E element) {
        return source.set(index, element);
    }

    @Override
    protected E doRemove(int index) {
        if (size() <= 1) {
            throw new IllegalStateException("List cannot be empty");
        }
        return source.remove(index);
    }

}

请注意，在此列表中调用clear()将稍微随意地保留“last”元素。这是一个单元测试：

import java.util.ArrayList;
import java.util.Arrays;

import org.junit.Test;

import org.junit.Assert;

public class NonEmptyObservableListTest {

    @Test (expected = IllegalStateException.class)
    public void testExceptionFromListChangeListener() {
        NonEmptyObservableList<String> list = new NonEmptyObservableList<>(new ArrayList<>(Arrays.asList("one", "two")));
        list.clear();
    }


    @Test
    public void testSizeOnClear() {
        NonEmptyObservableList<String> list = new NonEmptyObservableList<>(new ArrayList<>(Arrays.asList("one", "two")));
        try {
            list.clear();
        } catch (Exception e) {
            // squash exception to test list size...
        }
        Assert.assertSame("List size is not 1", list.size(), 1);
    }
}

您也可以考虑覆盖clear()以“原子否决”此更改：

@Override
public void clear() {
    throw new IllegalStateException("List cannot be empty");
}

会在调用clear()时保持列表不变（而不是在其中留下一个元素），但很难涵盖所有可能性（list.subList(0, list.size()).clear() ...）。

尝试创建一个通用的可查看的可观察列表（使用Predicate<List<E>>来确定是否允许更改）会很有趣，但是以有效的方式这样做会非常具有挑战性（并且保留为为读者练习。）

Answer 2

请注意。一年后，在TestFX中实现了所需的功能。

Add support for propagating uncaught exceptions that occur on the JavaFX Application Thread. Issue #155

Observable / List或Property：在监听器中抛出异常而不是＆＃34;看到＆＃34;通过单元测试

2 个答案: