Java CucumberException类代码示例

import cucumber.runtime.CucumberException; //导入依赖的package包/类
public File getOutputFile(Class testClass) {
	if(testClass == null) {
		throw new IllegalArgumentException("testClass cannot be null");
	}

	try {
		File outputFolder = new File(Constants.RESULTS_FOLDER);
		Files.createDirectories(outputFolder.toPath()); // if directory already exists will do nothing

		//testClass.getName() is the unique identifier of the class
		String fileName = String.format("%s_%s", testClass.getName(), Constants.RESULTS_FILE_NAME_POSTFIX);
		File outputFile = new File(outputFolder, fileName);
		outputFile.createNewFile(); // if file already exists will do nothing
		return outputFile;
	} catch (IOException e) {
		throw new CucumberException(Constants.errorPrefix + "Failed to create cucumber results output directory", e);
	}
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
private ResourceLoader getResourceLoader() {
	List<Path> fileSystemFeaturePaths = getFileSystemFeaturePaths();
	if (fileSystemFeaturePaths.size() == 0)
		return new MultiLoader(cucumberClassLoader);
	URL[] urls = new URL[fileSystemFeaturePaths.size()];
	int index = 0;
	for (Path featurePath : fileSystemFeaturePaths) {
		try {
			urls[index] = featurePath.toUri().toURL();
		} catch (MalformedURLException e) {
			throw new CucumberException(e);
		}
		index++;
	}
	URLClassLoader featuresLoader = new URLClassLoader(urls, cucumberClassLoader);
	return new MultiLoader(featuresLoader);
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
public byte run() throws InterruptedException, IOException {
	byte result = 0;
	ExecutorService executor = Executors.newFixedThreadPool(rerunFiles.size());
	List<CucumberRuntimeCallable> runtimes = new ArrayList<CucumberRuntimeCallable>();
	for (Path rerunFile : rerunFiles) {
		CucumberRuntimeCallable runtimeCallable = new CucumberRuntimeCallable(buildCallableRuntimeArgs(rerunFile),
				runtimeFactory);
		runtimes.add(runtimeCallable);
	}
	List<Future<Byte>> futures = executor.invokeAll(runtimes);
	executor.shutdown();
	for (Future<Byte> future : futures)
		try {
			byte callableResult = future.get();
			result |= callableResult;
		} catch (ExecutionException e) {
			if (e.getCause() instanceof CucumberException)
				throw (CucumberException) e.getCause();
			else
				throw new CucumberException(e.getCause());
		}
	return result;
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
private void buildFeatureElementRunners() {
   for (CucumberTagStatement cucumberTagStatement : cucumberFeature
      .getFeatureElements()) {
      try {
         ParentRunner<?> featureElementRunner;
         if (cucumberTagStatement instanceof CucumberScenario) {
            featureElementRunner =
               new RestExecutionUnitRunner(runtime, cucumberTagStatement,
                  jUnitReporter, cucumberFeature);
         } else {
            featureElementRunner =
               new RestScenarioOutlineRunner(runtime,
                  (CucumberScenarioOutline) cucumberTagStatement, jUnitReporter,
                  cucumberFeature);
         }
         children.add(featureElementRunner);
      } catch (InitializationError e) {
         throw new CucumberException("Failed to create scenario runner", e);
      }
   }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
/**
 * Constructor of cucumberReporter.
 *
 * @param url url
 * @param cClass class
 * @throws IOException exception
 */
public CucumberReporter(String url, String cClass, String additional) throws IOException {
    this.url = url;
    this.cClass = cClass;
    this.additional = additional;

    try {
        document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        results = document.createElement("testng-results");
        suite = document.createElement("suite");
        test = document.createElement("test");
        callerClass = cClass;
        suite.appendChild(test);
        results.appendChild(suite);
        document.appendChild(results);
        jUnitDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        jUnitResults = jUnitDocument.createElement("testsuites");
        jUnitSuite = jUnitDocument.createElement("testsuite");
        jUnitDocument.appendChild(jUnitResults);
        jUnitResults.appendChild(jUnitSuite);
    } catch (ParserConfigurationException e) {
        throw new CucumberException("Error initializing DocumentBuilder.", e);
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
/**
 * Run the testclases(Features).
 *
 * @throws IOException exception
 * @throws NoSuchMethodException exception
 * @throws InvocationTargetException exception
 * @throws IllegalAccessException exception
 */
public void runCukes() throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

    runtime.run();

    if (!runtime.getErrors().isEmpty()) {
        Iterator<Throwable> iterator = runtime.getErrors().iterator();
        while (iterator.hasNext()) {
            Throwable value = iterator.next();
            if (value.getMessage().contains("TESTS EXECUTION ABORTED!")) {
                iterator.remove();
            }
        }
        logger.error ("Got {} exceptions", runtime.getErrors());
        throw new CucumberException(runtime.getErrors().get(0));
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
@Override
public void execute(Scenario scenario) throws Throwable {
    Object[] args;
    switch (method.getParameterTypes().length) {
        case 0:
            args = new Object[0];
            break;
        case 1:
            if (!Scenario.class.equals(method.getParameterTypes()[0])) {
                throw new CucumberException("When a hook declares an argument it must be of type " + Scenario.class.getName() + ". " + method.toString());
            }
            args = new Object[]{scenario};
            break;
        default:
            throw new CucumberException("Hooks must declare 0 or 1 arguments. " + method.toString());
    }

    Utils.invoke(objectFactory.getInstance(method.getDeclaringClass()), method, timeout, args);
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
/**
 * Registers step definitions and hooks.
 *
 * @param androidBackend the backend where stepdefs and hooks will be registered.
 * @param method         a candidate for being a stepdef or hook.
 * @param glueCodeClass  the class where the method is declared.
 */
void scan(AndroidBackend androidBackend, Method method, Class<?> glueCodeClass) {
    for (Class<? extends Annotation> cucumberAnnotationClass : mCucumberAnnotationClasses) {
        Annotation annotation = method.getAnnotation(cucumberAnnotationClass);
        if (annotation != null) {
            if (!method.getDeclaringClass().isAssignableFrom(glueCodeClass)) {
                throw new CucumberException(String.format("%s isn't assignable from %s", method.getDeclaringClass(), glueCodeClass));
            }
            if (!glueCodeClass.equals(method.getDeclaringClass())) {
                throw new CucumberException(String.format("You're not allowed to extend classes that define Step Definitions or hooks. %s extends %s", glueCodeClass, method.getDeclaringClass()));
            }
            if (isHookAnnotation(annotation)) {
                androidBackend.addHook(annotation, method);
            } else if (isStepdefAnnotation(annotation)) {
                androidBackend.addStepDefinition(annotation, method);
            }
        }
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
protected Step extractStep(final StepDefinitionMatch match) {
    try {
        final Field step = match.getClass().getDeclaredField("step");
        step.setAccessible(true);
        return (Step) step.get(match);
    } catch (ReflectiveOperationException e) {
        //shouldn't ever happen
        LOG.error(e.getMessage(), e);
        throw new CucumberException(e);
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
public KarateJunitFormatter(String featurePath, String reportPath) throws IOException {
    this.featurePath = featurePath;
    this.reportPath = reportPath;
    logger.trace(">> {}", reportPath);
    URL url = FileUtils.toFileUrl(reportPath);
    this.out = new UTF8OutputStreamWriter(new URLOutputStream(url));
    try {
        doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        rootElement = doc.createElement("testsuite");
        doc.appendChild(rootElement);
    } catch (ParserConfigurationException e) {
        throw new CucumberException("Error while processing unit report", e);
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
@Override
public void done() {
    try {
        String featureName = StringUtils.trimToNull(testCase.feature.getName());
        if (featureName == null) {
            featureName = featurePath;
        }
        rootElement.setAttribute("name", featureName);
        testCount = Integer.valueOf(rootElement.getAttribute("tests"));
        failCount = rootElement.getElementsByTagName("failure").getLength();
        rootElement.setAttribute("failures", String.valueOf(failCount));
        skipCount = rootElement.getElementsByTagName("skipped").getLength();
        rootElement.setAttribute("skipped", String.valueOf(skipCount));
        timeTaken = sumTimes(rootElement.getElementsByTagName("testcase"));
        rootElement.setAttribute("time", formatTime(timeTaken));
        printStatsToConsole();
        if (rootElement.getElementsByTagName("testcase").getLength() == 0) {
            addDummyTestCase(); // to avoid failed Jenkins jobs
        }
        TransformerFactory transfac = TransformerFactory.newInstance();
        Transformer trans = transfac.newTransformer();
        trans.setOutputProperty(OutputKeys.INDENT, "yes");
        StreamResult result = new StreamResult(out);
        DOMSource source = new DOMSource(doc);
        trans.transform(source, result);
    } catch (TransformerException e) {
        throw new CucumberException("Error while transforming.", e);
    }
    logger.trace("<< {}", reportPath);
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
public HPEAlmOctaneGherkinFormatter(ResourceLoader resourceLoader, List<String> features, OutputFile outputFile) {
    cucumberFeatures = features;
    cucumberResourceLoader = resourceLoader;
    this.outputFile = outputFile;
    try {
        _doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        _rootElement = _doc.createElement(GherkinSerializer.ROOT_TAG_NAME);
        _rootElement.setAttribute("version",Constants.XML_VERSION);
        _doc.appendChild(_rootElement);
    } catch (ParserConfigurationException e) {
        throw new CucumberException(Constants.errorPrefix + "Failed to create xml document",e);
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
private void addFeatureFileInfo(String featureFile) {
    try {
        Resource resource = findResource(featureFile);
        FeatureBuilder builder = new FeatureBuilder(new ArrayList<CucumberFeature>());
        _currentFeature.setPath(((FileResource) resource).getFile().getPath());
        _currentFeature.setFile(builder.read(resource));
    } catch (Exception e) {
        throw new CucumberException(Constants.errorPrefix + "Failed to find feature file:" + featureFile ,e);
    }
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
public void write(Document doc) {
	File file = getOutputFile(testClass);
	try (FileOutputStream outputStream = new FileOutputStream(file)) {
		DOMImplementationRegistry reg = DOMImplementationRegistry.newInstance();
		DOMImplementationLS impl = (DOMImplementationLS) reg.getDOMImplementation("LS");
		LSSerializer serializer = impl.createLSSerializer();
		LSOutput output = impl.createLSOutput();
		output.setByteStream(outputStream);
		serializer.write(doc, output);
	} catch (Exception e) {
		throw new CucumberException(Constants.errorPrefix + "Failed to write document to disc", e);
	}
}
 

import cucumber.runtime.CucumberException; //导入依赖的package包/类
@Override
public void tearDown() {
    try {
        getAppiumDriver().runAppInBackground(2);
    }
    catch (Exception e) {
        throw new CucumberException("Failed to collect code coverage data!", e);
    }
}