boccioli_m
7d8dceb12b
It still does not work because the Pshell function run() does not accept local parameters without deleting all local envionment variables.
1338 lines
59 KiB
Java
1338 lines
59 KiB
Java
/*
|
|
* Copyright (c) 2015 Paul Scherrer Institute. All rights reserved.
|
|
*/
|
|
//<editor-fold defaultstate="collapsed" desc="import">
|
|
|
|
import ch.psi.pshell.core.Controller;
|
|
import ch.psi.utils.swing.MonitoredPanel;
|
|
import ch.psi.pshell.ui.Panel;
|
|
import ch.psi.utils.swing.SwingUtils;
|
|
import ch.psi.wsaf.Task;
|
|
import java.io.File;
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import javax.swing.ImageIcon;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.table.DefaultTableModel;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.Vector;
|
|
import java.util.logging.FileHandler;
|
|
import java.util.logging.SimpleFormatter;
|
|
import javax.swing.DefaultCellEditor;
|
|
import javax.swing.JComboBox;
|
|
import javax.swing.JDialog;
|
|
import javax.swing.JFileChooser;
|
|
import javax.swing.table.DefaultTableCellRenderer;
|
|
import org.apache.commons.io.FilenameUtils;
|
|
import org.python.core.PyList;
|
|
import static org.python.bouncycastle.util.Arrays.append;
|
|
//</editor-fold>
|
|
|
|
/**
|
|
*
|
|
* @author boccioli_m
|
|
*/
|
|
public class TestingList extends Panel {
|
|
|
|
NetbeansPluginPanel testingList;
|
|
|
|
Task task = new Task() {
|
|
@Override
|
|
protected Object execute() throws Exception {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @return jPanel
|
|
*/
|
|
@Override
|
|
protected JPanel create() {
|
|
try {
|
|
testingList = new NetbeansPluginPanel();
|
|
|
|
} catch (IOException ex) {
|
|
Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
return testingList;
|
|
}
|
|
|
|
//delete this
|
|
@Override
|
|
protected void onExecutedFile(String fileName, Object result) {
|
|
int iCurrentTestPos = 0;
|
|
try {
|
|
Object ret = eval("ret");
|
|
boolean status = (boolean) eval("status");
|
|
Object deviceName = eval("DEVICE");
|
|
String sStatus = (status == true) ? TestStatus.SUCCESS.toString() : TestStatus.FAILURE.toString();
|
|
System.out.println("onExecutedFile: received end of test for test " + fileName);
|
|
// if (ret != "") {
|
|
//start next test
|
|
if (testingList.isTestRunAllowed() && testingList.runningTestsCount() == 0) {
|
|
// testingList.executeTests(iCurrentTestPos);
|
|
}
|
|
/* } else { // ret empty means that either the test script does not have variable ret, or that the script could not be started at all
|
|
ret = "Could not start test script or script doea not contain default variables";
|
|
sStatus = TestStatus.FAILURE.toString();
|
|
String[] dsDeviceName = testingList.getTestInProgress();
|
|
//SwingUtils.showException(getComponent(), ex );
|
|
if (dsDeviceName[0] != "") {
|
|
iCurrentTestPos = testingList.showResult(dsDeviceName[0], fileName, ret.toString(), sStatus);
|
|
//start next test
|
|
if (testingList.isTestRunAllowed() && testingList.runningTestsCount()==0) {
|
|
testingList.executeTest(iCurrentTestPos);
|
|
}
|
|
}
|
|
}
|
|
*/ } catch (Exception ex) {
|
|
String ret = "Could not start test script";
|
|
String sStatus = TestStatus.FAILURE.toString();
|
|
String[] dsDeviceName = testingList.getTestInProgress();
|
|
//SwingUtils.showException(getComponent(), ex );
|
|
SwingUtils.showMessage(getComponent(), "onExecutedFile()", ex.toString() + " " + dsDeviceName[0]);
|
|
if (dsDeviceName[0] != "") {
|
|
iCurrentTestPos = testingList.showResult(dsDeviceName[0], fileName, ret, sStatus);
|
|
//start next test
|
|
if (testingList.isTestRunAllowed()) {
|
|
// testingList.executeTests(iCurrentTestPos + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* enumeration of table column indexes
|
|
*/
|
|
public enum COL {
|
|
|
|
CHECK(0),
|
|
STARTSEQUENCE(1),
|
|
TIME(2),
|
|
DEVICENAME(3),
|
|
DEVICEDESCR(4),
|
|
TESTSUITE(5),
|
|
TESTNAME(6),
|
|
TESTPATH(7),
|
|
TESTPARAMS(8),
|
|
TESTDESCR(9),
|
|
TESTHELP(10),
|
|
RESULT(11),
|
|
STATUS(12),
|
|
ICON(13);
|
|
private int value;
|
|
|
|
private COL(int value) {
|
|
this.value = value;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return int index of the corresponding column
|
|
*/
|
|
public int index() {
|
|
return (int) value;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* enumeration of possible test statuses: text and related icon
|
|
*/
|
|
public enum TestStatus {
|
|
|
|
SUCCESS,
|
|
FAILURE,
|
|
PENDING,
|
|
DISABLED,
|
|
RUNNING;
|
|
|
|
/**
|
|
*
|
|
* @return
|
|
*/
|
|
public String IconFilename() {
|
|
String iconFileName = "";
|
|
switch (this) {
|
|
case SUCCESS:
|
|
iconFileName = "/icons/button_ok-16px.png";
|
|
break;
|
|
case FAILURE:
|
|
iconFileName = "/icons/button_close-16px.png";
|
|
break;
|
|
case PENDING:
|
|
iconFileName = "/icons/button_stop-16px.png";
|
|
break;
|
|
case DISABLED:
|
|
iconFileName = "";
|
|
break;
|
|
case RUNNING:
|
|
iconFileName = "/icons/button_play-16px.png";
|
|
break;
|
|
}
|
|
return iconFileName;
|
|
}
|
|
|
|
@Override
|
|
public final String toString() {
|
|
String status = "";
|
|
switch (this) {
|
|
case SUCCESS:
|
|
status = "Success";
|
|
break;
|
|
case FAILURE:
|
|
status = "Failure";
|
|
break;
|
|
case PENDING:
|
|
status = "Pending";
|
|
break;
|
|
case DISABLED:
|
|
status = "Disabled";
|
|
break;
|
|
case RUNNING:
|
|
status = "Running";
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return
|
|
*/
|
|
public ImageIcon Icon() {
|
|
String iconFileName = this.IconFilename();
|
|
ImageIcon icon = null;
|
|
if (iconFileName != "") {
|
|
icon = new ImageIcon(getClass().getResource(this.IconFilename()));
|
|
}
|
|
return icon;
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public enum StartSequence {
|
|
|
|
START_SEQ_AFTER,
|
|
START_SEQ_TOGETHER;
|
|
|
|
@Override
|
|
public final String toString() {
|
|
String status = "";
|
|
switch (this) {
|
|
case START_SEQ_AFTER:
|
|
status = "After previous";
|
|
break;
|
|
case START_SEQ_TOGETHER:
|
|
status = "With previous";
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public class NetbeansPluginPanel extends MonitoredPanel {
|
|
|
|
Logger logger = Logger.getLogger("TestsLog");
|
|
//these paths are converted to unix or win path according to host OS
|
|
private final String TESTS_DEVICES_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
|
|
+ FilenameUtils.separatorsToSystem("/home/script/tests/devices/");
|
|
private final String TESTS_TESTS_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
|
|
+ FilenameUtils.separatorsToSystem("/home/script/tests/tests/");
|
|
private final String TESTS_LOG_DEFAULT_DIR = new java.io.File(".").getCanonicalPath()
|
|
+ FilenameUtils.separatorsToSystem("/home/script/tests/log/TestsLog" + getnow() + ".txt");
|
|
|
|
private void initLogger() {
|
|
try {
|
|
FileHandler fh;
|
|
// This block configure the logger with handler and formatter
|
|
fh = new FileHandler(TESTS_LOG_DEFAULT_DIR);
|
|
logger.addHandler(fh);
|
|
SimpleFormatter formatter = new SimpleFormatter();
|
|
fh.setFormatter(formatter);
|
|
logger.log(Level.INFO, "New testing session");
|
|
} catch (SecurityException e) {
|
|
SwingUtils.showMessage(this, "initLogger()", e.toString());
|
|
} catch (IOException e) {
|
|
SwingUtils.showMessage(this, "initLogger()", e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @throws IOException
|
|
*/
|
|
public NetbeansPluginPanel() throws IOException {
|
|
initComponents();
|
|
initLogger();
|
|
buildTable();
|
|
loadTests();
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
|
|
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
|
|
private void initComponents() {
|
|
|
|
jScrollPane2 = new javax.swing.JScrollPane();
|
|
jTable1 = new javax.swing.JTable();
|
|
jPanel1 = new javax.swing.JPanel();
|
|
jButtonRun = new javax.swing.JButton();
|
|
jButtonOpenLog = new javax.swing.JButton();
|
|
jPanel2 = new javax.swing.JPanel();
|
|
jCheckBox1 = new javax.swing.JCheckBox();
|
|
jButtonMoveDown = new javax.swing.JButton();
|
|
jButtonMoveUp = new javax.swing.JButton();
|
|
jButton1 = new javax.swing.JButton();
|
|
jButton2 = new javax.swing.JButton();
|
|
|
|
setLayout(new java.awt.BorderLayout());
|
|
|
|
jTable1.setFont(new java.awt.Font("Tahoma", 0, 15)); // NOI18N
|
|
jTable1.setModel(new javax.swing.table.DefaultTableModel(
|
|
new Object [][] {
|
|
|
|
},
|
|
new String [] {
|
|
"Select", "Start", "Time", "Device Name", "Device Description", "Test Suite", "Test Name", "Test Peth", "Test Parameters", "Test Description", "Test Help", "Last Test Result", "Status", ""
|
|
}
|
|
) {
|
|
Class[] types = new Class [] {
|
|
java.lang.Boolean.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, java.lang.Object.class, javax.swing.Icon.class
|
|
};
|
|
boolean[] canEdit = new boolean [] {
|
|
true, true, false, false, false, false, false, false, false, false, false, false, false, false
|
|
};
|
|
|
|
public Class getColumnClass(int columnIndex) {
|
|
return types [columnIndex];
|
|
}
|
|
|
|
public boolean isCellEditable(int rowIndex, int columnIndex) {
|
|
return canEdit [columnIndex];
|
|
}
|
|
});
|
|
jTable1.getTableHeader().setReorderingAllowed(false);
|
|
jTable1.setDragEnabled(true);
|
|
jTable1.setDropMode(javax.swing.DropMode.INSERT);
|
|
jTable1.setRowHeight(22);
|
|
jTable1.addMouseListener(new java.awt.event.MouseAdapter() {
|
|
public void mouseClicked(java.awt.event.MouseEvent evt) {
|
|
jTable1MouseClicked(evt);
|
|
}
|
|
});
|
|
jTable1.addKeyListener(new java.awt.event.KeyAdapter() {
|
|
public void keyReleased(java.awt.event.KeyEvent evt) {
|
|
jTable1KeyReleased(evt);
|
|
}
|
|
});
|
|
jScrollPane2.setViewportView(jTable1);
|
|
|
|
add(jScrollPane2, java.awt.BorderLayout.CENTER);
|
|
|
|
jPanel1.setMinimumSize(new java.awt.Dimension(100, 100));
|
|
jPanel1.setPreferredSize(new java.awt.Dimension(110, 110));
|
|
jPanel1.setLayout(new java.awt.BorderLayout());
|
|
|
|
jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_play-64px.png"))); // NOI18N
|
|
jButtonRun.setToolTipText("Run selected tests");
|
|
jButtonRun.setMaximumSize(new java.awt.Dimension(33, 39));
|
|
jButtonRun.setMinimumSize(new java.awt.Dimension(90, 90));
|
|
jButtonRun.setPreferredSize(new java.awt.Dimension(33, 39));
|
|
jButtonRun.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButtonRunActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel1.add(jButtonRun, java.awt.BorderLayout.CENTER);
|
|
|
|
jButtonOpenLog.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/log-icon-64px.png"))); // NOI18N
|
|
jButtonOpenLog.setToolTipText("Open current sessions Log");
|
|
jButtonOpenLog.setMaximumSize(new java.awt.Dimension(80, 39));
|
|
jButtonOpenLog.setMinimumSize(new java.awt.Dimension(90, 90));
|
|
jButtonOpenLog.setPreferredSize(new java.awt.Dimension(90, 39));
|
|
jButtonOpenLog.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButtonOpenLogActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel1.add(jButtonOpenLog, java.awt.BorderLayout.EAST);
|
|
|
|
jPanel2.setLayout(new java.awt.BorderLayout());
|
|
|
|
jCheckBox1.setToolTipText("Select/Deselec thet highlighted tests");
|
|
jCheckBox1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
|
|
jCheckBox1.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
|
|
jCheckBox1.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jCheckBox1ActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel2.add(jCheckBox1, java.awt.BorderLayout.WEST);
|
|
|
|
jButtonMoveDown.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/ArrowDown - 24.png"))); // NOI18N
|
|
jButtonMoveDown.setToolTipText("Move the highlighted tests down");
|
|
jButtonMoveDown.setMaximumSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveDown.setMinimumSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveDown.setPreferredSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveDown.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButtonMoveDownActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel2.add(jButtonMoveDown, java.awt.BorderLayout.SOUTH);
|
|
|
|
jButtonMoveUp.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/ArrowUp - 24.png"))); // NOI18N
|
|
jButtonMoveUp.setToolTipText("Move the highlighted tests up");
|
|
jButtonMoveUp.setMaximumSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveUp.setMinimumSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveUp.setPreferredSize(new java.awt.Dimension(25, 25));
|
|
jButtonMoveUp.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButtonMoveUpActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel2.add(jButtonMoveUp, java.awt.BorderLayout.PAGE_START);
|
|
|
|
jButton1.setText("jButton1");
|
|
jButton1.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButton1ActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel2.add(jButton1, java.awt.BorderLayout.CENTER);
|
|
|
|
jButton2.setText("jButton2");
|
|
jButton2.addActionListener(new java.awt.event.ActionListener() {
|
|
public void actionPerformed(java.awt.event.ActionEvent evt) {
|
|
jButton2ActionPerformed(evt);
|
|
}
|
|
});
|
|
jPanel2.add(jButton2, java.awt.BorderLayout.LINE_END);
|
|
|
|
jPanel1.add(jPanel2, java.awt.BorderLayout.LINE_START);
|
|
|
|
add(jPanel1, java.awt.BorderLayout.NORTH);
|
|
}// </editor-fold>//GEN-END:initComponents
|
|
|
|
private void jButtonRunActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonRunActionPerformed
|
|
if (this.jButtonRun.getToolTipText().equals("Run selected tests")) {
|
|
setButtonToStart();
|
|
updateStatus();
|
|
executeTests();
|
|
} else {
|
|
setToStopped();
|
|
}
|
|
}//GEN-LAST:event_jButtonRunActionPerformed
|
|
|
|
private void setButtonToStop() {
|
|
abort();
|
|
this.jButtonRun.setToolTipText("Run selected tests");
|
|
jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_play-64px.png")));
|
|
this.jTable1.setEnabled(true);
|
|
}
|
|
|
|
private void setButtonToStart() {
|
|
this.jButtonRun.setToolTipText("Stop tests");
|
|
jButtonRun.setIcon(new javax.swing.ImageIcon(getClass().getResource("/icons/button_stop-64px.png")));
|
|
this.jTable1.clearSelection();
|
|
this.jTable1.setEnabled(false);
|
|
}
|
|
|
|
private void jCheckBox1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jCheckBox1ActionPerformed
|
|
boolean bSelected = jCheckBox1.isSelected();
|
|
int iSelRows = jTable1.getSelectedRowCount();
|
|
|
|
if (iSelRows > 0) {// if some rows are selected, check/uncheck selected rows
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
for (int selRow = 0; selRow <= jTable1.getSelectedRowCount() - 1; selRow++) {
|
|
if (row == jTable1.getSelectedRows()[selRow]) {
|
|
jTable1.setValueAt(bSelected, row, 0);
|
|
}
|
|
}
|
|
}
|
|
} else {//if none of the rows are selected, check/uncheck all
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
jTable1.setValueAt(bSelected, row, 0);
|
|
}
|
|
}
|
|
updateStatus();
|
|
}//GEN-LAST:event_jCheckBox1ActionPerformed
|
|
|
|
private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTable1MouseClicked
|
|
if (this.jTable1.isEnabled()) {
|
|
try {
|
|
switch (evt.getClickCount()) {
|
|
case 1:
|
|
int colIndex = jTable1.getSelectedColumn();
|
|
if (colIndex == COL.CHECK.ordinal()) {
|
|
updateStatus();
|
|
}
|
|
break;
|
|
case 2:
|
|
openDetails();
|
|
break;
|
|
}
|
|
} catch (Exception ex) {
|
|
SwingUtils.showException(this, ex);
|
|
}
|
|
}
|
|
}//GEN-LAST:event_jTable1MouseClicked
|
|
|
|
//oopen the log file using one of th default OS text reades
|
|
private void jButtonOpenLogActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonOpenLogActionPerformed
|
|
String cmd;
|
|
if (System.getProperty("os.name").toLowerCase().contains("windows")) {
|
|
cmd = "notepad.exe " + TESTS_LOG_DEFAULT_DIR;
|
|
} else {
|
|
cmd = "nedit " + TESTS_LOG_DEFAULT_DIR;
|
|
}
|
|
try {
|
|
Runtime.getRuntime().exec(cmd);
|
|
} catch (IOException ex) {
|
|
SwingUtils.showMessage(this, "jButtonOpenLogActionPerformed()", "jButtonOpenLogActionPerformed() " + ex.toString()
|
|
+ " \nPlease open the file manually. \nFile dir: " + TESTS_LOG_DEFAULT_DIR);
|
|
Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
}//GEN-LAST:event_jButtonOpenLogActionPerformed
|
|
|
|
private void jTable1KeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jTable1KeyReleased
|
|
int colIndex = jTable1.getSelectedColumn();
|
|
if (colIndex == COL.CHECK.ordinal()) {
|
|
updateStatus();
|
|
}
|
|
}//GEN-LAST:event_jTable1KeyReleased
|
|
|
|
private void jButtonMoveDownActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveDownActionPerformed
|
|
moveDown();
|
|
}//GEN-LAST:event_jButtonMoveDownActionPerformed
|
|
|
|
private void jButtonMoveUpActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonMoveUpActionPerformed
|
|
moveUp();
|
|
}//GEN-LAST:event_jButtonMoveUpActionPerformed
|
|
|
|
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
|
|
|
|
new Thread(() -> {
|
|
try {
|
|
//Object ret = eval("parallelize((run,('testLocalVar1',globals(),{'a':'21', 'b':34})), (run,('testLocalVar2',globals(),{'a':231, 'b':234})))");
|
|
Object ret;
|
|
ret = eval("parallelize((run,('dummy',)))");
|
|
ret = eval("parallelize((run,('testLocalVar1',{'a':21, 'b':34})), (run,('testLocalVar2', {'a':231, 'b':234})))");
|
|
Object ret1 = ((ArrayList) ret).get(0);
|
|
Object ret2 = ((ArrayList) ret).get(1);
|
|
System.out.println(String.valueOf(ret1));
|
|
System.out.println(String.valueOf(ret2));
|
|
} catch (Exception ex) {
|
|
SwingUtils.showException(this, ex);
|
|
}
|
|
}).start();
|
|
|
|
}//GEN-LAST:event_jButton1ActionPerformed
|
|
|
|
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed
|
|
// TODO add your handling code here:
|
|
this.loadSettings();
|
|
}//GEN-LAST:event_jButton2ActionPerformed
|
|
|
|
//<editor-fold defaultstate="collapsed" desc="Witget Variables declaration">
|
|
// Variables declaration - do not modify//GEN-BEGIN:variables
|
|
private javax.swing.JButton jButton1;
|
|
private javax.swing.JButton jButton2;
|
|
private javax.swing.JButton jButtonMoveDown;
|
|
private javax.swing.JButton jButtonMoveUp;
|
|
private javax.swing.JButton jButtonOpenLog;
|
|
private javax.swing.JButton jButtonRun;
|
|
private javax.swing.JCheckBox jCheckBox1;
|
|
private javax.swing.JPanel jPanel1;
|
|
private javax.swing.JPanel jPanel2;
|
|
private javax.swing.JScrollPane jScrollPane2;
|
|
private javax.swing.JTable jTable1;
|
|
// End of variables declaration//GEN-END:variables
|
|
//</editor-fold>
|
|
|
|
/**
|
|
*returns whether or not the tests can run
|
|
* (Run launched by the user)
|
|
*
|
|
* @return status of run button. True = tests launching sequence is running
|
|
*/
|
|
public boolean isTestRunAllowed() {
|
|
return (this.jButtonRun.getToolTipText().equals("Stop tests") && pendingTestsCount() > 0);
|
|
}
|
|
|
|
/**
|
|
* move selected rows up in table
|
|
*/
|
|
private void moveUp() {
|
|
DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
|
|
int[] rows = jTable1.getSelectedRows();
|
|
if (rows[0] - 1 >= 0) {
|
|
jTable1.setAutoCreateRowSorter(false);
|
|
model.moveRow(rows[0], rows[rows.length - 1], rows[0] - 1);
|
|
jTable1.setAutoCreateRowSorter(true);
|
|
jTable1.setRowSelectionInterval(rows[0] - 1, rows[rows.length - 1] - 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* move selected rows down in table
|
|
*/
|
|
private void moveDown() {
|
|
DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
|
|
int[] rows = jTable1.getSelectedRows();
|
|
if (rows[rows.length - 1] < jTable1.getRowCount()) {
|
|
jTable1.setAutoCreateRowSorter(false);
|
|
model.moveRow(rows[0], rows[rows.length - 1], rows[0] + 1);
|
|
jTable1.setAutoCreateRowSorter(true);
|
|
jTable1.setRowSelectionInterval(rows[0] + 1, rows[rows.length - 1] + 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* open details of the selected row in a new panel
|
|
*
|
|
* @throws exception
|
|
*/
|
|
private void openDetails() throws Exception {
|
|
//pick details from the clicked row
|
|
int row = jTable1.getSelectedRow();
|
|
String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
|
|
String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString();
|
|
String sTestPath = String.valueOf(jTable1.getValueAt(row, COL.TESTPATH.ordinal()));
|
|
String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString();
|
|
String sTestDescription = jTable1.getValueAt(row, COL.TESTDESCR.ordinal()).toString();
|
|
String sDeviceDescription = jTable1.getValueAt(row, COL.DEVICEDESCR.ordinal()).toString();
|
|
String sLastResult = jTable1.getValueAt(row, COL.RESULT.ordinal()).toString();
|
|
String sResultTime = jTable1.getValueAt(row, COL.TIME.ordinal()).toString();
|
|
String sTestHelp = String.valueOf(jTable1.getValueAt(row, COL.TESTHELP.ordinal()));
|
|
HashMap mParameters = buildParametersMap(String.valueOf(jTable1.getValueAt(row, COL.TESTPARAMS.ordinal())));
|
|
//create map for passing details to Details Panel
|
|
HashMap details = new HashMap();
|
|
details.put("deviceName", sDeviceName);
|
|
details.put("deviceDescription", sDeviceDescription);
|
|
details.put("testDescription", sTestDescription);
|
|
details.put("testSuite", sTestCaseName);
|
|
details.put("testName", sTestName);
|
|
details.put("testResult", sLastResult);
|
|
details.put("time", sResultTime);
|
|
details.put("parameters", mParameters);
|
|
details.put("testHelp", sTestHelp);
|
|
details.put("testPath", sTestPath);
|
|
//open details panel
|
|
JDialog dlg = new JDialog(getView(), "Test Details - " + sTestName, true);
|
|
//create a class to visualise the details panel
|
|
Class testingListDetailsClass = getController().getClassByName("TestingListDetails");
|
|
JPanel detailsPanel = (JPanel) testingListDetailsClass.getConstructor(new Class[]{HashMap.class}).newInstance(new Object[]{details});
|
|
|
|
dlg.getContentPane().add(detailsPanel);
|
|
//dlg.add(new TestingListDetails());
|
|
dlg.pack();
|
|
dlg.setVisible(true);
|
|
}
|
|
|
|
/**
|
|
* put the test result in table
|
|
*
|
|
* @param deviceName name of the device to search in table
|
|
* @param testPath path of the test to search in table
|
|
* @param res String result returned by the test
|
|
* @param status String status returned by the test
|
|
* @return int index of the row of the device in table
|
|
*/
|
|
public int showResult(String deviceName, String testPath, String res, String status) {
|
|
int rowD = -1;
|
|
String sTestName = testPath;
|
|
logger.log(Level.FINE, "Looking for: deviceName: " + deviceName + "; testPath: " + testPath + " in table.");
|
|
String sStatus;
|
|
if (status == "true") {
|
|
sStatus = TestStatus.SUCCESS.toString();
|
|
} else if (status == "false") {
|
|
sStatus = TestStatus.FAILURE.toString();
|
|
} else {
|
|
sStatus = status;
|
|
}
|
|
//search for device name in table
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal()))
|
|
&& testPath.equals(jTable1.getValueAt(row, COL.TESTPATH.ordinal()))) {
|
|
rowD = row;
|
|
sTestName = jTable1.getValueAt(rowD, COL.TESTNAME.ordinal()).toString();
|
|
break;
|
|
}
|
|
}
|
|
ImageIcon icon = new ImageIcon();
|
|
switch (sStatus) {
|
|
case "Success":
|
|
icon = TestStatus.SUCCESS.Icon();
|
|
logger.log(Level.INFO, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res);
|
|
break;
|
|
case "Failure":
|
|
icon = TestStatus.FAILURE.Icon();
|
|
logger.log(Level.SEVERE, sStatus + " - Device: " + deviceName + "; Test: " + sTestName + "; Result: " + res);
|
|
break;
|
|
case "Running":
|
|
icon = TestStatus.RUNNING.Icon();
|
|
//logger.log(Level.INFO, "Running Test: " + sTestName + ".");
|
|
break;
|
|
}
|
|
if (rowD >= 0) {
|
|
jTable1.setValueAt(icon, rowD, COL.ICON.ordinal());
|
|
jTable1.setValueAt(getNow(), rowD, COL.TIME.ordinal());
|
|
jTable1.setValueAt(res, rowD, COL.RESULT.ordinal());
|
|
jTable1.setValueAt(sStatus, rowD, COL.STATUS.ordinal());
|
|
} else {
|
|
logger.log(Level.SEVERE, "Cant find Test: " + testPath + " in table.");
|
|
}
|
|
//check if there are still pending tests. If not, set the status of the tool to Stopped.
|
|
if (pendingTestsCount() == 0 && runningTestsCount() == 0) {
|
|
setToStopped();
|
|
}
|
|
return rowD;
|
|
}
|
|
|
|
|
|
/**
|
|
*returns the amount of tests currently in Pending state
|
|
*
|
|
* @return int counter of pending tests
|
|
*/
|
|
public int pendingTestsCount() {
|
|
return testsStatusCount(TestStatus.PENDING);
|
|
}
|
|
|
|
|
|
/**
|
|
*returns the amount of tests currently in Running state
|
|
*
|
|
* @return int counter of running tests
|
|
*/
|
|
public int runningTestsCount() {
|
|
return testsStatusCount(TestStatus.RUNNING);
|
|
}
|
|
|
|
|
|
/**
|
|
*returns the amount of tests currently in Pending state
|
|
*
|
|
* @return int counter of successful tests
|
|
*/
|
|
public int successTestsCount() {
|
|
return testsStatusCount(TestStatus.SUCCESS);
|
|
}
|
|
|
|
/**
|
|
* returns the amount of tests currently in "status" state
|
|
*
|
|
* @param status type of status to count
|
|
* @return int counter with occurrences of the status
|
|
*/
|
|
private int testsStatusCount(TestStatus status) {
|
|
String sStatus;
|
|
boolean bSelected;
|
|
int iPendingTestsCount = 0;
|
|
for (int row = 0; row < jTable1.getRowCount(); row++) {
|
|
bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
|
|
sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString();
|
|
if (bSelected && sStatus == status.toString()) {
|
|
iPendingTestsCount++;
|
|
}
|
|
}
|
|
return iPendingTestsCount;
|
|
}
|
|
|
|
/**
|
|
* set the tests to stopped
|
|
*/
|
|
private void setToStopped() {
|
|
//No more tests to play. Stop
|
|
setButtonToStop();
|
|
logger.log(Level.INFO, "End of tests.");
|
|
}
|
|
|
|
/**
|
|
* get the first test currently in progress
|
|
*
|
|
* @return properties of the test in progress
|
|
*/
|
|
public String[] getTestInProgress() {
|
|
String[] dsTestProperties = {"", ""};
|
|
//search for device name in table
|
|
try {
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
if (jTable1.getValueAt(row, COL.STATUS.ordinal()).toString().equals(TestStatus.RUNNING.toString())) {
|
|
dsTestProperties[0] = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
|
|
dsTestProperties[1] = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString();
|
|
break;
|
|
}
|
|
}
|
|
} catch (Exception ex) {
|
|
this.setToStopped();
|
|
SwingUtils.showMessage(this, "getTestInProgress()", ex.toString());
|
|
} finally {
|
|
return dsTestProperties;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*returns the status of the specified test name for specified device name
|
|
*
|
|
* @param deviceName name of the device
|
|
* @param testPath path of the test file
|
|
* @return String containing the result returned by the test
|
|
*/
|
|
public String getResult(String deviceName, String testPath) {
|
|
String sStatus = "";
|
|
int rowD = -1, colT = -1;
|
|
//search for device name in table
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
if (deviceName.equals(jTable1.getValueAt(row, COL.DEVICENAME.ordinal()))) {
|
|
rowD = row;
|
|
break;
|
|
}
|
|
}
|
|
if (rowD >= 0) {
|
|
//search for test in table
|
|
if (testPath.equals(jTable1.getValueAt(rowD, COL.TESTPATH.ordinal()))) {
|
|
colT = COL.TESTNAME.ordinal();
|
|
}
|
|
}
|
|
//get the test result
|
|
if (colT >= 0 && rowD >= 0) {
|
|
sStatus = jTable1.getValueAt(rowD, COL.STATUS.ordinal()).toString();
|
|
}
|
|
return sStatus;
|
|
}
|
|
|
|
/**
|
|
* visualise test status (columns status and icon)
|
|
*/
|
|
public void updateStatus() {
|
|
String sStatus;
|
|
boolean bSelected;
|
|
ImageIcon icon = null;
|
|
String sStart;
|
|
for (int row = 0; row <= jTable1.getRowCount() - 1; row++) {
|
|
bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
|
|
sStart = String.valueOf(jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal()));
|
|
if (bSelected) {
|
|
sStatus = TestStatus.PENDING.toString();
|
|
icon = TestStatus.PENDING.Icon();
|
|
if (sStart == "") {
|
|
sStart = StartSequence.START_SEQ_AFTER.toString();
|
|
}
|
|
} else {
|
|
sStatus = TestStatus.DISABLED.toString();
|
|
icon = TestStatus.DISABLED.Icon();
|
|
sStart = "";
|
|
}
|
|
jTable1.setValueAt(bSelected, row, COL.CHECK.ordinal());
|
|
jTable1.setValueAt(icon, row, COL.ICON.ordinal());
|
|
jTable1.setValueAt(sStatus, row, COL.STATUS.ordinal());
|
|
jTable1.setValueAt(sStart, row, COL.STARTSEQUENCE.ordinal());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*launch the execution of the tests
|
|
*/
|
|
public void executeTests() {
|
|
RunTest runTest = new RunTest();
|
|
Thread t = new Thread(runTest);
|
|
t.start();
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public class RunTest implements Runnable {
|
|
|
|
private HashMap mParameters;
|
|
//private HashMap<String,Object> args;
|
|
private HashMap<String, HashMap> hTests;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public RunTest() {
|
|
//System.out.println("A0");
|
|
}
|
|
|
|
public void run() {
|
|
// code in the other thread, can reference "var" variable
|
|
executeTest(0);
|
|
}
|
|
|
|
/**
|
|
*execute the selected tests in the list, starting from the position
|
|
*
|
|
*@param position row number from which to start executing tests
|
|
*/
|
|
private void executeTest(int position) {
|
|
boolean bSelected = false;
|
|
String sStartSequence, sStatus;
|
|
int[] selectedTestsRows = {};
|
|
//scan through the table starting from 'position' and execute the first selected test found
|
|
int row = 0;// position;
|
|
if (row >= 0 && row < jTable1.getRowCount()) {
|
|
for (row = position; row < jTable1.getRowCount(); row++) {
|
|
bSelected = (boolean) jTable1.getValueAt(row, COL.CHECK.ordinal());
|
|
sStartSequence = jTable1.getValueAt(row, COL.STARTSEQUENCE.ordinal()).toString();
|
|
sStatus = jTable1.getValueAt(row, COL.STATUS.ordinal()).toString();
|
|
//collect tests to be launched in parallel
|
|
//the test must be: selected, set as start with previous, pending.
|
|
//alternatively, the test must be: selected, first of the list.
|
|
|
|
//System.out.println(String.valueOf(row) + "\t" + String.valueOf(bSelected) + "\t" + String.valueOf(selectedTestsRows.length) + "\t" + sStartSequence + "\t" + sStatus);
|
|
if (bSelected
|
|
&& sStatus.equals(TestStatus.PENDING.toString())
|
|
&& (selectedTestsRows.length == 0 || //the test must be: selected, pending, first of the list.
|
|
sStartSequence.equals(StartSequence.START_SEQ_TOGETHER.toString()))) { //or the test must be: selected, pending, set as start with previous
|
|
selectedTestsRows = append(selectedTestsRows, row);
|
|
} else if (bSelected
|
|
&& sStatus.equals(TestStatus.PENDING.toString()) &&//if this test must be executed...
|
|
selectedTestsRows.length > 0 && //but there are already tests to be executed in parallel....
|
|
(sStartSequence.equals(StartSequence.START_SEQ_AFTER.toString()))) { //...and this test must be executed in series, then stop searching
|
|
break;
|
|
}
|
|
}
|
|
if (selectedTestsRows.length > 0) { //at least one test is selected: launch it (or them)
|
|
System.out.println("\n===================================================\n");
|
|
executeParallelTestsGroup(selectedTestsRows); //last execution did not find a test file. Continue with next execution
|
|
executeTest(position + 1);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private HashMap buildMapFromTableRow(int row) {
|
|
String sDeviceName = jTable1.getValueAt(row, COL.DEVICENAME.ordinal()).toString();
|
|
String sTestName = jTable1.getValueAt(row, COL.TESTNAME.ordinal()).toString();
|
|
String sTestCaseName = jTable1.getValueAt(row, COL.TESTSUITE.ordinal()).toString();
|
|
String sTestPath = jTable1.getValueAt(row, COL.TESTPATH.ordinal()).toString();
|
|
HashMap mParameters = buildParametersMap(String.valueOf(jTable1.getValueAt(row, COL.TESTPARAMS.ordinal())));
|
|
HashMap testArgs = new HashMap();
|
|
//args.put("ret", "");
|
|
testArgs.put("parameters", mParameters);
|
|
testArgs.put("test", sTestName);
|
|
testArgs.put("device", sDeviceName);
|
|
testArgs.put("testPath", sTestPath);
|
|
testArgs.put("status", false);
|
|
|
|
return testArgs;
|
|
}
|
|
|
|
//start all the tests in the rowsToExecute
|
|
private int executeParallelTestsGroup(int[] rowsToExecute) {
|
|
int iRet = -1;
|
|
HashMap args2 = new HashMap(); //this is the global map that will contain one map per test.
|
|
HashMap testArgs; //this is the map for a test.
|
|
RunTest runTest;
|
|
String sTestName = "", sDeviceName = "", sTestPath = "";
|
|
for (int row : rowsToExecute) {
|
|
//System.out.println(String.valueOf(row) + "\t" + sDeviceName + "\t" + sTestName + "\t" + sTestCaseName + "\t" + String.valueOf(rowsToExecute.length));
|
|
try {
|
|
testArgs = buildMapFromTableRow(row);
|
|
sTestName = (String) testArgs.get("test");
|
|
sTestPath = (String) testArgs.get("testPath");
|
|
sDeviceName = (String) testArgs.get("device");
|
|
mParameters = (HashMap) testArgs.get("parameters");
|
|
File f = new File(sTestPath);
|
|
if (!f.exists() || f.isDirectory()) {
|
|
logger.log(Level.SEVERE, "Cannot find test script: " + sTestPath);
|
|
showResult(sDeviceName, sTestPath, "Cannot find test script: " + sTestPath, TestStatus.FAILURE.toString());
|
|
continue;
|
|
}
|
|
showResult(sDeviceName, sTestPath, "Test running", TestStatus.RUNNING.toString());
|
|
//launch the test
|
|
if (!mParameters.isEmpty()) {
|
|
logger.log(Level.INFO, "Running test '" + sTestName + "' with the following parameters: " + mParameters.toString());
|
|
System.out.println("Running test '" + sTestName + "' with the following parameters: " + mParameters.toString());
|
|
} else {
|
|
logger.log(Level.INFO, "Running Test '" + sTestName + "'. No parameters found.");
|
|
System.out.println("Running test '" + sTestName + "'. No parameters found.");
|
|
}
|
|
|
|
args2.put(sTestPath, testArgs);
|
|
|
|
hTests = args2;
|
|
iRet = 0;
|
|
} catch (Exception ex) {
|
|
SwingUtils.showMessage(TestingList.this.getComponent(), "executeTest()", ex.toString());
|
|
logger.log(Level.SEVERE, ex.toString());
|
|
showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString());
|
|
setToStopped();
|
|
}
|
|
}
|
|
try {
|
|
int iLastExecutedTestIndex = -1;
|
|
final String sParallelizeBegin = "(run,(str('";
|
|
final String sParallelizeEnd = "'),))";
|
|
String sParallelizeArguments;
|
|
try {
|
|
//System.out.println("A0.1");
|
|
String sParallelizeCommand = "parallelize(";
|
|
int i = 0;
|
|
int iTotalEntries = hTests.entrySet().size();
|
|
for (Map.Entry<String, HashMap> hTest : hTests.entrySet()) {
|
|
//setGlobalsVars(hTest.getValue()); //set global variables that can be read by all test scripts
|
|
sTestPath = hTest.getKey().toString();
|
|
sTestPath = sTestPath.replace("\\", "\\\\");
|
|
//System.out.println(hTest.getValue().get("test"));
|
|
sParallelizeCommand = sParallelizeCommand + "(run,(str('" + sTestPath;
|
|
//System.out.println("A"+i);
|
|
sParallelizeArguments = "globals(),{'parameters':'" + hTest.getValue().get("parameters")
|
|
+ // sParallelizeArguments = "{'parameters':'"+hTest.getValue().get("parameters")+
|
|
"','test':'" + hTest.getValue().get("test")
|
|
+ "','device':'" + hTest.getValue().get("device")
|
|
+ "','status':'" + hTest.getValue().get("status") + "'}";
|
|
sParallelizeCommand = sParallelizeCommand + "')," + sParallelizeArguments;
|
|
i++;
|
|
if (i < iTotalEntries) {
|
|
sParallelizeCommand = sParallelizeCommand + ")),"; //between each "run" command
|
|
} else {
|
|
sParallelizeCommand = sParallelizeCommand + ")))"; //very last part of command "parallelize"
|
|
}
|
|
}
|
|
System.out.println(sParallelizeCommand);
|
|
Object ret;
|
|
//ret = eval("str(locals())");
|
|
//ret = eval("str(globals())");
|
|
ret = eval(sParallelizeCommand);
|
|
System.out.println("c");
|
|
// Object ret = eval("parallelize((run,(str('"+sTestPath+"'),)), (run,('Motor Test 3 200ms',)))");
|
|
//System.out.println("Ret = " + String.valueOf(ret));
|
|
String sTestResult, sTestStatus;
|
|
//read the return mapping and put the result in the right table row
|
|
//System.out.println("ret type "+ret.getClass().toString() );
|
|
//scan through all return mappings of all run tests
|
|
for (Object oTestRet : (ArrayList) ret) {
|
|
//check if the mapping of the selected test has all expected return values
|
|
if (((List<PyList>) oTestRet).size() >= 4) {
|
|
//extract return data of the current test
|
|
sTestPath = String.valueOf(((List<PyList>) oTestRet).get(0));
|
|
sDeviceName = String.valueOf(((List<PyList>) oTestRet).get(1));
|
|
sTestResult = String.valueOf(((List<PyList>) oTestRet).get(2));
|
|
sTestStatus = String.valueOf(((List<PyList>) oTestRet).get(3));
|
|
//from the map of executed tests, get the test name (key is test path)
|
|
HashMap<String, HashMap> hTest = hTests.get(sTestPath);
|
|
sTestName = String.valueOf(hTest.get("test"));
|
|
} else { //problem, the test script does not return all the expected return values
|
|
String sErrorText = "Test " + sTestPath + " did not return all required return values";
|
|
Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, sErrorText);
|
|
SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", sErrorText);
|
|
System.out.println(String.valueOf(sErrorText));
|
|
//try to fetch at least first element of returned map. If fails, it will go to catch
|
|
sTestPath = String.valueOf(((List<PyList>) oTestRet).get(0));
|
|
sTestStatus = sErrorText;
|
|
sTestResult = "false";
|
|
HashMap<String, HashMap> hTest = hTests.get(sTestPath);
|
|
sDeviceName = String.valueOf(hTest.get("device"));
|
|
sTestName = String.valueOf(hTest.get("test"));
|
|
}
|
|
System.out.println("Result: " + sDeviceName + "|" + sTestPath + "|" + sTestResult + "|" + sTestStatus);
|
|
iLastExecutedTestIndex = showResult(sDeviceName, sTestPath, sTestResult, sTestStatus);
|
|
}
|
|
} catch (ClassCastException ccex) {
|
|
Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ccex);
|
|
SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", ccex.toString());
|
|
//System.out.println(String.valueOf(ccex));
|
|
if (!sDeviceName.isEmpty()) {
|
|
showResult(sDeviceName, sTestPath, ccex.toString(), TestStatus.FAILURE.toString());
|
|
}
|
|
} catch (Exception ex) {
|
|
Logger.getLogger(TestingList.class.getName()).log(Level.SEVERE, null, ex);
|
|
SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup()", ex.toString());
|
|
System.out.println(String.valueOf(ex));
|
|
showResult(sDeviceName, sTestPath, ex.toString(), TestStatus.FAILURE.toString());
|
|
}
|
|
|
|
} catch (Exception ex) {
|
|
SwingUtils.showMessage(TestingList.this.getComponent(), "executeParallelTestsGroup(), run thread", ex.toString());
|
|
logger.log(Level.SEVERE, ex.toString());
|
|
setToStopped();
|
|
}
|
|
return iRet;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* table management
|
|
*/
|
|
private void buildTable() {
|
|
String sDate = getNow();
|
|
DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
|
|
jTable1.setModel(model);
|
|
|
|
//Set up the combo box editor for the Start Sequence cells.
|
|
JComboBox comboBox = new JComboBox();
|
|
comboBox.addItem(StartSequence.START_SEQ_AFTER.toString());
|
|
comboBox.addItem(StartSequence.START_SEQ_TOGETHER.toString());
|
|
jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellEditor(new DefaultCellEditor(comboBox));
|
|
//Set up tool tips for the sequence cells.
|
|
DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
|
|
renderer.setToolTipText("Click for options");
|
|
jTable1.getColumnModel().getColumn(COL.STARTSEQUENCE.ordinal()).setCellRenderer(renderer);
|
|
|
|
jTable1.getColumnModel().getColumn(COL.ICON.ordinal()).setMaxWidth(27);
|
|
jTable1.getColumnModel().getColumn(COL.CHECK.ordinal()).setMaxWidth(27);
|
|
jTable1.getColumnModel().getColumn(COL.DEVICENAME.ordinal()).setPreferredWidth(30);
|
|
jTable1.getColumnModel().getColumn(COL.STATUS.ordinal()).setPreferredWidth(30);
|
|
hideColumn(COL.DEVICEDESCR);
|
|
hideColumn(COL.TESTPATH);
|
|
hideColumn(COL.TESTDESCR);
|
|
hideColumn(COL.TESTPARAMS);
|
|
hideColumn(COL.TESTHELP);
|
|
jTable1.setAutoCreateRowSorter(true);
|
|
updateStatus();
|
|
}
|
|
|
|
private void hideColumn(COL column) {
|
|
jTable1.getColumnModel().getColumn(column.ordinal()).setMinWidth(0);
|
|
jTable1.getColumnModel().getColumn(column.ordinal()).setMaxWidth(0);
|
|
}
|
|
|
|
//append test info to table
|
|
private void addToTable(String deviceName,
|
|
String deviceDescription,
|
|
String testSuite,
|
|
String testName,
|
|
String testParams,
|
|
String testDescription,
|
|
String testHelp) {
|
|
String sDate = "";
|
|
if (testName.equals("") || deviceName.equals("")) {
|
|
return;
|
|
}
|
|
ImageIcon icon = null;// new ImageIcon(getClass().getResource("/icons/button_pause-16px.png"));
|
|
DefaultTableModel model = (DefaultTableModel) jTable1.getModel();
|
|
String testPath = FilenameUtils.separatorsToSystem(TESTS_TESTS_DEFAULT_DIR + testSuite + "/" + testName + "/" + testName + ".py");
|
|
model.addRow(new Object[]{false, "", sDate, deviceName, deviceDescription, testSuite, testName, testPath, testParams, testDescription, testHelp, "", "Pending", icon});
|
|
jTable1.setModel(model);
|
|
updateStatus();
|
|
}
|
|
|
|
/**
|
|
*get the current time in format like 2015/07/02 15:59:43
|
|
*
|
|
* @return formatted time
|
|
*/
|
|
public String getNow() {
|
|
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
|
|
Date date = new Date();
|
|
return dateFormat.format(date);
|
|
}
|
|
|
|
/**
|
|
*get the current time in format like 20150702155943
|
|
*
|
|
* @return time with sortable format
|
|
*/
|
|
public String getnow() {
|
|
DateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
|
|
Date date = new Date();
|
|
return dateFormat.format(date);
|
|
}
|
|
|
|
/**
|
|
*scan tests directory, scan devices directory, search for their test cases and scan for tests.
|
|
*
|
|
* @throws FileNotFoundException
|
|
* @throws IOException
|
|
*/
|
|
public void loadTests() throws FileNotFoundException, IOException {
|
|
Properties propDevice = new Properties();
|
|
Properties propTest = new Properties();
|
|
String fileName = TESTS_DEVICES_DEFAULT_DIR;
|
|
File folder = new File(fileName);
|
|
File testsFolder = null;
|
|
String sTestName;
|
|
int iCounter = 0;
|
|
//search devices and their tests
|
|
//Scan the list of devices
|
|
File[] listOfFiles = folder.listFiles();
|
|
for (File listOfFile : listOfFiles) {
|
|
propDevice.clear();
|
|
if (listOfFile.isFile()) {
|
|
} else if (listOfFile.isDirectory()) {
|
|
File configFile = new File(listOfFile.getPath() + FilenameUtils.separatorsToSystem("/.config"));
|
|
if (configFile.exists() && !configFile.isDirectory()) {
|
|
InputStream is = new FileInputStream(configFile);
|
|
propDevice.load(is);
|
|
//config of device was loaded. now load the config of each test belonging to the device
|
|
sTestName = TESTS_TESTS_DEFAULT_DIR + propDevice.getProperty("tests");
|
|
testsFolder = new File(sTestName);
|
|
if (testsFolder.exists() && testsFolder.isDirectory()) {
|
|
File[] listOfTests = testsFolder.listFiles();
|
|
for (File listOfTest : listOfTests) {
|
|
propTest.clear();
|
|
if (listOfTest.isDirectory()) {
|
|
configFile = new File(listOfTest.getPath() + FilenameUtils.separatorsToSystem("/.config"));
|
|
if (configFile.exists() && !configFile.isDirectory()) {
|
|
InputStream ist = new FileInputStream(configFile);
|
|
propTest.load(ist);
|
|
addToTable(propDevice.getProperty("name"),
|
|
propDevice.getProperty("description"),
|
|
propDevice.getProperty("tests"),
|
|
propTest.getProperty("name"),
|
|
propTest.getProperty("parameters"),
|
|
propTest.getProperty("description"),
|
|
propTest.getProperty("help"));
|
|
iCounter++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
logger.log(Level.INFO, iCounter + " tests loaded.");
|
|
}
|
|
|
|
/**
|
|
* Build a map with optional parameters to be passed to the testing
|
|
* script. The map is like this:
|
|
* parameters
|
|
* \_ name
|
|
* | \_ value
|
|
* | \_ description
|
|
* \_ name
|
|
* | \_ value
|
|
* | \_ description
|
|
* ...
|
|
* the name 'name' is the mapping key. 'value' and 'description' are constant
|
|
* mapping keys of a nested map.
|
|
*
|
|
* @param parametersString string containing the parameters. Syntax:
|
|
* name:value:description[;name:value:description;...]
|
|
*/
|
|
private HashMap buildParametersMap(String parametersString) {
|
|
HashMap mParameters = new HashMap(); // contains name and attributes
|
|
HashMap mParameterAttributes = new HashMap(); //contians value and description
|
|
String[] dsParameterAttributes = null;
|
|
String[] dsParameters = parametersString.split(";");
|
|
for (String sParameter : dsParameters) {
|
|
dsParameterAttributes = sParameter.split(":");
|
|
if (dsParameterAttributes.length > 2) {
|
|
mParameterAttributes = new HashMap();
|
|
mParameterAttributes.put("value", (Object) dsParameterAttributes[1]);
|
|
mParameterAttributes.put("description", dsParameterAttributes[2]);
|
|
//add parameter name and attributes (value + description)
|
|
mParameters.put(dsParameterAttributes[0], mParameterAttributes);
|
|
}
|
|
}
|
|
return mParameters;
|
|
}
|
|
|
|
/**
|
|
*Open file selector
|
|
*/
|
|
public void selectFile() {
|
|
final JFileChooser fc = new JFileChooser();
|
|
|
|
int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);
|
|
|
|
if (returnVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = fc.getSelectedFile();
|
|
//This is where a real application would open the file.
|
|
System.out.println("Opening: " + file.getName() + ".");
|
|
} else {
|
|
System.out.println("Open command cancelled by user.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save current setup in a file.
|
|
* The current position of table rows is also saved.
|
|
*/
|
|
public void saveSettings() {
|
|
final JFileChooser fc = new JFileChooser();
|
|
|
|
int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);
|
|
|
|
if (returnVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = fc.getSelectedFile();
|
|
saveSettings(file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save current setup in a file.
|
|
* The current position of table rows is also saved.
|
|
*
|
|
* @param file file containing the settings
|
|
*/
|
|
private void saveSettings(File file) {
|
|
DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel();
|
|
try {
|
|
ObjectOutputStream out = new ObjectOutputStream(
|
|
new FileOutputStream(file));
|
|
out.writeObject(tableModel.getDataVector());
|
|
out.close();
|
|
} catch (Exception ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save current setup in a file.
|
|
* The current position of table rows is also saved.
|
|
*/
|
|
public void loadSettings() {
|
|
final JFileChooser fc = new JFileChooser();
|
|
int returnVal = fc.showOpenDialog(NetbeansPluginPanel.this);
|
|
if (returnVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = fc.getSelectedFile();
|
|
loadSettings(file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save current setup in a file.
|
|
* The current position of table rows is also saved.
|
|
*
|
|
* @param file file containing the settings
|
|
*/
|
|
private void loadSettings(File file) {
|
|
DefaultTableModel tableModel = (DefaultTableModel) jTable1.getModel();
|
|
try {
|
|
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
|
|
Vector rowData = (Vector) in.readObject();
|
|
Iterator itr = rowData.iterator();
|
|
for (int row = 0; row < jTable1.getRowCount(); row++) {
|
|
tableModel.removeRow(row);
|
|
}
|
|
while (itr.hasNext()) {
|
|
tableModel.addRow((Vector) itr.next());
|
|
}
|
|
in.close();
|
|
} catch (Exception ex) {
|
|
ex.printStackTrace();
|
|
SwingUtils.showMessage(this, "loadSettings()", ex.toString());
|
|
}
|
|
}
|
|
|
|
//end of class
|
|
}
|
|
}
|