// Path: src/main/java/reactor/ColdFlux.java
// public class ColdFlux<T> extends Flux<T> implements TestablePublisher<T> {
// 
//     private final TestablePublisher<T> publisher;
// 
//     protected ColdFlux(TestablePublisher<T> publisher) {
//         this.publisher = publisher;
//     }
// 
//     @Override
//     public void subscribe(Subscriber<? super T> s) {
//         publisher.subscribe(s);
//     }
// 
//     @Override
//     public List<SubscriptionLog> getSubscriptions() {
//         return publisher.getSubscriptions();
//     }
// 
//     @Override
//     public List<Recorded<T>> getMessages() {
//         return publisher.getMessages();
//     }
// 
//     public static <T> ColdFlux<T> create(Scheduler scheduler, Recorded<T>... notifications) {
//         return create(scheduler, Arrays.asList(notifications));
//     }
// 
//     public static <T> ColdFlux<T> create(final Scheduler scheduler, List<Recorded<T>> notifications) {
// 
//         ColdPublisher<T> coldPublisher = new ColdPublisher<>(new SchedulerFactory() {
//             @Override
//             public org.reactivestreams.Scheduler create() {
//                 return new SchedulerAdapter(scheduler);
//             }
//         }, notifications);
// 
//         return new ColdFlux<>(coldPublisher);
//     }
// 
// }
// 
// Path: src/main/java/reactor/MapHelper.java
// public class MapHelper {
// 
//     public static <V> Map<String, V> of(String k, V v) {
//         return Collections.singletonMap(k,v);
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2) {
//         Map<String, V> map = new HashMap<>();
//         map.put(k1, v1);
//         map.put(k2, v2);
//         return map;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3) {
//         Map<String, V> result = of(k1, v1, k2, v2);
//         result.put(k3, v3);
//         return result;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3, String k4, V v4) {
//         Map<String, V> result = of(k1, v1, k2, v2, k3, v3);
//         result.put(k4, v4);
//         return result;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3, String k4, V v4, String k5, V v5) {
//         Map<String, V> result = of(k1, v1, k2, v2, k3, v3, k4, v4);
//         result.put(k5, v5);
//         return result;
//     }
// }
// 
// Path: src/main/java/reactor/junit/MarbleRule.java
// public static ISetupTest expectFlux(Flux<?> actual) {
//     return schedulerHolder.get().expectFlux(actual);
// }
// 
// Path: src/main/java/reactor/junit/MarbleRule.java
// public class MarbleRule implements TestRule {
// 
//     private static ThreadLocal<MarbleScheduler> schedulerHolder = new ThreadLocal<>();
// 
//     public final MarbleScheduler scheduler;
// 
//     public MarbleRule() {
//         scheduler = new MarbleScheduler();
//     }
// 
//     public MarbleRule(long frameTimeFactor) {
//         scheduler = new MarbleScheduler(frameTimeFactor);
//     }
// 
//     public static <T> HotFlux<T> hot(String marbles, Map<String, T> values) {
//         return schedulerHolder.get().createHotFlux(marbles, values);
//     }
// 
//     public static HotFlux<String> hot(String marbles) {
//         return schedulerHolder.get().createHotFlux(marbles);
//     }
// 
//     public static <T> ColdFlux<T> cold(String marbles, Map<String, T> values) {
//         return schedulerHolder.get().createColdFlux(marbles, values);
//     }
// 
//     public static ColdFlux<String> cold(String marbles) {
//         return schedulerHolder.get().createColdFlux(marbles);
//     }
// 
//     public static ISetupTest expectFlux(Flux<?> actual) {
//         return schedulerHolder.get().expectFlux(actual);
//     }
// 
//     public static ISetupTest expectFlux(Flux<?> actual, String unsubscriptionMarbles) {
//         return schedulerHolder.get().expectFlux(actual, unsubscriptionMarbles);
//     }
// 
//     public static ISetupTest expectMono(Mono<?> actual) {
//         return schedulerHolder.get().expectFlux(actual.flux());
//     }
// 
//     public static ISetupTest expectMono(Mono<?> actual, String unsubscriptionMarbles) {
//         return schedulerHolder.get().expectFlux(actual.flux(), unsubscriptionMarbles);
//     }
// 
//     public static ISetupSubscriptionsTest expectSubscriptions(List<SubscriptionLog> subscriptions) {
//         return schedulerHolder.get().expectSubscriptions(subscriptions);
//     }
// 
//     @Override
//     public Statement apply(final Statement base, Description description) {
//         return new Statement() {
//             @Override
//             public void evaluate() throws Throwable {
//                 schedulerHolder.set(scheduler);
//                 try {
//                     base.evaluate();
//                     scheduler.flush();
//                 } finally {
//                     schedulerHolder.remove();
//                 }
// 
//             }
//         };
//     }
// }


import org.junit.Rule;
import org.junit.Test;
import reactor.ColdFlux;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import static reactor.MapHelper.*;
import static reactor.junit.MarbleRule.expectFlux;
import static reactor.junit.MarbleRule.*;
package reactor.junit;




/**
 * Created by Alexandre Victoor on 26/04/2017.
 */
public class DemoTest {

    @Rule
// Path: src/main/java/reactor/ColdFlux.java
// public class ColdFlux<T> extends Flux<T> implements TestablePublisher<T> {
// 
//     private final TestablePublisher<T> publisher;
// 
//     protected ColdFlux(TestablePublisher<T> publisher) {
//         this.publisher = publisher;
//     }
// 
//     @Override
//     public void subscribe(Subscriber<? super T> s) {
//         publisher.subscribe(s);
//     }
// 
//     @Override
//     public List<SubscriptionLog> getSubscriptions() {
//         return publisher.getSubscriptions();
//     }
// 
//     @Override
//     public List<Recorded<T>> getMessages() {
//         return publisher.getMessages();
//     }
// 
//     public static <T> ColdFlux<T> create(Scheduler scheduler, Recorded<T>... notifications) {
//         return create(scheduler, Arrays.asList(notifications));
//     }
// 
//     public static <T> ColdFlux<T> create(final Scheduler scheduler, List<Recorded<T>> notifications) {
// 
//         ColdPublisher<T> coldPublisher = new ColdPublisher<>(new SchedulerFactory() {
//             @Override
//             public org.reactivestreams.Scheduler create() {
//                 return new SchedulerAdapter(scheduler);
//             }
//         }, notifications);
// 
//         return new ColdFlux<>(coldPublisher);
//     }
// 
// }
// 
// Path: src/main/java/reactor/MapHelper.java
// public class MapHelper {
// 
//     public static <V> Map<String, V> of(String k, V v) {
//         return Collections.singletonMap(k,v);
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2) {
//         Map<String, V> map = new HashMap<>();
//         map.put(k1, v1);
//         map.put(k2, v2);
//         return map;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3) {
//         Map<String, V> result = of(k1, v1, k2, v2);
//         result.put(k3, v3);
//         return result;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3, String k4, V v4) {
//         Map<String, V> result = of(k1, v1, k2, v2, k3, v3);
//         result.put(k4, v4);
//         return result;
//     }
// 
//     public static <V> Map<String, V> of(String k1, V v1, String k2, V v2, String k3, V v3, String k4, V v4, String k5, V v5) {
//         Map<String, V> result = of(k1, v1, k2, v2, k3, v3, k4, v4);
//         result.put(k5, v5);
//         return result;
//     }
// }
// 
// Path: src/main/java/reactor/junit/MarbleRule.java
// public static ISetupTest expectFlux(Flux<?> actual) {
//     return schedulerHolder.get().expectFlux(actual);
// }
// 
// Path: src/main/java/reactor/junit/MarbleRule.java
// public class MarbleRule implements TestRule {
// 
//     private static ThreadLocal<MarbleScheduler> schedulerHolder = new ThreadLocal<>();
// 
//     public final MarbleScheduler scheduler;
// 
//     public MarbleRule() {
//         scheduler = new MarbleScheduler();
//     }
// 
//     public MarbleRule(long frameTimeFactor) {
//         scheduler = new MarbleScheduler(frameTimeFactor);
//     }
// 
//     public static <T> HotFlux<T> hot(String marbles, Map<String, T> values) {
//         return schedulerHolder.get().createHotFlux(marbles, values);
//     }
// 
//     public static HotFlux<String> hot(String marbles) {
//         return schedulerHolder.get().createHotFlux(marbles);
//     }
// 
//     public static <T> ColdFlux<T> cold(String marbles, Map<String, T> values) {
//         return schedulerHolder.get().createColdFlux(marbles, values);
//     }
// 
//     public static ColdFlux<String> cold(String marbles) {
//         return schedulerHolder.get().createColdFlux(marbles);
//     }
// 
//     public static ISetupTest expectFlux(Flux<?> actual) {
//         return schedulerHolder.get().expectFlux(actual);
//     }
// 
//     public static ISetupTest expectFlux(Flux<?> actual, String unsubscriptionMarbles) {
//         return schedulerHolder.get().expectFlux(actual, unsubscriptionMarbles);
//     }
// 
//     public static ISetupTest expectMono(Mono<?> actual) {
//         return schedulerHolder.get().expectFlux(actual.flux());
//     }
// 
//     public static ISetupTest expectMono(Mono<?> actual, String unsubscriptionMarbles) {
//         return schedulerHolder.get().expectFlux(actual.flux(), unsubscriptionMarbles);
//     }
// 
//     public static ISetupSubscriptionsTest expectSubscriptions(List<SubscriptionLog> subscriptions) {
//         return schedulerHolder.get().expectSubscriptions(subscriptions);
//     }
// 
//     @Override
//     public Statement apply(final Statement base, Description description) {
//         return new Statement() {
//             @Override
//             public void evaluate() throws Throwable {
//                 schedulerHolder.set(scheduler);
//                 try {
//                     base.evaluate();
//                     scheduler.flush();
//                 } finally {
//                     schedulerHolder.remove();
//                 }
// 
//             }
//         };
//     }
// }


// Path: src/test/java/reactor/junit/DemoTest.java
import org.junit.Rule;
import org.junit.Test;
import reactor.ColdFlux;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import static reactor.MapHelper.*;
import static reactor.junit.MarbleRule.expectFlux;
import static reactor.junit.MarbleRule.*;

package reactor.junit;




/**
 * Created by Alexandre Victoor on 26/04/2017.
 */
public class DemoTest {

    @Rule
    public MarbleRule marble = new MarbleRule();