示例#1
0
    static private <T> Promise<?>
    testNaN(final Eventual _, final T x) throws Exception {
        final Promise<T> p = ref(x);
        check(p.equals(p));
        check(!p.equals(ref(x)));
        try {
            p.call();
            check(false);
        } catch (final ArithmeticException e) { /* expected */ }
        class ENaN extends Do<T,Promise<Boolean>> implements Serializable {
            static private final long serialVersionUID = 1L;

            public Promise<Boolean>
            fulfill(final T arg) throws Exception { throw new Exception(); }

            public Promise<Boolean>
            reject(final Exception reason) throws Exception {
                if (reason instanceof ArithmeticException) { return ref(true); }
                throw reason;
            }
        }
        final Promise<?> a = _.when(p, new ENaN());
        final Promise<?> b = _.when(x, new ENaN());
        final Promise<?> c = _.when(new Sneaky<T>(x), new ENaN());

        return join(_, a, b, c);
    }
示例#2
0
 /**
  * Executes the test.
  * @param args  ignored
  * @throws Exception    test failed
  */
 static public void
 main(final String[] args) throws Exception {
     final List<Promise<?>> work = List.list();
     final Promise<?> result = make(new Eventual(work.appender()));
     while (!work.isEmpty()) { work.pop().call(); }
     result.call();
 }
示例#3
0
    /**
     * Tests promises for a normal reference.
     */
    static private <T extends Receiver<?>> Promise<?>
    testNormal(final Eventual _, final T x) throws Exception {
        final Promise<T> p = ref(x);
        check(p.equals(p));
        check(ref(x).equals(p));
        check(x.equals(p.call()));
        class EQ extends Do<T,Promise<Boolean>> implements Serializable {
            static private final long serialVersionUID = 1L;

            public Promise<Boolean>
            fulfill(final T arg) throws Exception {
                check(x.equals(arg));
                return ref(true);
            }
        }
        final Promise<?> a = _.when(p, new EQ());
        final Promise<?> b = _.when(x, new EQ());
        final Promise<?> c = _.when(new Sneaky<T>(x), new EQ());

        final T x_ = _._(x);
        check(x_.equals(x_));
        check(_._(x_).equals(x_));
        check(_._(x).equals(x_));
        check(ref(x_).equals(p));
        final Promise<?> d = _.when(x_, new EQ());

        return join(_, a, b, c, d);
    }
示例#4
0
    /**
     * Tests promises for {@link Float}.
     */
    static private Promise<?>
    testFloat(final Eventual _) throws Exception {
        // check normal handling
        final Promise<Float> pMin = ref(Float.MIN_VALUE);
        check(pMin.equals(pMin));
        check(ref(Float.MIN_VALUE).equals(pMin));
        check(Float.MIN_VALUE == pMin.call());
        class EQ extends Do<Float,Promise<Boolean>> implements Serializable {
            static private final long serialVersionUID = 1L;

            public Promise<Boolean>
            fulfill(final Float arg) throws Exception {
                check(Float.MIN_VALUE == arg);
                return ref(true);
            }
        }
        final Promise<?> a = _.when(pMin, new EQ());
        final Promise<?> b = _.when(Float.MIN_VALUE, new EQ());

        final Promise<?> c = testNaN(_, Float.NaN);
        final Promise<?> d = testNaN(_, Float.NEGATIVE_INFINITY);
        final Promise<?> e = testNaN(_, Float.POSITIVE_INFINITY);

        return join(_, a, b, c, d, e);
    }