/** * Same as <code>expectMsgAllOf(remainingOrDefault(), obj...)</code>, but correctly treating the * timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remainingOrDefault(), obj...)</code>, but correctly treating the * timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number of objects and * assert that for each given object one is received which equals it and vice versa. This * construct is useful when the order in which the objects are received is not fixed. Wait time is * bounded by the given duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number of objects and * assert that for each given object one is received which equals it and vice versa. This * construct is useful when the order in which the objects are received is not fixed. Wait time is * bounded by the given duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Receive a number of messages from the test actor matching the given number * of objects and assert that for each given object one is received which * equals it and vice versa. This construct is useful when the order in which * the objects are received is not fixed. Wait time is bounded by the given * duration, with an AssertionFailure being thrown in case of timeout. */ public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) { return (Object[]) p.expectMsgAllOf(max, Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }
/** * Same as <code>expectMsgAllOf(remaining(), obj...)</code>, but correctly * treating the timeFactor. */ public Object[] expectMsgAllOf(Object... msgs) { return (Object[]) p.expectMsgAllOf(Util.immutableSeq(msgs)).toArray(Util.classTag(Object.class)); }