org.testfx.util.WaitForAsyncUtils Java Examples

@Test
public void testMoveViewPort(final FxRobot robot) {
	Platform.runLater(() -> {
		try {
			app.getMainStage().showAndWait();
		}catch(final IllegalStateException ignored) {
			// Already visible
		}
	});
	WaitForAsyncUtils.waitForFxEvents();
	final ScrollPane pane = robot.lookup("#scrollPane").query();
	final double hvalue = pane.getHvalue();
	final double vvalue = pane.getVvalue();
	robot.drag("#canvas", MouseButton.MIDDLE).dropBy(100d, 200d);
	WaitForAsyncUtils.waitForFxEvents();
	assertThat(hvalue).isGreaterThan(pane.getHvalue());
	assertThat(vvalue).isGreaterThan(pane.getVvalue());
}
 

@Test
void testOnChangeNbPlotPoints() {
	final List<PathElement> before = duplicatePath(getCurvePath());
	model.setNbPlottedPoints(model.getNbPlottedPoints() + 41);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(before, getCurvePath());
}
 

@Test
void testFillGradient() {
	assumeTrue(model.isFillable());
	model.setFillingStyle(FillingStyle.GRAD);
	WaitForAsyncUtils.waitForFxEvents();
	assertTrue(border.getFill() instanceof LinearGradient);
}
 

@Test
public void testClickPSTActivations() {
	clickOn(tabPane.lookup("#tabPST"));
	WaitForAsyncUtils.waitForFxEvents();

	Mockito.verify(selector, Mockito.times(1)).setActivated(false, false);
	Mockito.verify(paster, Mockito.times(1)).setActivated(false, false);
	Mockito.verify(undo, Mockito.times(1)).setActivated(false, false);
	Mockito.verify(zoomer, Mockito.times(1)).setActivated(false, false);
	Mockito.verify(deleter, Mockito.times(1)).setActivated(false, false);
	Mockito.verify(zoomer, Mockito.times(1)).setActivated(false, false);
}
 

@Test
void testTextProducesImageWhenNotDefaultColour() throws InterruptedException, TimeoutException, ExecutionException {
	model.setLineColour(ShapeFactory.INST.createColorFX(Color.AQUAMARINE));
	WaitForAsyncUtils.waitForFxEvents();
	model.setText("hello");
	view.getCurrentCompilation().get(5, TimeUnit.SECONDS);
	WaitForAsyncUtils.waitForFxEvents();
	assertTrue(BadaboomCollector.INSTANCE.errorsProperty().isEmpty(), () -> HelperTest.getBadaboomMessages());
	assertFalse(getImage().isDisable());
	assertTrue(getImage().isVisible());
}
 

@Test
void testCompilationDataDuringCompilation() throws InterruptedException, TimeoutException, ExecutionException {
	model.setText("$hello$");
	view.getCurrentCompilation().get(5, TimeUnit.SECONDS);
	WaitForAsyncUtils.waitForFxEvents();
	assertTrue(BadaboomCollector.INSTANCE.errorsProperty().isEmpty(), () -> HelperTest.getBadaboomMessages());
	assertTrue(view.getCompilationData().isPresent());
}
 

@Test
void testChangeGridWidthImpactOnLabels() {
	final List<Double> xBefore = view.getLabels().getChildren().stream().map(c -> ((Text) c).getX()).collect(Collectors.toList());
	final List<Double> yBefore = view.getLabels().getChildren().stream().map(c -> ((Text) c).getY()).collect(Collectors.toList());
	model.setGridWidth(43d);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(xBefore, view.getLabels().getChildren().stream().map(c -> ((Text) c).getX()).collect(Collectors.toList()));
	assertNotEquals(yBefore, view.getLabels().getChildren().stream().map(c -> ((Text) c).getY()).collect(Collectors.toList()));
}
 

private PdfDocumentDescriptor populate() throws Exception {
    File file = folder.newFile("temp.pdf");
    PdfLoadRequestEvent loadEvent = new PdfLoadRequestEvent(MODULE);
    PdfDocumentDescriptor ret = PdfDocumentDescriptor.newDescriptorNoPassword(file);
    loadEvent.add(ret);
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> eventStudio().broadcast(loadEvent, MODULE));
    return ret;
}
 

@Override
@Test
void testChangeGridEndX() {
	model.setGridEndX(model.getGridEndX() + 1d);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(ptH1, view.axesHoriz.getModel().getPtAt(0));
	assertNotEquals(ptH2, view.axesHoriz.getModel().getPtAt(1));
	assertEquals(ptV1, view.axesVert.getModel().getPtAt(0));
	assertEquals(ptV2, view.axesVert.getModel().getPtAt(1));
	assertNotEquals(pathTicksBefore, view.pathTicks.getElements());
}
 

@Test
public void logEventOnclickOn() {
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> firstItem.moveStatusTo(PdfDescriptorLoadingStatus.REQUESTED));
    WaitForAsyncUtils.waitForFxEvents();
    Text icon = lookup(".glyph-icon").queryAs(Text.class);
    assertEquals(PdfDescriptorLoadingStatus.REQUESTED.getIcon().unicode(), icon.getText());
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> firstItem.moveStatusTo(PdfDescriptorLoadingStatus.LOADING));
    WaitForAsyncUtils.waitForFxEvents();
    icon = lookup(".glyph-icon").queryAs(Text.class);
    assertEquals(PdfDescriptorLoadingStatus.LOADING.getIcon().unicode(), icon.getText());
}
 

@ParameterizedTest
@EnumSource(ArcStyle.class)
void testClipArrowSameType(final ArcStyle style) {
	assumeTrue(style.supportArrow());
	model.setArcStyle(style);
	model.setArrowStyle(ArrowStyle.RIGHT_ARROW, 0);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(((Arc) view.border.getClip()).getType(), style.getJFXStyle());
}
 

@Test
void testChangeGridWidthImpactOnStrokeWidth() {
	final double strokeBefore = view.getMaingrid().getStrokeWidth();
	model.setGridWidth(21d);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(strokeBefore, view.getMaingrid().getStrokeWidth());
}
 

@Test
void testDashSepBlack() {
	assumeTrue(model.isLineStylable());
	model.setLineStyle(LineStyle.DASHED);
	model.setDashSepBlack(21d);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(Arrays.asList(21d, model.getDashSepWhite()), border.getStrokeDashArray());
}
 

@Test
void testChangeticksStyleFullProperty() {
	model.setTicksStyle(TicksStyle.TOP);
	WaitForAsyncUtils.waitForFxEvents();
	pathTicksBefore = new ArrayList<>(view.pathTicks.getElements());
	model.setTicksStyle(TicksStyle.FULL);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(pathTicksBefore, view.pathTicks.getElements());
}
 

@Test
void testShowPtsCtrl2DotsOkPosition() {
	model.setShowPts(true);
	WaitForAsyncUtils.waitForFxEvents();
	final List<Point> centers = view.showPoint.getChildren().stream().filter(n -> n instanceof Ellipse).
		map(ell -> ShapeFactory.INST.createPoint(((Ellipse) ell).getCenterX(), ((Ellipse) ell).getCenterY())).collect(Collectors.toList());

	assertThat(model.getSecondCtrlPts())
		.allMatch(pt -> centers.contains(pt));
}
 

@ParameterizedTest
@EnumSource(ArcStyle.class)
void testClipArrowExists(final ArcStyle style) {
	assumeTrue(style.supportArrow());
	model.setArcStyle(style);
	model.setArrowStyle(ArrowStyle.RIGHT_ARROW, 0);
	WaitForAsyncUtils.waitForFxEvents();
	assertTrue(view.border.getClip() instanceof Arc);
}
 

@ParameterizedTest
@EnumSource(ArcStyle.class)
void testClipArrowSameStrokeWidth(final ArcStyle style) {
	assumeTrue(style.supportArrow());
	model.setArcStyle(style);
	model.setThickness(model.getThickness() * 2d);
	model.setArrowStyle(ArrowStyle.RIGHT_ARROW, 0);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(((Arc) view.border.getClip()).getStrokeWidth(), view.border.getStrokeWidth(), 0.0001);
}
 

@Test
@Override
void testChangeGridStartY() {
	model.setGridStartY(model.getGridStartY() - 1d);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(ptH1, view.axesHoriz.getModel().getPtAt(0));
	assertEquals(ptH2, view.axesHoriz.getModel().getPtAt(1));
	assertNotEquals(ptV1, view.axesVert.getModel().getPtAt(0));
	assertEquals(ptV2, view.axesVert.getModel().getPtAt(1));
	assertNotEquals(pathTicksBefore, view.pathTicks.getElements());
}
 

@Override
@Before
public void setUp() throws Exception {
	super.setUp();
	hand.setActivated(true);
	when(pencil.isActivated()).thenReturn(false);
	WaitForAsyncUtils.waitForFxEvents();
}
 

@Test
void testLineStyleDottedSepDoubleLineAfterLineStyle() {
	assumeTrue(model.isLineStylable());
	model.setLineStyle(LineStyle.DOTTED);
	if(model.isDbleBorderable()) {
		model.setHasDbleBord(true);
	}
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(Arrays.asList(0d, model.getDotSep() + model.getFullThickness()), border.getStrokeDashArray());
}
 

@Test
void testLineStyleDottedSepDoubleLineDoubleSep() {
	assumeTrue(model.isLineStylable());
	model.setLineStyle(LineStyle.DOTTED);
	if(model.isDbleBorderable()) {
		model.setHasDbleBord(true);
		model.setDbleBordSep(33d);
	}
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(Arrays.asList(0d, model.getDotSep() + model.getFullThickness()), border.getStrokeDashArray());
}
 

@Test
void testLineStyleDottedSepSimpleLine() {
	assumeTrue(model.isLineStylable());
	model.setLineStyle(LineStyle.DOTTED);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(Arrays.asList(0d, model.getDotSep() + model.getFullThickness()), border.getStrokeDashArray());
}
 

@Test
void testDashSepWhite() {
	assumeTrue(model.isLineStylable());
	model.setLineStyle(LineStyle.DASHED);
	model.setDashSepWhite(2.451);
	WaitForAsyncUtils.waitForFxEvents();
	assertEquals(Arrays.asList(model.getDashSepBlack(), 2.451), border.getStrokeDashArray());
}
 

@Override
@Before
public void setUp() throws Exception {
	super.setUp();
	setter = injector.getInstance(TextSetter.class);
	when(hand.isActivated()).thenReturn(false);
	when(setter.isActivated()).thenReturn(false);
	textAutoSize = new TextAreaAutoSize();
	when(setter.getTextField()).thenReturn(textAutoSize);
	pencil.setActivated(true);
	drawing = canvas.getDrawing();
	injector.getInstance(PreferencesService.class).magneticGridProperty().set(false);
	WaitForAsyncUtils.waitForFxEvents(100);
	canvas.toFront();
}
 

@Test
void testShowPtsCtrlEllNoStroke() {
	model.setShowPts(true);
	WaitForAsyncUtils.waitForFxEvents();
	assertThat(view.showPoint.getChildren())
		.filteredOn(n -> n instanceof Ellipse)
		.extracting(n -> ((Shape) n).getStroke())
		.containsOnlyNulls();
}
 

@Test
public void fileOrDirDestination() {
    DirectoryTaskOutput output = mock(DirectoryTaskOutput.class);
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> victim.dispatch(output));
    verify(output).getDestination();
    Text icon = lookup(".glyph-icon").queryAs(Text.class);
    assertEquals(MaterialDesignIcon.FOLDER_OUTLINE.unicode(), icon.getText());
}
 

@Test
public void directoryDestination() {
    DirectoryTaskOutput output = mock(DirectoryTaskOutput.class);
    WaitForAsyncUtils.waitForAsyncFx(2000, () -> victim.dispatch(output));
    verify(output).getDestination();
    Text icon = lookup(".glyph-icon").queryAs(Text.class);
    assertEquals(MaterialDesignIcon.FOLDER_OUTLINE.unicode(), icon.getText());
}
 

@Override
@Test
void testChangeOriginX() {
	final List<Double> yBefore = view.getLabels().getChildren().stream().map(c -> ((Text) c).getY()).collect(Collectors.toList());
	final List<Double> xBefore = view.getLabels().getChildren().stream().map(c -> ((Text) c).getX()).collect(Collectors.toList());
	model.setOriginX(model.getOriginX() + 1d);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(xBefore, view.getLabels().getChildren().stream().map(c -> ((Text) c).getX()).collect(Collectors.toList()));
	assertEquals(yBefore, view.getLabels().getChildren().stream().map(c -> ((Text) c).getY()).collect(Collectors.toList()));
}
 

@Test
void testTicknessChangeHasDblBord() {
	final Arc arc = cloneArc(view.border);
	model.setHasDbleBord(true);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(arc.getRadiusX(), view.border.getRadiusX());
	assertNotEquals(arc.getRadiusY(), view.border.getRadiusY());
}
 

@Override
@Test
void testChangeOriginX() {
	final List<String> textBefore = view.getLabels().getChildren().stream().map(c -> ((Text) c).getText()).collect(Collectors.toList());
	model.setOriginX(model.getOriginX() + 1d);
	WaitForAsyncUtils.waitForFxEvents();
	assertNotEquals(textBefore, view.getLabels().getChildren().stream().map(c -> ((Text) c).getText()).collect(Collectors.toList()));
}