java - soltar - manual programacion android español pdf

Prueba de archivos de arrastrar y soltar en la aplicación

Question

Estoy buscando un método para realizar un arrastrar y soltar un archivo / varios archivos en mi aplicación desde una prueba de unidad. Por ejemplo, al seleccionar algunos archivos en el Explorador de Windows, arrástrelos y suéltelos en mi aplicación.

Soy capaz de probar el comportamiento de arrastrar y soltar entre dos componentes en mi aplicación (vea a continuación, siéntase libre de indicar si conoce una mejor manera), pero no tengo idea de cómo hacer lo mismo cuando los datos deben provenir de fuera de mi solicitud.

Pensé en usar el depurador para inspeccionar un ''archivo'' Transferable cuando hago la operación de arrastrar y soltar a mano, pero debe haber una mejor manera que codificar en firme un Transferable completo.

Ejemplo de una prueba de arrastrar y soltar entre componentes

import org.junit.Test;

import javax.swing.Action;
import javax.swing.JTextField;
import javax.swing.TransferHandler;
import java.awt.event.ActionEvent;

import static org.junit.Assert.assertEquals;

public class DragAndDropTest {
  @Test
  public void dragAndDropBetweenTwoTextFields() {
    JTextField firstField = new JTextField();
    JTextField secondField = new JTextField();
    String testText = "Test text";
    firstField.setText( testText );
    firstField.selectAll();
    Action copyAction = TransferHandler.getCopyAction();
    copyAction.actionPerformed( new ActionEvent( firstField, ActionEvent.ACTION_PERFORMED, "Copy" ) );
    Action pasteAction = TransferHandler.getPasteAction();
    pasteAction.actionPerformed( new ActionEvent( secondField, ActionEvent.ACTION_PERFORMED, "Paste" ) );
    assertEquals( "Text is not copied", testText, secondField.getText() );
  }
}

Editar

Basándome en los comentarios de esta pregunta, he actualizado mi fragmento de código para "falsificar" un arrastrar y soltar proporcionando un Transferable codificado. El código también contiene un pequeño programa principal que solo crea un marco vacío en el que puedes soltar archivos. La ruta se imprimirá en la consola.

En mi PC, arrastrar y soltar un archivo no utiliza el javaFileListFlavor sino el sabor URI. Las experiencias anteriores (ver esta pregunta ) ya me enseñaron que el componente Transferable que recibe un componente al arrastrar algo desde fuera de la aplicación Java puede diferir de maneras sutiles.

Para que quede completamente claro: quiero probar la parte de mi código que extrae la información del Transferable recibido. El código de "manejo de información" (por ejemplo, lo que sucede cuando la aplicación recibe el archivo) se puede probar fácilmente sin molestar a D&D. Solo necesito asegurarme de extraer la información correcta del Transferable , y es una tontería probar esto con un Transferable codificado.

import org.junit.Test;

import javax.swing.Action;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.TransferHandler;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.ActionEvent;
import java.io.File;
import java.io.IOException;
import java.util.List;

import static org.junit.Assert.assertEquals;

public class DragAndDropTest {
  private static DataFlavor URI_LIST_FLAVOR = null;
  static {
    try {
      URI_LIST_FLAVOR = new DataFlavor( "text/uri-list;class=java.lang.String" );
    }
    catch ( ClassNotFoundException ignore ) {
    }
  }

  @Test
  public void testFileDragAndDrop() throws IOException, UnsupportedFlavorException {
    JComponent testComponent = new JPanel();
    TestingTransferHandler transferHandler = new TestingTransferHandler();
    testComponent.setTransferHandler( transferHandler );
    Clipboard clipBoard = new JLabel(  ).getToolkit().getSystemClipboard();
    Transferable transferable = new Transferable() {
      @Override
      public DataFlavor[] getTransferDataFlavors() {
        return new DataFlavor[]{URI_LIST_FLAVOR};
      }

      @Override
      public boolean isDataFlavorSupported( DataFlavor flavor ) {
        return flavor == URI_LIST_FLAVOR;
      }

      @Override
      public Object getTransferData( DataFlavor flavor ) throws UnsupportedFlavorException, IOException {
        if ( flavor == URI_LIST_FLAVOR ) {
          return new String( "file:///home/robins/Desktop/swingx-1.0-javadoc.jar" );
        }
        throw new UnsupportedFlavorException( flavor );
      }
    };
    clipBoard.setContents( transferable, null );
    Action pasteAction = TransferHandler.getPasteAction();
    pasteAction.actionPerformed( new ActionEvent( testComponent, ActionEvent.ACTION_PERFORMED, "Paste" ) );
    assertEquals( transferable.getTransferData( URI_LIST_FLAVOR ), transferHandler.transferable.getTransferData( URI_LIST_FLAVOR ) );
  }

  private static class TestingTransferHandler extends TransferHandler{
    public Transferable transferable;
    @Override
    public boolean canImport( TransferSupport support ) {
      return true;
    }
    @Override
    public boolean importData( TransferSupport support ) {
      transferable = support.getTransferable();
      try{
        if ( transferable.isDataFlavorSupported( DataFlavor.javaFileListFlavor ) ) {
          System.out.println("File list flavor");
          List<File> fileList = ( List<File> ) transferable.getTransferData( DataFlavor.javaFileListFlavor );
          System.out.println( "fileList = " + fileList );
        }
        if ( transferable.isDataFlavorSupported( URI_LIST_FLAVOR )){
          System.out.println("URI list flavor");
          String uriList = ( String ) transferable.getTransferData( URI_LIST_FLAVOR );
          System.out.println( "uriList = " + uriList );
        }
        return true;
      } catch ( UnsupportedFlavorException e ) {
        return false;
      } catch ( IOException e ) {
        return false;
      }
    }
  }

  public static void main( String[] args ) {
    EventQueue.invokeLater( new Runnable() {
      @Override
      public void run() {
        JFrame frame = new JFrame( "TestFrame" );
        JPanel contentPane = new JPanel( new BorderLayout(  ) );
        contentPane.setTransferHandler( new TestingTransferHandler() );
        frame.setContentPane( contentPane );
        frame.setSize( 200,200 );
        frame.setVisible( true );
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      }
    } );
  }
}

Answer 1

¿Has visto la clase de Robot ? Es genial para probar la interacción humana. No sé si puedes arrastrar y soltar archivos ... ¡pero tiene sentido que puedas!

Answer 2

Prueba de unidad Swing GUI siempre es doloroso, por no hablar de D&D. Sin embargo, creo que se puede hacer.

Hay dos cosas a tener en cuenta:

1. Actualmente, no estás probando D&D en absoluto, sino copiar y pegar. Esta es también una forma de transferencia de datos, pero el uso de copyAction y pasteAction hace que no pasteAction ninguno de los pasos de D&D

2. Menciona que desea verificar la parte que recibe el archivo y, por lo tanto, creó un Transferible personalizado, pero me gustaría argumentar que está intentando probar algo incorrecto. La parte que maneja los datos se puede implementar como un método privado del paquete que maneja un Transferable contiene los datos y se puede probar con una prueba unitaria simple (sin componentes Swing involucrados)

Creo que lo que debería estar probando, si le interesan las diferencias D&D entre diferentes sistemas operativos, es que el proceso D&D en sí mismo está funcionando, es decir:

1. Se solicita al componente con los datos ( DragSource ) que proporcione los datos y que los proporcione.
2. El componente que solicita los datos ( DropTarget ) recibe los datos y los maneja
3. Opcionalmente, es posible que desee verificar que se permiten o no diferentes condiciones (por ejemplo, copiar contra mover, etc.)

Puede probar esto utilizando la clase ComponentDragAndDrop FEST (consulte aquí ).

Si desea escribir su propia implementación (¡¿por qué querría hacer eso?!) Podría:
Reemplace los TransferHandler s de los componentes de origen y destino con simulacros (o espías para ser más precisos), que además de llamar a los métodos reales, le permitirían verificar que se llame a los métodos esperados con los datos esperados

Answer 3

Puedes usar Swinput para simular eventos de entrada en Linux.

Answer 4

Quizás AutoIt Script podría ayudar: vea aquí

Puede crear un script de Windows para simular el mouse o los eventos clave necesarios. A continuación, ejecute este script desde su prueba y vea qué sucedería.

Espero que esto ayude.

Answer 5

Si no está limitado a las pruebas unitarias, puede intentar escribir una prueba GUI. Hay varios marcos para Swing, vea este hilo - Marco de pruebas unitarias para una UI de Swing

He estado usando jemmy por un tiempo hace varios años y estaba bien, si la prueba era simple

Answer 6

Trate de usar las burlas. Estoy usando el framework Mockito .