Projects >> azkaban >>67e8c2a2e447ea5ca633b804257230dec7dbe676

Chunk
Conflicting content 
                                    }
                                }
                            }
<<<<<<< HEAD
                        });
=======
                        }
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                allKnownFlows.saveExecutableFlow(new FlowExecutionHolder(flowToRun, parentProps));
            }
Solution content 
                                    }
                                }
                            }
                        });

                allKnownFlows.saveExecutableFlow(new FlowExecutionHolder(flowToRun, parentProps));
            }
File
Scheduler.java
Developer's decision
Version 1
Kind of conflict
Other
Chunk
Conflicting content 
                                    _completed.put(_scheduledJob.getId(), _scheduledJob);
                                }
                            }
<<<<<<< HEAD
                        });
=======
                        }
                        catch (RuntimeException e) {
                            logger.warn("Exception caught while saving flow/sending emails", e);
                            throw e;
                        }
                        finally {
                            // mark the job as completed
                            _executing.remove(_scheduledJob.getId());
                            _completed.put(_scheduledJob.getId(), _scheduledJob);
                        }
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                allKnownFlows.saveExecutableFlow(holder);
            }
Solution content 
                                    _completed.put(_scheduledJob.getId(), _scheduledJob);
                                }
                            }
                        });

                allKnownFlows.saveExecutableFlow(holder);
            }
File
Scheduler.java
Developer's decision
Version 1
Kind of conflict
Catch clause
Comment
Method invocation
Chunk
Conflicting content 
    private volatile Status jobState;
    private volatile Throwable exception;
    private volatile List callbacksToCall = new ArrayList();
<<<<<<< HEAD
    private volatile Props parentProps;
=======
    private volatile Props flowOutputGeneratedProperties;
    private volatile Props intermediateFlowOutputProperties;
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82


    public ComposedExecutableFlow(String id, ExecutableFlow depender, ExecutableFlow dependee)
Solution content 
    private volatile Status jobState;
    private volatile Throwable exception;
    private volatile List callbacksToCall = new ArrayList();
    private volatile Props parentProps;
    private volatile Props returnProps;


    public ComposedExecutableFlow(String id, ExecutableFlow depender, ExecutableFlow dependee)
File
ComposedExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
Chunk
Conflicting content 
                        jobState = Status.RUNNING;
                        startTime = dependee.getStartTime();
                        endTime = null;
<<<<<<< HEAD
                        parentProps = dependee.getParentProps();
                        dependee.execute(parentProps, new DependeeCallback());
=======
                        // Like GroupedExecutableFlow, seems to only be installing the callback.
                        dependee.execute(new DependeeCallback(), new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
                        break;
                    case COMPLETED:
                    case SUCCEEDED:
Solution content 
                        jobState = Status.RUNNING;
                        startTime = dependee.getStartTime();
                        endTime = null;
                        parentProps = dependee.getParentProps();
                        dependee.execute(parentProps, new DependeeCallback());
                        break;
                    case COMPLETED:
                    case SUCCEEDED:
File
ComposedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Attribute
Comment
Method invocation
Chunk
Conflicting content 
                startTime = dependee.getStartTime() == null ? depender.getStartTime() : dependee.getStartTime();
                endTime = null;

<<<<<<< HEAD
                parentProps = depender.getParentProps();
                if (! parentProps.equalsProps(dependee.getParentProps())) {
                    throw new IllegalStateException(String.format("Parent props differ for sub flows [%s]", id));
                }
                depender.execute(parentProps, new DependerCallback());
=======
                // Like GroupedExecutableFlow, seems to only be installing the callback.
                depender.execute(new DependerCallback(), new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                break;
            case COMPLETED:
Solution content 
                startTime = dependee.getStartTime() == null ? depender.getStartTime() : dependee.getStartTime();
                endTime = null;

                parentProps = depender.getParentProps();
                if (! parentProps.equalsProps(dependee.getParentProps())) {
                    throw new IllegalStateException(String.format("Parent props differ for sub flows [%s]", id));
                }
                depender.execute(parentProps, new DependerCallback());

                break;
            case COMPLETED:
File
ComposedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Attribute
Comment
If statement
Method invocation
Chunk
Conflicting content 
    }

    @Override
<<<<<<< HEAD
    public void execute(Props parentProps, final FlowCallback callback)
=======
    public void execute(final FlowCallback callback, Props flowInputGeneratedProperties)
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    {
        if (parentProps == null) {
            parentProps = new Props();
Solution content 
    @Override
    public void execute(Props parentProps, final FlowCallback callback)
    {
        if (parentProps == null) {
            parentProps = new Props();
File
ComposedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Method signature
Chunk
Conflicting content 
        }

        try {
<<<<<<< HEAD
            dependee.execute(parentProps, new DependeeCallback());
=======
            dependee.execute(new DependeeCallback(), flowInputGeneratedProperties);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        }
        catch (RuntimeException e) {
            final List callbacks;
Solution content 
        }

        try {
            dependee.execute(parentProps, new DependeeCallback());
        }
        catch (RuntimeException e) {
            final List callbacks;
File
ComposedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
                    for (FlowCallback flowCallback : callbackList) {
                        flowCallback.progressMade();
                    }
<<<<<<< HEAD

                    depender.execute(parentProps, new DependerCallback());
=======
                    
                    
                    // Aggregate all output from dependee
                    intermediateFlowOutputProperties = new Props(
                            flowInputGeneratedProperties,
                            dependee.getFlowGeneratedProperties()
                    );
                    intermediateFlowOutputProperties.logProperties(
                            "Intermediate Output properties for dependee " + getName()
                    );

                    depender.execute(new DependerCallback(), intermediateFlowOutputProperties);
                    
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
                    break;
                case FAILED:
                    synchronized (sync) {
Solution content 
                    for (FlowCallback flowCallback : callbackList) {
                        flowCallback.progressMade();
                    }
                    
                    depender.execute(new Props(parentProps, dependee.getReturnProps()), new DependerCallback());
                    break;
                case FAILED:
                    synchronized (sync) {
File
ComposedExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
Comment
Method invocation
Chunk
Conflicting content 
        final ExecutableFlow dependerFlow = overrides.containsKey(depender.getName()) ?
                                            overrides.get(depender.getName()) :
<<<<<<< HEAD
                                            // TODO why are we not using overides here? not sure.. :/
                                            depender.createExecutableFlow(id, new HashMap());
=======
                                            depender.createExecutableFlow(id, overrideProps, overrides);

        // Remove the depender from the overrides because the ComposedExecutableFlow will take its place.
        // The put() below will have the same effect, but I added this to be explicit.
        overrides.remove(depender.getName());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        final ComposedExecutableFlow retVal = new ComposedExecutableFlow(id, dependerFlow, dependeeFlow);
Solution content 
        final ExecutableFlow dependerFlow = overrides.containsKey(depender.getName()) ?
                                            overrides.get(depender.getName()) :
                                            depender.createExecutableFlow(id, overrides);

        // Remove the depender from the overrides because the ComposedExecutableFlow will take its place.
        // The put() below will have the same effect, but I added this to be explicit.
        overrides.remove(depender.getName());

        final ComposedExecutableFlow retVal = new ComposedExecutableFlow(id, dependerFlow, dependeeFlow);
File
ComposedFlow.java
Developer's decision
Manual
Kind of conflict
Comment
Method invocation
Chunk
Conflicting content 
     * @param callback the callback to be run upon completion.
     * @param flowInputGeneratedProperties
     */
<<<<<<< HEAD
    public void execute(Props parentProperties, FlowCallback callback);
=======
    public void execute(FlowCallback callback, Props flowInputGeneratedProperties);
    
    /**
     * Get the properties that were generated by this flow.
     * 
     * @return
     */
    public Props getFlowGeneratedProperties();
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

    /**
     * Cancels a running flow
Solution content 
     * @param callback the callback to be run upon completion.
     */
    public void execute(Props parentProperties, FlowCallback callback);

    /**
     * Cancels a running flow
File
ExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Comment
Method interface
Chunk
Conflicting content 
     * @return time execution completed.  Null if not started yet.
     */
    public DateTime getEndTime();
<<<<<<< HEAD

    /**
     * Gets the parent props used for the execution of this Flow
     *
     * @return the parent props, null if state is READY
     */
    public Props getParentProps();
=======
    
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

    /**
     * Gets the exception that caused this Flow to fail, if it has failed
Solution content 
     * @return time execution completed.  Null if not started yet.
     */
    public DateTime getEndTime();

    /**
     * Gets the parent props used for the execution of this Flow
     *
     * @return the parent props, null if state is READY
     */
    public Props getParentProps();

    /**
     * Gets the return props from the execution of this Flow
     *
     * The return props are the props that this execution wants to
     * provide to any other up-stream executions.
     *
     * @return the parent props, null if state is READY
     */
    public Props getReturnProps();

    /**
     * Gets the exception that caused this Flow to fail, if it has failed
File
ExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Comment
Method interface
Chunk
Conflicting content 
package azkaban.flow;

import azkaban.common.utils.Props;
<<<<<<< HEAD
=======

>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import org.apache.commons.lang.StringUtils;
Solution content 
package azkaban.flow;

import azkaban.common.utils.Props;
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import org.apache.commons.lang.StringUtils;
File
GroupedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Blank
Chunk
Conflicting content 
    private volatile DateTime endTime;
    private volatile GroupedExecutableFlow.GroupedFlowCallback theGroupCallback;
    private volatile Throwable exception;
<<<<<<< HEAD
    private volatile Props parentProps;
=======
    private volatile Props flowOutputGeneratedProperties;
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

    public GroupedExecutableFlow(String id, ExecutableFlow... flows)
    {
Solution content 
    private volatile DateTime endTime;
    private volatile GroupedExecutableFlow.GroupedFlowCallback theGroupCallback;
    private volatile Throwable exception;
    private volatile Props parentProps;
    private volatile Props returnProps;

    public GroupedExecutableFlow(String id, ExecutableFlow... flows)
    {
File
GroupedExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
Chunk
Conflicting content 
                // Make sure everything is initialized before leaking the pointer to "this".
                // This is just installing the callback in an already running flow.
                for (ExecutableFlow runningFlow : runningFlows) {
<<<<<<< HEAD
                    runningFlow.execute(parentProps, theGroupCallback);
=======
                    runningFlow.execute(theGroupCallback, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
                }
        }
    }
Solution content 
                // Make sure everything is initialized before leaking the pointer to "this".
                // This is just installing the callback in an already running flow.
                for (ExecutableFlow runningFlow : runningFlows) {
                    runningFlow.execute(parentProps, theGroupCallback);
                }
        }
    }
File
GroupedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
    }

    @Override
<<<<<<< HEAD
    public void execute(Props parentProps, final FlowCallback callback)
=======
    public void execute(final FlowCallback callback, Props flowInputOutputProperties)
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    {
        if (parentProps == null) {
            parentProps = new Props();
Solution content 
    }

    @Override
    public void execute(Props parentProps, final FlowCallback callback)
    {
        if (parentProps == null) {
            parentProps = new Props();
File
GroupedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Method signature
Chunk
Conflicting content 
        for (ExecutableFlow flow : flows) {
            if (jobState != Status.FAILED) {
                try {
<<<<<<< HEAD
                    flow.execute(this.parentProps, theGroupCallback);
=======
                    flow.execute(theGroupCallback, this.flowInputGeneratedProperties);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
                }
                catch (RuntimeException e) {
                    final List callbacks;
Solution content 
        for (ExecutableFlow flow : flows) {
            if (jobState != Status.FAILED) {
                try {
                    flow.execute(this.parentProps, theGroupCallback);
                }
                catch (RuntimeException e) {
                    final List callbacks;
File
GroupedExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
    private final String id;
    private final String name;
    private final JobManager jobManager;
<<<<<<< HEAD

=======
    private final Props overrideProps;
    
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    private volatile Status jobState;
    private volatile List callbacksToCall;
    private volatile DateTime startTime;
Solution content 
    private final String id;
    private final String name;
    private final JobManager jobManager;

    private volatile Status jobState;
    private volatile List callbacksToCall;
    private volatile DateTime startTime;
File
IndividualJobExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Attribute
Chunk
Conflicting content 
    private volatile DateTime endTime;
    private volatile Job job;
    private volatile Throwable exception;
<<<<<<< HEAD
    private volatile Props parentProps;
=======
    private volatile Props flowOutputGeneratedProperties;
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

    public IndividualJobExecutableFlow(String id, String name, JobManager jobManager)
    {
Solution content 
    private volatile DateTime endTime;
    private volatile Job job;
    private volatile Throwable exception;
    private volatile Props parentProps;
    private volatile Props returnProps;

    public IndividualJobExecutableFlow(String id, String name, JobManager jobManager)
    {
File
IndividualJobExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
Chunk
Conflicting content 
    }

    {
        return name;
    }
<<<<<<< HEAD

    public Props getParentProps() {
		return parentProps;
	}
    
    @Override
    public void execute(Props parentProps, FlowCallback callback)
=======
    
    @Override
    public Props getFlowGeneratedProperties() {
        return flowOutputGeneratedProperties;
    }
    
    public Props getOverrideProps() {
        return overrideProps;
    @Override
    public void execute(FlowCallback callback, Props flowGeneratedProperties)
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    {
        if (parentProps == null) {
            parentProps = new Props();
Solution content 
    {
        return name;
    }

    @Override
    public Props getParentProps() {
		return parentProps;
	}

    @Override
    public Props getReturnProps() {
        return returnProps;
    }

    @Override
    public void execute(Props parentProps, FlowCallback callback)
    {
        if (parentProps == null) {
            parentProps = new Props();
File
IndividualJobExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
            }
        }

<<<<<<< HEAD
        job = jobManager.loadJob(getName(), this.parentProps, true);

        final ClassLoader storeMyClassLoader = Thread.currentThread().getContextClassLoader();
=======
        // Get the output properties from dependent jobs.
        // Clone them so we don't mess up storage up the line.
        final Props flowInputGeneratedProperties = (flowGeneratedProperties == null ?
                                                    null :
                                                    Props.clone(flowGeneratedProperties));
        
        try {
            // Only one thread should ever be able to get to this point because of management of jobState
            // Thus, this should only ever get called once before the job finishes (at which point it could be reset)
            job = jobManager.loadJob(getName(), new Props(overrideProps, flowInputGeneratedProperties), true);
        }
        catch (Exception e) {
            logger.warn(
                    String.format("Exception thrown while creating job[%s]", getName()),
                    e
            );
            job = null;
        }
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        if (job == null) {
            logger.warn(
Solution content 
            }
        }

        try {
            // Only one thread should ever be able to get to this point because of management of jobState
            // Thus, this should only ever get called once before the job finishes (at which point it could be reset)
            job = jobManager.loadJob(getName(), parentProps, true);
        }
        catch (Exception e) {
            logger.warn(
                    String.format("Exception thrown while creating job[%s]", getName()),
                    e
            );
            job = null;
        }
        if (job == null) {
            logger.warn(
File
IndividualJobExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
Comment
Method invocation
Try statement
Variable
Chunk
Conflicting content 
        return this;
    }

<<<<<<< HEAD
    IndividualJobExecutableFlow setParentProperties(Props parentProps)
    {
        synchronized (sync) {
            if (this.parentProps == null) {
                this.parentProps = parentProps;
            }
            else {
                throw new IllegalStateException("Attempt to override parent properties.  " +
                                                "This method should only really be called from deserialization code");
            }
        }

        return this;
    }

    private void resetState() {
        jobState = Status.READY;
        callbacksToCall = new ArrayList();
        parentProps = null;
        startTime = null;
        endTime = null;
        exception = null;
=======
    private void callCallbacks(final List callbackList, final Status status)
    {
        if (endTime == null) {
            endTime = new DateTime();
        }

        Thread callbackThread = new Thread(
                new Runnable()
                {
                    @Override
                    public void run()
                    {
                        for (FlowCallback callback : callbackList) {
                            try {
                                callback.completed(status);
                            }
                            catch (RuntimeException t) {
                                logger.error(
                                        String.format("Exception thrown while calling callback. job[%s]", getName()),
                                        t
                                );
                            }
                        }
                    }
                },
                String.format("%s-callback", Thread.currentThread().getName())
        );

        callbackThread.start();
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    }
}
Solution content 
        return this;
    }

    private void callCallbacks(final List callbackList, final Status status)
    {
        if (endTime == null) {
            endTime = new DateTime();
        }

        Thread callbackThread = new Thread(
                new Runnable()
                {
                    @Override
                    public void run()
                    {
                        for (FlowCallback callback : callbackList) {
                            try {
                                callback.completed(status);
                            }
                            catch (RuntimeException t) {
                                logger.error(
                                        String.format("Exception thrown while calling callback. job[%s]", getName()),
                                        t
                                );
                            }
                        }
                    }
                },
                String.format("%s-callback", Thread.currentThread().getName())
        );

        callbackThread.start();
    }

    IndividualJobExecutableFlow setParentProperties(Props parentProps)
    {
        synchronized (sync) {
            if (this.parentProps == null) {
                this.parentProps = parentProps;
            }
            else {
                throw new IllegalStateException("Attempt to override parent properties.  " +
                                                "This method should only really be called from deserialization code");
            }
        }

        return this;
    }

    private void resetState() {
        jobState = Status.READY;
        callbacksToCall = new ArrayList();
        parentProps = null;
        returnProps = null;
        startTime = null;
        endTime = null;
        exception = null;
    }
}
File
IndividualJobExecutableFlow.java
Developer's decision
Manual
Kind of conflict
Attribute
If statement
Method declaration
Method invocation
Method signature
Variable
Chunk
Conflicting content 
    }
    
    @Override
<<<<<<< HEAD
    public void execute(Props parentProperties, FlowCallback callback)
    {
        actualFlow.execute(parentProperties, callback);
=======
    public void execute(FlowCallback callback, Props flowInputOutputProperties) {
        actualFlow.execute(callback, flowInputOutputProperties);
    }
    
    @Override
    public Props getFlowGeneratedProperties() {
        return actualFlow.getFlowGeneratedProperties();
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    }

    @Override
Solution content 
    }

    @Override
    public void execute(Props parentProperties, FlowCallback callback)
    {
        actualFlow.execute(parentProperties, callback);
    }

    @Override
File
MultipleDependencyExecutableFlow.java
Developer's decision
Version 1
Kind of conflict
Annotation
Method declaration
Method invocation
Method signature
Return statement
Chunk
Conflicting content 
                                    exception.printStackTrace();
                                }

<<<<<<< HEAD
                                countDown.countDown();
                            }
                        });
=======
                        countDown.countDown();
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
            } catch(Exception e) {
                System.out.println("Failed to run job '" + jobName + "':");
                e.printStackTrace();
Solution content 
                                    exception.printStackTrace();
                                }

                                countDown.countDown();
                            }
                        });
            } catch(Exception e) {
                System.out.println("Failed to run job '" + jobName + "':");
                e.printStackTrace();
File
CommandLineJobRunner.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
         
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        },composedFlowInputGenParams);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
                    {
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
        Assert.assertEquals(null, flow.getException());
<<<<<<< HEAD

        EasyMock.verify(props);
        EasyMock.reset(props);

        EasyMock.expect(props.equalsProps(props)).andReturn(false).once();

        EasyMock.replay(props);

        boolean exceptionThrown = false;
        try {
            flow.execute(
                    props,
                    new FlowCallback() {
                        @Override
                        public void progressMade() {
                        }

                        @Override
                        public void completed(Status status) {
                        }
                    }
            );
        }
        catch (IllegalArgumentException e) {
            exceptionThrown = true;
        }

        Assert.assertTrue("Expected an IllegalArgumentException to be thrown because props weren't the same.", exceptionThrown);
=======
        
        // The output should be the union of the input params to the job - the generated output params
        // from after the job ran.
        Props flowGeneratedProps = flow.getFlowGeneratedProperties();
        Assert.assertFalse(flowGeneratedProps == null);
        Assert.assertEquals(flowGeneratedProps.get("junit.dependee"), "dependeeGen");
        Assert.assertEquals(flowGeneratedProps.get("junit.dependee"), "dependeeGen");
        Assert.assertEquals(flowGeneratedProps.get("junit.composedFlow"), "composedFlowGen");
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    }

    @Test
Solution content 
        Assert.assertEquals(null, flow.getException());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());

        EasyMock.verify(props);
        EasyMock.reset(props);

        EasyMock.expect(props.equalsProps(props)).andReturn(false).once();

        EasyMock.replay(props);

        boolean exceptionThrown = false;
        try {
            flow.execute(
                    props,
                    new FlowCallback() {
                        @Override
                        public void progressMade() {
                        }

                        @Override
                        public void completed(Status status) {
                        }
                    }
            );
        }
        catch (IllegalArgumentException e) {
            exceptionThrown = true;
        }

        Assert.assertTrue("Expected an IllegalArgumentException to be thrown because props weren't the same.", exceptionThrown);
    }

    @Test
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Comment
Method invocation
Try statement
Variable
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
                    }
        Assert.assertEquals(theException, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        Assert.assertEquals(theException, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").once();

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(theException, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        Assert.assertEquals(theException, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean executeCallWhileStateWasRunningHadItsCallbackCalled = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean executeCallWhileStateWasRunningHadItsCallbackCalled = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
                Assert.assertTrue("Dependee already ran!?", dependeeRan.compareAndSet(false, true));
                Assert.assertEquals(Status.RUNNING, flow.getStatus());

<<<<<<< HEAD
                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });
=======
                flow.execute(new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                dependeeCallback.getValue().completed(Status.SUCCEEDED);
Solution content 
                Assert.assertTrue("Dependee already ran!?", dependeeRan.compareAndSet(false, true));
                Assert.assertEquals(Status.RUNNING, flow.getStatus());

                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });

                dependeeCallback.getValue().completed(Status.SUCCEEDED);
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").once();

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependeeFlow.getParentProps()).andReturn(props).times(1);
        Capture dependeeFlowCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeFlowCallback));

        Capture dependerFlowCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerFlowCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeFlowCallback), EasyMock.isA(Props.class));
        
        // These are called by dependeeCallback.getValue().completed(Status.SUCCEEDED);
        EasyMock.expect(dependeeFlow.getFlowGeneratedProperties()).andReturn(new Props()).once();
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").once();

        Capture dependerFlowCallback = new Capture();
        dependerFlow.execute(EasyMock.capture(dependerFlowCallback), EasyMock.isA(Props.class));
            
        // These are called by dependerCallback.getValue().completed(Status.SUCCEEDED);
        EasyMock.expect(dependerFlow.getFlowGeneratedProperties()).andReturn(new Props()).once();
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").once();
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        EasyMock.replay(dependerFlow, dependeeFlow);
Solution content 
        EasyMock.expect(dependeeFlow.getParentProps()).andReturn(props).times(1);

        Capture dependeeFlowCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeFlowCallback));

        Capture dependerFlowCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerFlowCallback));

        EasyMock.replay(dependerFlow, dependeeFlow);
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Comment
Method invocation
Variable
Chunk
Conflicting content 
        EasyMock.expect(dependeeFlow.getParentProps()).andReturn(props).once();

        Capture dependerFlowCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerFlowCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerFlowCallback), EasyMock.isA(Props.class));
        
        // These are called by dependeeCallback.getValue().completed(Status.SUCCEEDED);
        EasyMock.expect(dependerFlow.getFlowGeneratedProperties()).andReturn(new Props()).once();
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").once();
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        EasyMock.reset(props);
        EasyMock.expect(props.equalsProps(props)).andReturn(true).once();
Solution content 
        EasyMock.reset(props);
        EasyMock.expect(dependeeFlow.getParentProps()).andReturn(props).once();

        Capture dependerFlowCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerFlowCallback));

        EasyMock.expect(props.equalsProps(props)).andReturn(true).once();
File
ComposedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Comment
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
=======
        mockFlow1.execute(EasyMock.capture(flow1Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
<<<<<<< HEAD
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
=======
        mockFlow2.execute(EasyMock.capture(flow2Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            public void theCallback(Status status) {
                Assert.assertEquals(Status.SUCCEEDED, status);
                Assert.assertEquals(2, numJobsComplete.get());
            }
        }, mockGroupFlowInputGenParams);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        flow.execute(
        Assert.assertEquals(props, flow.getParentProps());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan)
        {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
                Assert.assertEquals(2, numJobsComplete.get());
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        Assert.assertEquals(props, flow.getParentProps());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
        Assert.assertEquals(null, flow.getException());
<<<<<<< HEAD

        EasyMock.verify(props);
        EasyMock.reset(props);

        EasyMock.expect(props.equalsProps(props)).andReturn(false).once();

        EasyMock.replay(props);

        boolean exceptionThrown = false;
        try {
            flow.execute(
                    props,
                    new FlowCallback() {
                        @Override
                        public void progressMade() {
                        }

                        @Override
                        public void completed(Status status) {
                        }
                    }
            );
        }
        catch (IllegalArgumentException e) {
            exceptionThrown = true;
        }

        Assert.assertTrue("Expected an IllegalArgumentException to be thrown because props weren't the same.", exceptionThrown);
=======
        
        // The output should be the union of the input params to the job _ the generated output params
        // from after the job ran.
        Props flowGeneratedProps = flow.getFlowGeneratedProperties();
        Assert.assertFalse(flowGeneratedProps == null);
        Assert.assertEquals(flowGeneratedProps.get("junit.mockFlow1"), "mockGen1");
        Assert.assertEquals(flowGeneratedProps.get("junit.mockFlow2"), "mockGen2");
        Assert.assertEquals(flowGeneratedProps.get("junit.groupFlow"), "groupFlowGen");
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
    }

    @Test
Solution content 
        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
        Assert.assertEquals(null, flow.getException());

        EasyMock.verify(props);
        EasyMock.reset(props);

        EasyMock.expect(props.equalsProps(props)).andReturn(false).once();

        EasyMock.replay(props);

        boolean exceptionThrown = false;
        try {
            flow.execute(
                    props,
                    new FlowCallback() {
                        @Override
                        public void progressMade() {
                        }

                        @Override
                        public void completed(Status status) {
                        }
                    }
            );
        }
        catch (IllegalArgumentException e) {
            exceptionThrown = true;
        }

        Assert.assertTrue("Expected an IllegalArgumentException to be thrown because props weren't the same.", exceptionThrown);
    }

    @Test
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Comment
Method invocation
Try statement
Variable
Chunk
Conflicting content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
=======
        mockFlow1.execute(EasyMock.capture(flow1Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            public void theCallback(Status status) {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.FAILED, flow.getStatus());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan)
        {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        Assert.assertEquals(Status.FAILED, flow.getStatus());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
=======
        mockFlow1.execute(EasyMock.capture(flow1Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
<<<<<<< HEAD
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
=======
        mockFlow2.execute(EasyMock.capture(flow2Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            public void theCallback(Status status) {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.FAILED, flow.getStatus());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan)
        {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
                Assert.assertEquals(2, numJobsComplete.get());
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        Assert.assertEquals(Status.FAILED, flow.getStatus());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
=======
        mockFlow1.execute(EasyMock.capture(flow1Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow1 ****/
        final Capture flow1Callback = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(flow1Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

<<<<<<< HEAD
                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });
=======
                flow.execute(new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                flow1Callback.getValue().completed(Status.SUCCEEDED);
Solution content 
                Assert.assertEquals(Status.RUNNING, flow.getStatus());
                Assert.assertEquals(1, numJobsComplete.incrementAndGet());

                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });

                flow1Callback.getValue().completed(Status.SUCCEEDED);
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
<<<<<<< HEAD
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
=======
        mockFlow2.execute(EasyMock.capture(flow2Callback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
Solution content 
        /**** Setup mockFlow2 ****/
        final Capture flow2Callback = new Capture();
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(flow2Callback));
        EasyMock.expectLastCall().andAnswer(new IAnswer() {
            @Override
            public Void answer() throws Throwable {
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            public void theCallback(Status status) {
                Assert.assertEquals(Status.SUCCEEDED, status);
                Assert.assertEquals(2, numJobsComplete.get());
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        /**** Start the test ****/
        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    public void theCallback(Status status) {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan)
        {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
                Assert.assertEquals(2, numJobsComplete.get());
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                        Assert.assertEquals(2, numJobsComplete.get());
                    }
                });

        Assert.assertTrue("Callback wasn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        completedJob2.markCompleted();

        AtomicBoolean callbackWasCalled = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackWasCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackWasCalled)
        {
            @Override
            public void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback wasn't called!?", callbackWasCalled.get());
        EasyMock.verify(factory);
Solution content 
        completedJob2.markCompleted();

        AtomicBoolean callbackWasCalled = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackWasCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Callback wasn't called!?", callbackWasCalled.get());
        EasyMock.verify(factory);
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(mockFlow1.getEndTime()).andReturn(falseEndTime).once();
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(falseStartTime).once();
        EasyMock.expect(mockFlow2.getEndTime()).andReturn(expectedEndTime).once();
<<<<<<< HEAD

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
        EasyMock.expect(props.equalsProps(props)).andReturn(true).once();

        EasyMock.replay(mockFlow1, mockFlow2, props);
=======
        
        // These are called by mockFlow1.getValue().completed(Status.SUCCEEDED);
        EasyMock.expect(mockFlow1.getFlowGeneratedProperties()).andReturn(new Props()).once();
        EasyMock.expect(mockFlow1.getName()).andReturn("mockFlow1").once();
        
        // These are called by mockFlow2.getValue().completed(Status.SUCCEEDED);
        EasyMock.expect(mockFlow2.getFlowGeneratedProperties()).andReturn(new Props()).once();
        EasyMock.expect(mockFlow2.getName()).andReturn("mockFlow2").once();
                
        EasyMock.replay(mockFlow1, mockFlow2);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        flow = new GroupedExecutableFlow("blah", mockFlow1, mockFlow2);
Solution content 
        EasyMock.expect(mockFlow1.getEndTime()).andReturn(falseEndTime).once();
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(falseStartTime).once();
        EasyMock.expect(mockFlow2.getEndTime()).andReturn(expectedEndTime).once();

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
        EasyMock.expect(props.equalsProps(props)).andReturn(true).once();

        EasyMock.replay(mockFlow1, mockFlow2, props);

        flow = new GroupedExecutableFlow("blah", mockFlow1, mockFlow2);
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Comment
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(null).once();

        Capture callbackCapture = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture));
=======
        mockFlow1.execute(EasyMock.capture(callbackCapture), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
Solution content 
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(null).once();

        Capture callbackCapture = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture));

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(expectedStartTime).once();

        Capture callbackCapture = new Capture();
<<<<<<< HEAD
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture));
=======
        mockFlow2.execute(EasyMock.capture(callbackCapture), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
Solution content 
        EasyMock.expect(mockFlow2.getStartTime()).andReturn(expectedStartTime).once();

        Capture callbackCapture = new Capture();
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture));

        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Capture callbackCapture1 = new Capture();
        Capture callbackCapture2 = new Capture();
<<<<<<< HEAD
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture1));
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture2));
=======
        mockFlow1.execute(EasyMock.capture(callbackCapture1), EasyMock.isA(Props.class));
        mockFlow2.execute(EasyMock.capture(callbackCapture2), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
Solution content 
        Capture callbackCapture1 = new Capture();
        Capture callbackCapture2 = new Capture();
        mockFlow1.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture1));
        mockFlow2.execute(EasyMock.eq(props), EasyMock.capture(callbackCapture2));

        EasyMock.expect(mockFlow1.getParentProps()).andReturn(props).once();
        EasyMock.expect(mockFlow2.getParentProps()).andReturn(props).once();
File
GroupedExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.replay(mockJob, jobManager);

        Assert.assertEquals(Status.READY, executableFlow.getStatus());
<<<<<<< HEAD

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
=======
        
        executableFlow.execute(new FlowCallback()
        {
            @Override
            public void progressMade()
            {
                assertionViolated.set(true);
                reason = String.format("progressMade() shouldn't actually be called.");
            }

            @Override
            public void completed(Status status)
            {
                completionLatch.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, inputGeneratedProps);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
Solution content 
        EasyMock.replay(mockJob, jobManager);

        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.FAILED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new FlowCallback()
        {
            @Override
            public void progressMade()
            {
                assertionViolated.set(true);
                reason = String.format("progressMade() shouldn't actually be called.");
            }

            @Override
            public void completed(Status status)
            {
                completionLatch.countDown();
                if (Status.FAILED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback: status[%s] != Status.FAILED", status);
                }
            }
        }, p);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.FAILED, executableFlow.getStatus());
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.FAILED", status);
                        }
                    }
                });

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.FAILED, executableFlow.getStatus());
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        final AtomicBoolean firstCallbackCalled = new AtomicBoolean(false);
<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(firstCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        firstCallbackLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback1: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(secondCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        secondCallbackLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback2: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new OneCallFlowCallback(firstCallbackCalled)
        {
            @Override
            public void theCallback(Status status)
            {
                firstCallbackLatch.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback1: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, p);

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(new OneCallFlowCallback(secondCallbackCalled)
        {
            @Override
            public void theCallback(Status status)
            {
                secondCallbackLatch.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback2: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        firstCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
        secondCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        final AtomicBoolean firstCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(firstCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        firstCallbackLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);

                            reason = String.format("In executableFlow Callback1: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(secondCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        secondCallbackLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback2: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
        firstCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
        secondCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Variable
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        final AtomicBoolean firstCallbackCalled = new AtomicBoolean(false);
<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(firstCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        firstCallbackLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback1: status[%s] != Status.FAILED", status);
                        }
                    }
                });

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(secondCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        secondCallbackLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback2: status[%s] != Status.FAILED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new OneCallFlowCallback(firstCallbackCalled)
        {
            @Override
            public void theCallback(Status status)
            {
                firstCallbackLatch.countDown();
                if (Status.FAILED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback1: status[%s] != Status.FAILED", status);
                }
            }
        }, p);

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(new OneCallFlowCallback(secondCallbackCalled)
        {
            @Override
            public void theCallback(Status status)
            {
                secondCallbackLatch.countDown();
                if (Status.FAILED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback2: status[%s] != Status.FAILED", status);
                }
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        firstCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
        secondCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        final AtomicBoolean firstCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(firstCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        firstCallbackLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback1: status[%s] != Status.FAILED", status);
                        }
                    }
                });

        final AtomicBoolean secondCallbackCalled = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(secondCallbackCalled)
                {
                    @Override
                    public void theCallback(Status status)
                    {
                        secondCallbackLatch.countDown();
                        if (Status.FAILED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback2: status[%s] != Status.FAILED", status);
                        }
                    }
                });

        firstCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
        secondCallbackLatch.await(1000, TimeUnit.MILLISECONDS);
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Variable
Chunk
Conflicting content 
            @Override
        {

        Assert.assertEquals(Status.READY, executableFlow.getStatus());

<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new FlowCallback()
            public void progressMade()
            {
                assertionViolated.set(true);
                reason = String.format("progressMade() shouldn't actually be called.");
            }

            @Override
            public void completed(Status status)
            {
                completionLatch.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, p);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch2.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new FlowCallback()
        {
            @Override
            public void progressMade()
            {
                assertionViolated.set(true);
                reason = String.format("progressMade() shouldn't actually be called.");
            }

            @Override
            public void completed(Status status)
            {
                completionLatch2.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, p);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        completionLatch2.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch2.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        completionLatch2.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });
=======
        executableFlow.execute(new FlowCallback()
        {
            @Override
            public void progressMade()
            {
                assertionViolated.set(true);
                reason = String.format("progressMade() shouldn't actually be called.");
            }

            @Override
            public void completed(Status status)
            {
                completionLatch.countDown();
                if (Status.SUCCEEDED != status) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                }
            }
        }, p);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
Solution content 
        Assert.assertEquals(Status.READY, executableFlow.getStatus());

        executableFlow.execute(
                overrideProps,
                new FlowCallback()
                {
                    @Override
                    public void progressMade()
                    {
                        assertionViolated.set(true);
                        reason = String.format("progressMade() shouldn't actually be called.");
                    }

                    @Override
                    public void completed(Status status)
                    {
                        completionLatch.countDown();
                        if (Status.SUCCEEDED != status) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow Callback: status[%s] != Status.SUCCEEDED", status);
                        }
                    }
                });

        completionLatch.await(1000, TimeUnit.MILLISECONDS);
        Assert.assertEquals(Status.SUCCEEDED, executableFlow.getStatus());
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        }).start();

        AtomicBoolean runOnce = new AtomicBoolean(false);
<<<<<<< HEAD
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(runOnce)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        if (status != Status.FAILED) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow callback: status[%s] != Status.FAILED", status);
                            return;
                        }

                        if (! (runLatch.getCount() == 1 && cancelLatch.getCount() == 0)) {
                            assertionViolated.set(true);
                            reason = String.format(
                                    "In executableFlow callback: ! (runLatch.count[%s] == 1 && cancelLatch.count[%s] == 0)",
                                    runLatch.getCount(),
                                    cancelLatch.getCount()
                            );
                        }
                    }
                });
=======
        executableFlow.execute(new OneCallFlowCallback(runOnce)
        {
            @Override
            protected void theCallback(Status status)
            {
                if (status != Status.FAILED) {
                    assertionViolated.set(true);
                    reason = String.format("In executableFlow callback: status[%s] != Status.FAILED", status);
                    return;
                }

                if (! (runLatch.getCount() == 1 && cancelLatch.getCount() == 0)) {
                    assertionViolated.set(true);
                    reason = String.format(
                            "In executableFlow callback: ! (runLatch.count[%s] == 1 && cancelLatch.count[%s] == 0)",
                            runLatch.getCount(),
                            cancelLatch.getCount()
                    );
                }
            }
        }, p);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Expected callback to be called once.", runOnce.get());
    }
Solution content 
        }).start();

        AtomicBoolean runOnce = new AtomicBoolean(false);
        executableFlow.execute(
                overrideProps,
                new OneCallFlowCallback(runOnce)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                        if (status != Status.FAILED) {
                            assertionViolated.set(true);
                            reason = String.format("In executableFlow callback: status[%s] != Status.FAILED", status);
                            return;
                        }

                        if (! (runLatch.getCount() == 1 && cancelLatch.getCount() == 0)) {
                            assertionViolated.set(true);
                            reason = String.format(
                                    "In executableFlow callback: ! (runLatch.count[%s] == 1 && cancelLatch.count[%s] == 0)",
                                    runLatch.getCount(),
                                    cancelLatch.getCount()
                            );
                        }
                    }
                });

        Assert.assertTrue("Expected callback to be called once.", runOnce.get());
    }
File
IndividualJobExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
import org.junit.Test;

import java.util.concurrent.atomic.AtomicBoolean;
<<<<<<< HEAD
=======

import azkaban.common.utils.Props;
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

/**
 *
Solution content 
import org.junit.Test;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 *
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Import
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependeeFlow.getName()).andReturn("dependee").once();

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.replay(props);

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        flow.execute(

        callbackRan = new AtomicBoolean(false);
        EasyMock.replay(props);
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.replay(props);
        
        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        EasyMock.replay(props);
        
        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean dependeeRan = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").times(1);

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.replay(props);
        
        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.FAILED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
Solution content 
        EasyMock.replay(props);
        
        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.FAILED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.FAILED, flow.getStatus());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        final AtomicBoolean executeCallWhileStateWasRunningHadItsCallbackCalled = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
<<<<<<< HEAD
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
=======
        dependeeFlow.execute(EasyMock.capture(dependeeCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final AtomicBoolean executeCallWhileStateWasRunningHadItsCallbackCalled = new AtomicBoolean(false);

        final Capture dependeeCallback = new Capture();
        dependeeFlow.execute(EasyMock.eq(props), EasyMock.capture(dependeeCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
                Assert.assertTrue("Dependee already ran!?", dependeeRan.compareAndSet(false, true));
                Assert.assertEquals(Status.RUNNING, flow.getStatus());

<<<<<<< HEAD
                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });
=======
                flow.execute(new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                {
                    @Override
                    protected void theCallback(Status status)
                    {
                    }
                }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

                dependeeCallback.getValue().completed(Status.SUCCEEDED);
Solution content 
                Assert.assertTrue("Dependee already ran!?", dependeeRan.compareAndSet(false, true));
                Assert.assertEquals(Status.RUNNING, flow.getStatus());

                flow.execute(
                        props,
                        new OneCallFlowCallback(executeCallWhileStateWasRunningHadItsCallbackCalled)
                        {
                            @Override
                            protected void theCallback(Status status)
                            {
                            }
                        });

                dependeeCallback.getValue().completed(Status.SUCCEEDED);
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        EasyMock.expect(dependerFlow.getName()).andReturn("depender").times(1);

        final Capture dependerCallback = new Capture();
<<<<<<< HEAD
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
=======
        dependerFlow.execute(EasyMock.capture(dependerCallback), EasyMock.isA(Props.class));
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
Solution content 
        final Capture dependerCallback = new Capture();
        dependerFlow.execute(EasyMock.eq(props), EasyMock.capture(dependerCallback));
        EasyMock.expectLastCall().andAnswer(new IAnswer()
        {
            @Override
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, new Props());
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
Solution content 
        Assert.assertEquals(Status.READY, flow.getStatus());

        AtomicBoolean callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Internal flow executes never ran.", dependeeRan.get());
        Assert.assertTrue("Callback didn't run.", callbackRan.get());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation
Chunk
Conflicting content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
<<<<<<< HEAD
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });
=======
        flow.execute(new OneCallFlowCallback(callbackRan) {
            @Override
            protected void theCallback(Status status)
            {
                Assert.assertEquals(Status.SUCCEEDED, status);
            }
        }, null);
>>>>>>> bddd9a21858a9c4cde255968c83e2b9164eccc82

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
Solution content 
        Assert.assertEquals(null, flow.getException());

        callbackRan = new AtomicBoolean(false);
        flow.execute(
                props,
                new OneCallFlowCallback(callbackRan) {
                    @Override
                    protected void theCallback(Status status)
                    {
                        Assert.assertEquals(Status.SUCCEEDED, status);
                    }
                });

        Assert.assertTrue("Callback didn't run.", callbackRan.get());
        Assert.assertEquals(Status.SUCCEEDED, flow.getStatus());
File
MultipleDependencyExecutableFlowTest.java
Developer's decision
Version 1
Kind of conflict
Method invocation