Java StoryDuration类代码示例

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyCancelled(Story story, StoryDuration storyDuration) {
    crossReferencing.storyCancelled(story, storyDuration);
    if (multiThreading) {
        delayedMethods.add(new DelayedMethod(storyCancelled, story, storyDuration));
    } else {
        delegate.storyCancelled(story, storyDuration);
    }
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
@Test
public void shouldReportStoryCancellation(){
    // Given
    Configuration configuration = mock(Configuration.class,Mockito.RETURNS_DEEP_STUBS);
    when(configuration.storyControls().dryRun()).thenReturn(false);
    StoryReporter reporter = mock(ConcurrentStoryReporter.class);
    when(configuration.storyReporter(Matchers.anyString())).thenReturn(reporter);
    
    Story story = mock(Story.class);
    String storyPath = "story/path";
    when(story.getPath()).thenReturn(storyPath);
    RuntimeException expected = new RuntimeException();
    when(story.getMeta()).thenThrow(expected);
    
    InjectableStepsFactory stepsFactory = mock(InjectableStepsFactory.class);
    MetaFilter metaFilter = mock(MetaFilter.class);
    State state = mock(State.class);

    //When
    long durationInSecs = 2;
    long timeoutInSecs = 1;
    StoryDuration storyDuration = new StoryDuration(durationInSecs, timeoutInSecs);
    try {
        StoryRunner runner = new StoryRunner();
        runner.cancelStory(story, storyDuration);
        runner.run(configuration, stepsFactory, story, metaFilter, state);
        fail("A exception should be thrown");
    } catch (Throwable e) {
    //Then
        assertThat(e.equals(expected), is(true));
    }        
    verify(reporter).storyCancelled(story, storyDuration);
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
private void testStoryIfTimeoutIsSet(Answer<StoryRunner> answer) throws Throwable {
    // Given
    long timeoutInSecs = 1;

    StoryRunner runner = mock(StoryRunner.class);
    EmbedderMonitor monitor = mock(EmbedderMonitor.class);

    EmbedderControls embedderControls = new EmbedderControls().useStoryTimeoutInSecs(timeoutInSecs);

    Embedder embedder = embedderWith(runner, embedderControls, monitor);
    Configuration configuration = embedder.configuration();
    StoryPathResolver resolver = configuration.storyPathResolver();

    List<String> storyPaths = new ArrayList<String>();
    String storyPath = resolver.resolve(MyStory.class);
    storyPaths.add(storyPath);
    Story story = mockStory(Meta.EMPTY);
    when(story.getPath()).thenReturn(storyPath);
    when(runner.storyOfPath(configuration, storyPath)).thenReturn(story);

    Mockito.doAnswer(answer)
            .when(runner)
            .run(Matchers.any(Configuration.class), Matchers.any(InjectableStepsFactory.class), Matchers.eq(story),
                    Matchers.any(MetaFilter.class), Matchers.any(State.class));

    // When
    boolean exceptionWasThrown = false;
    try {
        embedder.runStoriesAsPaths(storyPaths);
    } catch (Exception exception) {
        exceptionWasThrown = true;
    }

    // Then
    assertThat(exceptionWasThrown, is(true));
    verify(runner).cancelStory(Matchers.eq(story), Matchers.any(StoryDuration.class));
    verify(monitor).storyTimeout(Matchers.eq(story), Matchers.any(StoryDuration.class));
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
@Override
public void storyCancelled(Story story, StoryDuration storyDuration) {
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
@Override
public void storyCancelled(Story story, StoryDuration storyDuration)
{
  // TODO: May 15, 2014 (fpedroza) - evaluate usefulness
  LOG.info("LoggingStoryReporter.storyCancelled() - {} {}", story, storyDuration);
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyTimeout(Story story, StoryDuration storyDuration) {
    log("Story " + story.getPath() + " duration of " + storyDuration.getDurationInSecs()
            + " seconds has exceeded timeout of " + storyDuration.getTimeoutInSecs() + " seconds", MSG_INFO);
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyTimeout(Story story, StoryDuration storyDuration) {
    getLog().warn(
            "Story " + story.getPath() + " duration of " + storyDuration.getDurationInSecs()
                    + " seconds has exceeded timeout of " + storyDuration.getTimeoutInSecs() + " seconds");
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyTimeout(Story story, StoryDuration storyDuration) {
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyTimeout(Story story, StoryDuration storyDuration) {
    print("Story " + story.getPath() + " duration of " + storyDuration.getDurationInSecs()
            + " seconds has exceeded timeout of " + storyDuration.getTimeoutInSecs() + " seconds");
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyTimeout(Story story, StoryDuration storyDuration) {
    delegate.storyTimeout(story, storyDuration);
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyCancelled(Story story, StoryDuration storyDuration) {
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyCancelled(Story story, StoryDuration storyDuration) {
    this.outputStory.cancelled = true;
    this.outputStory.storyDuration = storyDuration;
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public StoryDuration getStoryDuration() {
    return storyDuration;
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyCancelled(Story story, StoryDuration storyDuration) {
    add("cancelled");
}
 

import org.jbehave.core.model.StoryDuration; //导入依赖的package包/类
public void storyCancelled(Story story, StoryDuration storyDuration) {
    print(format("storyCancelled", "{0}: {1} ({2} s)\n", keywords.storyCancelled(), keywords.duration(),
            storyDuration.getDurationInSecs()));
}