import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void minorTicks(JFrameOperator jfo, String accessibleName) {
    JSliderOperator jso = new JSliderOperator(jfo,
            new AccessibleNameChooser(accessibleName));
    if (accessibleName.equals(HORIZONTAL_MINOR_TICKS_SLIDER)) {
        checkMaximum(jso, HORIZONTAL_MINOR_TICKS_SLIDER_MAXIMUM);
        checkMinimum(jso, HORIZONTAL_MINOR_TICKS_SLIDER_MINIMUM);
        checkMoveForward(jso, 2);
        checkSnapToTick(jso, 5, 6);
        assertEquals(5, jso.getMajorTickSpacing());
        assertEquals(1, jso.getMinorTickSpacing());
    } else {
        checkMaximum(jso, VERTICAL_MINOR_TICKS_SLIDER_MAXIMUM);
        checkMinimum(jso, VERTICAL_MINOR_TICKS_SLIDER_MINIMUM);
        checkMoveForward(jso, 10);
        assertEquals(20, jso.getMajorTickSpacing());
        assertEquals(5, jso.getMinorTickSpacing());
    }
    assertTrue(jso.getPaintTicks());
    assertTrue(jso.getPaintLabels());
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
@Test
public void test() throws Exception {

    new ClassReference(SplitPaneDemo.class.getCanonicalName()).startApplication();

    JFrameOperator frame = new JFrameOperator(DEMO_TITLE);

    JSplitPaneOperator splitPane = new JSplitPaneOperator(frame);

    // Toggle OneTouch Expandable
    checkOneTouch(frame, splitPane, true);
    checkOneTouch(frame, splitPane, false);

    // Check changing divider size to minimum and maximum values
    changeDividerSize(frame, splitPane, 50);
    changeDividerSize(frame, splitPane, 6);

    // Check moving the divider
    checkDividerMoves(frame, splitPane, false);
    checkDividerMoves(frame, splitPane, true);

    // Check different minumum Day/Night sizes
    changeMinimumSizes(frame, splitPane, 100);
    changeMinimumSizes(frame, splitPane, 0);
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
public void checkDividerMoves(JFrameOperator frame, JSplitPaneOperator splitPane, boolean isVertical) throws Exception {
    if (isVertical) {
        new JRadioButtonOperator(frame, VERTICAL_SPLIT).doClick();
    } else {
        new JRadioButtonOperator(frame, HORIZONTAL_SPLIT).doClick();
    }

    splitPane.moveDivider(0.0);
    assertEquals("Move Minimum, dividerLocation is at minimumDividerLocation",
            splitPane.getMinimumDividerLocation(), splitPane.getDividerLocation());

    // use getMaximumDividerLocation() to move divider to here because using proportion 1.0 does not work
    splitPane.moveDivider(1.0);

    assertEquals("Move Maximum, dividerLocation is at maximumDividerLocation",
            splitPane.getMaximumDividerLocation(), splitPane.getDividerLocation());

    splitPane.moveDivider(0.5);
    assertEquals("Move Middle, dividerLocation is at the artithmetic average of minimum and maximum DividerLocations",
            (splitPane.getMaximumDividerLocation() + splitPane.getMinimumDividerLocation()) / 2, splitPane.getDividerLocation());
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
@Test
public void test() throws Exception {

    new ClassReference(ProgressBarDemo.class.getCanonicalName()).startApplication();

    JFrameOperator frame = new JFrameOperator(DEMO_TITLE);

    JButtonOperator startButton = new JButtonOperator(frame, START_BUTTON);
    JButtonOperator stopButton = new JButtonOperator(frame, STOP_BUTTON);
    JProgressBarOperator jpbo = new JProgressBarOperator(frame);

    // Check that progress completes and corect enable/disable of start/stop buttons
    checkCompleteProgress(frame, startButton, stopButton, jpbo);

    // Check progess bar progression and start/stop button disabled/enabled states
    checkStartStop(frame, startButton, stopButton, jpbo);
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void testToggleButtons(JFrameOperator jfo) {
    ComponentChooser directionPanelChooser = new ByClassChooser(DirectionPanel.class);

    String text_Position = LayoutControlPanel.TEXT_POSITION;
    ContainerOperator<?> textPositionContainer = getLabeledContainerOperator(jfo, text_Position);
    ContainerOperator<?> directionPanelOperator = new ContainerOperator<>(textPositionContainer, directionPanelChooser);
    testRadioButtons(directionPanelOperator, 9, (t, i) -> i == 5);

    // Unfortunately, both directionPanels are in the same parent container
    // so we have to use indexes here.
    // There is no guarantee that if the UI changes, the code would be still
    // valid in terms of which directionPanel is checked first. However, it
    // does guarantee that two different directionPanels are checked.
    String content_Alignment = LayoutControlPanel.CONTENT_ALIGNMENT;
    ContainerOperator<?> contentAlignmentContainer = getLabeledContainerOperator(jfo, content_Alignment);
    ContainerOperator<?> directionPanelOperator2 = new ContainerOperator<>(contentAlignmentContainer, directionPanelChooser,
            contentAlignmentContainer.getSource() == textPositionContainer.getSource() ? 1 : 0);
    testRadioButtons(directionPanelOperator2, 9, (t, i) -> i == 4);

}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void changeValues(JFrameOperator jfo, int spinnerIndex) throws Exception {
    JSpinnerOperator spinner = new JSpinnerOperator(jfo, spinnerIndex);
    JTextFieldOperator jtfo = new JTextFieldOperator(spinner);
    float originalFieldValue = decimalFormat.parse(jtfo.getText()).floatValue();
    float finalFieldValue;

    // increment by one the value via spinner
    spinner.getIncreaseOperator().push();
    finalFieldValue = decimalFormat.parse(jtfo.getText()).floatValue();

    // check that the value was increased
    assertTrue("Increment Spinner " + spinner
            + " (originalFieldValue, actual value: " + originalFieldValue + " "
            + "< finalFieldValue, actual value = " + finalFieldValue + ")",
            originalFieldValue < finalFieldValue);

    // decrease value via spinner
    spinner.getDecreaseOperator().push();
    finalFieldValue = decimalFormat.parse(jtfo.getText()).floatValue();

    // check that the value was decrimented
    assertTrue("Decrement Spinner " + spinner
            + " (originalFieldValue, actual value: " + originalFieldValue + " "
            + ">= finalFieldValue, actual value = " + finalFieldValue + ")",
            originalFieldValue >= finalFieldValue);
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private JCheckBoxOperator getJCheckBoxOperator(JFrameOperator frame, int index) {

        // We map first half of indexes to the Prefixes panel and the second half
        // to the Suffixes panel
        String labelText;
        int subindex;
        if (index < CHECKBOX_COUNT / 2) {
            labelText = "Prefixes";
            subindex = index;
        } else {
            labelText = "Suffixes";
            subindex = index - CHECKBOX_COUNT / 2;
        }

        JCheckBoxOperator result = new JCheckBoxOperator(getLabeledContainerOperator(frame, labelText), subindex);
        result.setVerification(true);
        return result;
    }
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
public void checkButton(JFrameOperator jfo, int i, Robot rob) {
    JButtonOperator button = new JButtonOperator(jfo, i);

    Point loc = button.getLocationOnScreen();
    rob.mouseMove(loc.x, loc.y);

    BufferedImage initialButtonImage = capture(rob, button);
    assertNotBlack(initialButtonImage);
    save(initialButtonImage, "button" + i + "_0initial.png");
    rob.mousePress(InputEvent.BUTTON1_MASK);
    try {
        waitPressed(button);
        BufferedImage pressedButtonImage = capture(rob, button);
        assertNotBlack(pressedButtonImage);
        save(pressedButtonImage, "button" + i + "_1pressed.png");

        StrictImageComparator sComparator = new StrictImageComparator();
        assertNotEquals("Button " + i + " Test", sComparator, initialButtonImage, pressedButtonImage);
    } finally {
        rob.mouseRelease(InputEvent.BUTTON1_MASK);
    }
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
public void showInputDialog(JFrameOperator jfo) throws Exception {
    // Cancel with text case
    useInputDialog(jfo, SOME_TEXT_TO_TYPE, CANCEL);
    //TODO: wait for no dialog displayed

    // Cancel with *NO* text case
    useInputDialog(jfo, null, CANCEL);
    //TODO: wait for no dialog displayed

    // Text field has *NO* input
    useInputDialog(jfo, null, OK);
    //TODO: wait for no dialog displayed

    // Text field has input
    {
        final String enteredText = "Rambo";

        useInputDialog(jfo, enteredText, OK);
        checkMessage(enteredText + INPUT_RESPONSE);
    }
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
public void showConfirmationDialog(JFrameOperator jfo) throws Exception {
    // Case: Yes option selected
    {
        callADialogAndClose(jfo, CONFIRM_BUTTON, SELECT_AN_OPTION, YES);
        checkMessage(CONFIRM_YES);
    }

    // Case: No option selected
    {
        callADialogAndClose(jfo, CONFIRM_BUTTON, SELECT_AN_OPTION, NO);
        checkMessage(CONFIRM_NO);
    }

    // Case: Cancel option selected
    {
        callADialogAndClose(jfo, CONFIRM_BUTTON, SELECT_AN_OPTION, CANCEL);
        //TODO: wait for no dialog displayed
    }
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private JCheckBoxOperator getJCheckBoxOperator(JFrameOperator frame, int index) {

        // We map first half of indexes to the Prefixes panel and the second half
        // to the Suffixes panel
        String labelText;
        int subindex;
        if (index < CHECKBOX_COUNT / 2) {
            labelText = "Prefixes";
            subindex = index;
        } else {
            labelText = "Suffixes";
            subindex = index - CHECKBOX_COUNT / 2;
        }

        return new JCheckBoxOperator(getLabeledContainerOperator(frame, labelText), subindex);
    }
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
public void passwordField(JFrameOperator jfo) throws Exception {
    JPasswordFieldOperator password1 = new JPasswordFieldOperator(jfo, 0);
    JPasswordFieldOperator password2 = new JPasswordFieldOperator(jfo, 1);

    password1.typeText("password");
    password2.typeText("password");

    // Check Matching Passwords
    assertEquals("Matching Passwords", Color.green, password1.getBackground());
    assertEquals("Matching Passwords", Color.green, password2.getBackground());

    // Check non-matching passwords
    password2.typeText("passwereertegrs");
    assertEquals("Non-Matching Passwords", Color.white, password1.getBackground());
    assertEquals("Non-Matching Passwords", Color.white, password2.getBackground());
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
@Before
public void setUp() {
    scene = Root.ROOT.lookup().wrap();
    parent = scene.as(Parent.class, Node.class);
    contentPane = parent.lookup(new ByID<Node>(JFXPanelScrollApp.SCROLL_CONTAINER_ID)).wrap();
    frame = new JFrameOperator(JFXPanelScrollApp.class.getSimpleName());
    fxpane = new JComponentOperator(frame, new ComponentChooser() {
        public boolean checkComponent(Component component) {
            if (JFXPanel.class.isInstance(component)) {
                return true;
            }
            return false;
        }
        public String getDescription() {
            return "JFXPanel chooser";
        }
    });
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
@BeforeClass
public static void setUpClass() throws Exception {
    System.setProperty("javafx.swinginteroperability", "true");
    JFXPanelApp.main(null);
    JemmyProperties.setCurrentDispatchingModel(JemmyProperties.ROBOT_MODEL_MASK);
    frame = new JFrameOperator(JFXPanelApp.class.getSimpleName());
    menuBtn = new JButtonOperator(frame, JFXPanelApp.MENU_POPUP_BTN);
    alphaSlider = new JSliderOperator(frame);
    fxpanel = new JComponentOperator(frame, new ComponentChooser() {
        public boolean checkComponent(Component component) {
            return JFXPanel.class.isInstance(component);
        }

        public String getDescription() {
            return "JFXPanel chooser";
        }
    });
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
/** Pushes "Preview Form" button and waits for a frame opened.
 * @param frameName Frame class name.
 * @return JFrameOperator instance of "Form Preview" window
 */
public JFrameOperator previewForm(String frameName) {
    btPreviewForm().push();
    return (new JFrameOperator(Bundle.getString("org.netbeans.modules.form.actions.Bundle",
            "FMT_TestingForm",
            new Object[]{frameName})));
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
/** Test preview form mode of form designer. */
public void testPreviewForm() {
    FormDesignerOperator designer = new FormDesignerOperator(SAMPLE_FRAME);
    JFrameOperator myFrame = designer.previewForm(SAMPLE_FRAME.substring(0, SAMPLE_FRAME.indexOf('.')));
    myFrame.resize(400, 400);
    myFrame.requestClose();
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
@Test
public void test() throws Exception {
    new ClassReference(SliderDemo.class.getCanonicalName()).startApplication();
    JFrameOperator frame = new JFrameOperator(DEMO_TITLE);
    plain(frame, HORIZONTAL_PLAIN_SLIDER);
    majorTicks(frame, HORIZONTAL_MAJOR_TICKS_SLIDER);
    minorTicks(frame, HORIZONTAL_MINOR_TICKS_SLIDER);
    disabled(frame, HORIZONTAL_DISABLED_SLIDER);
    plain(frame, VERTICAL_PLAIN_SLIDER);
    majorTicks(frame, VERTICAL_MAJOR_TICKS_SLIDER);
    minorTicks(frame, VERTICAL_MINOR_TICKS_SLIDER);
    disabled(frame, VERTICAL_DISABLED_SLIDER);
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void plain(JFrameOperator jfo, String accessibleName) {
    JSliderOperator jso = new JSliderOperator(jfo,
            new AccessibleNameChooser(accessibleName));
    if (accessibleName.equals(HORIZONTAL_PLAIN_SLIDER)) {
        checkKeyboard(jso);
        checkMouse(jso);
    }
    checkMaximum(jso, PLAIN_SLIDER_MAXIMUM);
    checkMinimum(jso, PLAIN_SLIDER_MINIMUM);
    checkMoveForward(jso, 10);
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void majorTicks(JFrameOperator jfo, String accessibleName) {
    JSliderOperator jso = new JSliderOperator(jfo,
            new AccessibleNameChooser(accessibleName));
    checkMoveForward(jso, 40);
    assertTrue(jso.getPaintTicks());
    assertEquals(100, jso.getMajorTickSpacing());
}
 

import org.netbeans.jemmy.operators.JFrameOperator; //导入依赖的package包/类
private void disabled(JFrameOperator jfo, String accessibleName)
        throws InterruptedException {
    JSliderOperator jso = new JSliderOperator(jfo,
            new AccessibleNameChooser(accessibleName));
    int initialvalue;
    initialvalue = jso.getValue();
    jso.clickMouse(jso.getCenterXForClick(), jso.getCenterYForClick(), 10);
    Thread.sleep(500);
    assertFalse(jso.hasFocus());
    assertEquals(initialvalue, jso.getValue());
}