@Test
public void testMergeDifferentLineNumbers() {
firstClass.addLine(2, "helloWorld", "()V");
firstClass.addLine(3, "helloWorld", "()V");
greenProject.addClassData(firstClass);
firstClassB.addLine(1, "helloWorld", "()V");
firstClassB.addLine(5, "helloWorld", "()V");
redProject.addClassData(firstClassB);
greenProject.merge(redProject);
ClassData cd = greenProject.getClassData("test.First");
assertNotNull(cd);
assertEquals(4, cd.getNumberOfValidLines());
assertEquals(2, redProject.getClassData("test.First").getNumberOfValidLines());
Iterator lines = cd.getLines().iterator();
LineData line1 = (LineData) lines.next();
assertEquals(1, line1.getLineNumber());
LineData line2 = (LineData) lines.next();
assertEquals(2, line2.getLineNumber());
LineData line3 = (LineData) lines.next();
assertEquals(3, line3.getLineNumber());
LineData line5 = (LineData) lines.next();
assertEquals(5, line5.getLineNumber());
assertFalse(lines.hasNext());
}
public void clearState(Project project) {
myGlobals = null;
final String projectPath = getProjectPath(project);
synchronized (myProjectDataMap) {
final ProjectData data = myProjectDataMap.get(projectPath);
if (data != null) {
data.dropChanges();
}
}
}
@Test
public void testMergeBranches() {
firstClass.addLine(1, "helloWorld", "()V");
firstClass.addLineJump(1, 0);
firstClass.addLine(2, "helloWorld", "()V");
firstClass.addLineJump(2, 0);
firstClass.addLineJump(2, 1);
firstClass.addLine(3, "helloWorld", "()V");
firstClass.addLine(4, "helloWorld", "()V");
firstClass.addLineSwitch(4, 0, 0, 2);
firstClass.addLine(5, "helloWorld", "()V");
firstClass.addLine(8, "helloWorld", "()V");
greenProject.addClassData(firstClass);
firstClassB.addLine(1, "helloWorld", "()V");
firstClassB.addLineJump(1, 0);
firstClassB.addLine(2, "helloWorld", "()V");
firstClassB.addLine(3, "helloWorld", "()V");
firstClassB.addLineSwitch(3, 0, 2, 4);
firstClassB.addLine(6, "helloWorld", "()V");
firstClassB.addLineJump(6, 0);
firstClassB.addLine(7, "helloWorld", "()V");
firstClassB.addLine(8, "helloWorld", "()V");
redProject.addClassData(firstClassB);
greenProject.merge(redProject);
ClassData cd = greenProject.getClassData("test.First");
Iterator lines = cd.getLines().iterator();
LineData line1 = (LineData) lines.next();
assertTrue(line1.hasBranch());
LineData line2 = (LineData) lines.next();
assertTrue(line2.hasBranch());
LineData line3 = (LineData) lines.next();
assertTrue(line3.hasBranch());
LineData line4 = (LineData) lines.next();
assertTrue(line4.hasBranch());
LineData line5 = (LineData) lines.next();
assertFalse(line5.hasBranch());
LineData line6 = (LineData) lines.next();
assertTrue(line6.hasBranch());
LineData line7 = (LineData) lines.next();
assertFalse(line7.hasBranch());
LineData line8 = (LineData) lines.next();
assertFalse(line8.hasBranch());
assertFalse(lines.hasNext());
}
@Override
public void initialize(URL url, ResourceBundle rb) {
table = new TableView<>();
data = new ProjectData();
TableColumn idProjectCol = new TableColumn("ID");
idProjectCol.setCellValueFactory(
new PropertyValueFactory<ProjectDataItem, String>("IDProject"));
idProjectCol.setCellFactory(new EditableCell());
TableColumn nameCol = new TableColumn("Name");
nameCol.setCellValueFactory(new PropertyValueFactory<ProjectDataItem, String>("Name"));
nameCol.setCellFactory(new EditableCell());
TableColumn descriptionCol = new TableColumn("Description");
descriptionCol.setCellValueFactory(
new PropertyValueFactory<ProjectDataItem, String>("Description"));
descriptionCol.setCellFactory(new EditableCell());
table.setItems(data.getData());
table.getColumns().addAll(idProjectCol, nameCol, descriptionCol);
table.setEditable(true);
table.setTableMenuButtonVisible(true);
table.setContextMenu(new ProjectFormController.ProjectContextMenu());
table.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
paneTable.getChildren().add(table);
AnchorPane.setTopAnchor(table, 0.0);
AnchorPane.setLeftAnchor(table, 0.0);
AnchorPane.setRightAnchor(table, 0.0);
AnchorPane.setBottomAnchor(table, 50.0);
}
public static synchronized void applyTouchesOnProjectData(ProjectData projectData) {
logger.fine("=================== START OF REPORT ======================== ");
for (Class<?> c : registeredClasses.keySet()) {
logger.fine("Report: " + c.getName());
ClassData cd = projectData.getOrCreateClassData(c.getName());
applyTouchesToSingleClassOnProjectData(cd, c);
}
logger.fine("=================== END OF REPORT ======================== ");
}
@Test
public void testMergeSourceFiles() {
greenProject.addClassData(secondClass);
greenProject.addClassData(fourthClass);
redProject.addClassData(firstClass);
redProject.addClassData(fifthClass);
redProject.addClassData(seventhClass);
greenProject.merge(redProject);
Collection sources = greenProject.getSourceFiles();
assertEquals(5, sources.size());
Set sourceNames = new HashSet();
Iterator it = sources.iterator();
while (it.hasNext()) sourceNames.add(((SourceFileData) it.next()).getName());
assertTrue(sourceNames.contains("test/First.java"));
assertTrue(sourceNames.contains("test/Second.java"));
assertTrue(sourceNames.contains("test/me/Fourth.java"));
assertTrue(sourceNames.contains("beautiful/Fourth.java"));
assertTrue(sourceNames.contains("Seventh.java"));
}
@Test
public void testMergeSimillarLineNumbers() {
firstClass.addLine(2, "helloWorld", "()V");
firstClass.touch(2, 1);
firstClass.touch(2, 1);
firstClass.addLine(3, "helloWorld", "()V");
greenProject.addClassData(firstClass);
firstClassB.addLine(2, "helloWorld", "()V");
firstClassB.touch(2, 1);
firstClassB.touch(2, 1);
firstClassB.touch(2, 1);
firstClassB.addLine(3, "helloWorld", "()V");
firstClassB.touch(3, 1);
firstClassB.addLine(7, "helloWorld", "()V");
redProject.addClassData(firstClassB);
greenProject.merge(redProject);
ClassData cd = greenProject.getClassData("test.First");
assertNotNull(cd);
assertEquals(3, cd.getNumberOfValidLines());
assertEquals(3, redProject.getClassData("test.First").getNumberOfValidLines());
Iterator lines = cd.getLines().iterator();
LineData line2 = (LineData) lines.next();
assertEquals(2, line2.getLineNumber());
assertEquals(5, line2.getHits());
LineData line3 = (LineData) lines.next();
assertEquals(3, line3.getLineNumber());
assertEquals(1, line3.getHits());
LineData line7 = (LineData) lines.next();
assertEquals(7, line7.getLineNumber());
assertEquals(0, line7.getHits());
assertFalse(lines.hasNext());
}
void project() {
SearchProjectDetailDlg dlg =
new SearchProjectDetailDlg(
pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid);
dlg.setVisible(true);
if (dlg.getResponse() == JOptionPane.OK_OPTION) {
ProjectData[] project = dlg.getProjectData();
if (project.length > 0) {
m_project = project[0];
setNullFieldText();
m_codeTextField.setText(m_project.getCode());
ProjectBusinessLogic logic = new ProjectBusinessLogic(m_conn);
try {
m_customer = logic.getCustomerByCriteria1(m_project.getIndexcust(), m_conn);
} catch (Exception ex) {
}
if (m_customer != null) m_custTextField.setText(m_customer.getName());
if (m_project.getWorkDescription() != null)
m_wrkdescTextArea.setText(m_project.getWorkDescription());
m_unit = logic.getUnit(m_project.getIndexunit());
if (m_unit != null)
m_unitTextField.setText(m_unit.getCode() + " " + m_unit.getDescription());
m_activity = logic.getActivity(m_project.getIndexact());
if (m_activity != null) m_actTextField.setText(m_activity.getName());
m_org = logic.getOrganization(m_project.getIndexdept());
if (m_org != null) m_departTextField.setText(m_org.getName());
if (m_project.getPONo() != null) m_PONoTextField.setText(m_project.getPONo());
if (m_project.getIPCNo() != null) m_IPCNoTextField.setText(m_project.getIPCNo());
if (m_project.getPODate() != null)
m_PODateTextField.setText(m_dateformat.format(m_project.getPODate()));
if (m_project.getIPCDate() != null)
m_IPCDateTextField.setText(m_dateformat.format(m_project.getIPCDate()));
m_detailPanel.setEditable(true);
m_detailPanel.setProjectData(m_project);
m_detailPanel.setTimeSheet(m_project);
}
}
}
static {
ProjectData.getGlobalProjectData(); // To call ProjectData.initialize();
}
@Test
public void testMergePackages() {
greenProject.addClassData(firstClass);
greenProject.addClassData(fourthClass);
redProject.addClassData(fifthClass);
redProject.addClassData(sixthClass);
redProject.addClassData(seventhClass);
// merge with null - should not change the greenProject
greenProject.merge(null);
greenProject.merge(redProject);
Iterator subpackages = greenProject.getSubPackages("").iterator();
assertEquals("", ((PackageData) subpackages.next()).getName());
assertEquals("beautiful", ((PackageData) subpackages.next()).getName());
assertEquals("test", ((PackageData) subpackages.next()).getName());
assertEquals("test.me", ((PackageData) subpackages.next()).getName());
assertFalse(subpackages.hasNext());
assertEquals(5, greenProject.getClasses().size());
assertEquals(3, redProject.getClasses().size());
assertNotNull(greenProject.getClassData("test.First"));
assertNotNull(greenProject.getClassData("test.me.Fourth"));
assertNotNull(greenProject.getClassData("beautiful.Fourth"));
assertNotNull(greenProject.getClassData("Fourth"));
assertNotNull(greenProject.getClassData("Seventh"));
assertNull(redProject.getClassData("test.First"));
Iterator packages = greenProject.getPackages().iterator();
PackageData first = (PackageData) packages.next();
assertEquals("", first.getName());
assertEquals(2, first.getNumberOfChildren());
assertNotNull(first.getChild("Fourth"));
assertNotNull(first.getChild("Seventh"));
PackageData beautiful = (PackageData) packages.next();
assertEquals("beautiful", beautiful.getName());
assertEquals(1, beautiful.getNumberOfChildren());
assertNotNull(beautiful.getChild("Fourth"));
PackageData test = (PackageData) packages.next();
assertEquals("test", test.getName());
assertEquals(1, test.getNumberOfChildren());
assertNotNull(test.getChild("First"));
assertNull(test.getChild("test/me/First.java"));
assertNull(test.getChild("Fourth.java"));
PackageData testMe = (PackageData) packages.next();
assertEquals("test.me", testMe.getName());
assertEquals(1, testMe.getNumberOfChildren());
assertNull(testMe.getChild("test/First.java"));
assertNotNull(testMe.getChild("Fourth"));
assertNull(testMe.getChild("Fourth.java"));
assertFalse(packages.hasNext());
}
@Test
public void testMergeSimillarClassData() {
greenProject.addClassData(secondClass);
greenProject.addClassData(thirdClass);
redProject.addClassData(firstClass);
redProject.addClassData(thirdClass);
greenProject.merge(redProject);
assertEquals(1, greenProject.getNumberOfChildren());
assertEquals(3, greenProject.getClasses().size());
assertNotNull(greenProject.getClassData("test.First"));
assertNotNull(greenProject.getClassData("test.Second"));
assertNotNull(greenProject.getClassData("test.Third"));
assertNotNull(redProject.getClassData("test.First"));
assertNull(redProject.getClassData("test.Second"));
assertNotNull(redProject.getClassData("test.Third"));
}
@Nullable
public RequestFuture scheduleBuild(
final Project project,
final boolean isRebuild,
final boolean isMake,
final Collection<String> modules,
final Collection<String> artifacts,
final Collection<String> paths,
final Map<String, String> userData,
DefaultMessageHandler handler) {
final String projectPath = getProjectPath(project);
final UUID sessionId = UUID.randomUUID();
final CmdlineRemoteProto.Message.ControllerMessage params;
CmdlineRemoteProto.Message.ControllerMessage.GlobalSettings globals = myGlobals;
if (globals == null) {
globals = buildGlobalSettings();
myGlobals = globals;
}
CmdlineRemoteProto.Message.ControllerMessage.FSEvent currentFSChanges = null;
final SequentialTaskExecutor projectTaskQueue;
synchronized (myProjectDataMap) {
ProjectData data = myProjectDataMap.get(projectPath);
if (data == null) {
data = new ProjectData(new SequentialTaskExecutor(myPooledThreadExecutor));
myProjectDataMap.put(projectPath, data);
}
if (isRebuild) {
data.dropChanges();
}
currentFSChanges = data.getAndResetRescanFlag() ? null : data.createNextEvent();
projectTaskQueue = data.taskQueue;
}
if (isRebuild) {
params = CmdlineProtoUtil.createRebuildRequest(projectPath, userData, globals);
} else {
params =
isMake
? CmdlineProtoUtil.createMakeRequest(
projectPath, modules, artifacts, userData, globals, currentFSChanges)
: CmdlineProtoUtil.createForceCompileRequest(
projectPath, modules, artifacts, paths, userData, globals, currentFSChanges);
}
myMessageDispatcher.registerBuildMessageHandler(sessionId, handler, params);
// ensure server is listening
if (myListenPort < 0) {
try {
myListenPort = startListening();
} catch (Exception e) {
myMessageDispatcher.unregisterBuildMessageHandler(sessionId);
handler.handleFailure(sessionId, CmdlineProtoUtil.createFailure(e.getMessage(), null));
handler.sessionTerminated();
return null;
}
}
final RequestFuture<BuilderMessageHandler> future =
new RequestFuture<BuilderMessageHandler>(
handler,
sessionId,
new RequestFuture.CancelAction<BuilderMessageHandler>() {
@Override
public void cancel(RequestFuture<BuilderMessageHandler> future) throws Exception {
myMessageDispatcher.cancelSession(future.getRequestID());
}
});
projectTaskQueue.submit(
new Runnable() {
@Override
public void run() {
try {
if (project.isDisposed()) {
future.cancel(false);
return;
}
myBuildsInProgress.put(projectPath, future);
final Process process = launchBuildProcess(project, myListenPort, sessionId);
final OSProcessHandler processHandler =
new OSProcessHandler(process, null) {
@Override
protected boolean shouldDestroyProcessRecursively() {
return true;
}
};
final StringBuilder stdErrOutput = new StringBuilder();
processHandler.addProcessListener(
new ProcessAdapter() {
@Override
public void processTerminated(ProcessEvent event) {
final BuilderMessageHandler handler =
myMessageDispatcher.unregisterBuildMessageHandler(sessionId);
if (handler != null) {
handler.sessionTerminated();
}
}
@Override
public void onTextAvailable(ProcessEvent event, Key outputType) {
// re-translate builder's output to idea.log
final String text = event.getText();
if (!StringUtil.isEmpty(text)) {
LOG.info("BUILDER_PROCESS [" + outputType.toString() + "]: " + text.trim());
if (stdErrOutput.length() < 1024
&& ProcessOutputTypes.STDERR.equals(outputType)) {
stdErrOutput.append(text);
}
}
}
});
processHandler.startNotify();
final boolean terminated = processHandler.waitFor();
if (terminated) {
final int exitValue = processHandler.getProcess().exitValue();
if (exitValue != 0) {
final StringBuilder msg = new StringBuilder();
msg.append("Abnormal build process termination: ");
if (stdErrOutput.length() > 0) {
msg.append("\n").append(stdErrOutput);
} else {
msg.append("unknown error");
}
future
.getMessageHandler()
.handleFailure(
sessionId, CmdlineProtoUtil.createFailure(msg.toString(), null));
}
} else {
future
.getMessageHandler()
.handleFailure(
sessionId,
CmdlineProtoUtil.createFailure("Disconnected from build process", null));
}
} catch (ExecutionException e) {
myMessageDispatcher.unregisterBuildMessageHandler(sessionId);
future
.getMessageHandler()
.handleFailure(sessionId, CmdlineProtoUtil.createFailure(e.getMessage(), e));
future.getMessageHandler().sessionTerminated();
} finally {
myBuildsInProgress.remove(projectPath);
future.setDone();
}
}
});
return future;
}
