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);
}
/**
* 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();
}
/**
* 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);
}
/**
* 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);
}