Java Backend类代码示例

import cucumber.runtime.Backend; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void closeWebDriverPool() {
  try {
    Runtime runtime = (Runtime) FieldUtils.readField(this, "runtime", true);
    Collection<? extends Backend> backends =
        (Collection<? extends Backend>) FieldUtils.readField(runtime, "backends", true);
    for (Backend backend : backends) {
      if (backend instanceof JavaBackend) {
        GuiceFactory factory =
            (GuiceFactory) FieldUtils.readField(backend, "objectFactory", true);
        WebDriverRegistry webDriverRegistry = factory.getInstance(WebDriverRegistry.class);
        webDriverRegistry.shutdown();
      }
    }
  } catch (IllegalAccessException e) {
    LOG.error("unable to close web driver pool", e);
  }
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
@Override
public void onCreate(Bundle arguments) {
    Context context = getContext();
    Properties properties = new Properties();
    String glue = context.getPackageName();
    String features = "features";

    properties.setProperty("cucumber.options", String.format("-g %s %s", glue, features));
    mRuntimeOptions = new RuntimeOptions(properties);

    mResourceLoader = new AndroidResourceLoader(context);
    List<Backend> backends = new ArrayList<Backend>();
    backends.add(new AndroidBackend(this));
    mRuntime = new Runtime(mResourceLoader, getLoader(), backends, mRuntimeOptions);

    mFormatter = new AndroidFormatter(TAG);
    mRuntimeOptions.formatters.clear();
    mRuntimeOptions.formatters.add(mFormatter);

    super.onCreate(arguments);
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
@Before
public void setUp() throws Exception {

	when(i18n.keywords(GIVEN)).thenReturn(Arrays.asList(GIVEN));
	when(scenario.getId()).thenReturn(SCENARIO_ID);

	List<Backend> backends = Arrays.asList(backend);
	threadLoggedRuntime = new ThreadLoggedRuntime(resourceLoader, classLoader, backends, runtimeOptions, threadExecutionRecorder);
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
@Override
public List<Backend> getBackends() {
	wasInvoked = true;
	ResourceLoader resourceLoader = new MultiLoader(Thread.currentThread().getContextClassLoader());
	Backend backend = new JavaBackend(resourceLoader);
	return Arrays.asList(backend);
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
protected List<Backend> allBackends() throws IOException {
    ArrayList<RemoteBackend> remoteBackends = Lists.newArrayList();
    for (RemoteBackendProperties remoteBackendProperties : cucumberProperties.getRemoteBackends()) {
        remoteBackends.add(remoteBackendProperties.createRemoteBackend());
    }
    Backend miniumBackend = rhinoEngine.runWithContext(rhinoEngine.new RhinoCallable<Backend, IOException>() {
        @Override
        protected Backend doCall(Context cx, Scriptable scope) throws IOException {
            return new MiniumBackend(resourceLoader, cx, scope);
        }
    });
    return ImmutableList.<Backend> builder().add(miniumBackend).addAll(remoteBackends).build();
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public ThreadLoggedRuntime(ResourceLoader resourceLoader, ClassLoader classLoader,
		Collection<? extends Backend> backends, RuntimeOptions runtimeOptions,
		ThreadExecutionRecorder threadExecutionRecorder) {
	super(resourceLoader, classLoader, backends, runtimeOptions);
	this.threadExecutionRecorder = threadExecutionRecorder;
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public BackendRegistry register(String name, Backend backend) {
    Preconditions.checkState(!backends.containsKey(name), "Backend with name %s already registered", name);
    backends.put(name, backend);
    return this;
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public Map<String, Backend> getAll() {
    return new HashMap<String, Backend>(backends);
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public BackendContext(String backendName, Backend backend) {
    this.backendName = backendName;
    this.backend = backend;
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public CucumberRestController(Backend backend) {
    this(new BackendRegistry().register(DEFAULT_BACKEND, backend));
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
@Bean(name = "mockedBackend")
public Backend backendMock() {
    return mock(Backend.class);
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
@Bean
public Backend backend() {
    return new JavaBackend(resourceLoader());
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
public RuntimeBuilder withBackends(Backend ... backends) {
    return withBackends(Arrays.asList(backends));
}
 

import cucumber.runtime.Backend; //导入依赖的package包/类
List<Backend> getBackends();