/ - Diff - EDIT - EDIT Project Management

      */
     package eu.etaxonomy.taxeditor.model;
     import java.io.Serializable;
     import org.eclipse.core.runtime.IProgressMonitor;
     import org.eclipse.core.runtime.NullProgressMonitor;
-...
     		progressMonitor.internalWorked(arg0);
+    	}
         /**
          * {@inheritDoc}
          */
         @Override
         public Serializable getFeedback() {
             return null;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean getIsWaitingForFeedback() {
             return false;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setFeedback(Serializable arg0) {
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void waitForFeedback() {
             // TODO Auto-generated method stub
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public String getOwner() {
             return null;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean hasFeedbackWaitTimedOut() {
             return false;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void interrupt() {
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setOwner(String arg0) {
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void waitForFeedback(long arg0) {
+        }
+    }

     // $Id$
     /**
     * Copyright (C) 2015 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.taxeditor.operation;
     import java.io.Serializable;
     import java.util.UUID;
     import org.eclipse.swt.widgets.Display;
     import eu.etaxonomy.cdm.api.application.CdmApplicationState;
     /**
      * Default implementation of the {@link IFeedbackGenerator} interface.
+     *
      * @author cmathew
      * @date 29 Oct 2015
+     *
      */
     public abstract class FeedbackGenerator implements IFeedbackGenerator {
         /**
          * Generates feedback for a waiting remoting progress monitor
+         *
          * @return feedback object
          */
         public abstract Serializable generateFeedback();
         /**
          * {@inheritDoc}
          */
         @Override
         public void setFeedbackForMonitor(final UUID uuid) {
             Display.getDefault().syncExec(new Runnable() {
                 @Override
                 public void run() {
                     CdmApplicationState.getCurrentAppConfig().getProgressMonitorService().setFeedback(uuid, generateFeedback());
+                }
             });
+        }
+    }

     */
     package eu.etaxonomy.taxeditor.operation;
     import java.io.Serializable;
     import java.util.UUID;
     /**
      * Generates feeback for waiting remoting progress monitors.
      * The default implementation of this interface is {@link FeedbackGenerator}
+     *
      * @author cmathew
      * @date 28 Oct 2015
+     *
      */
     public interface IFeedbackGenerator {
         public Serializable generateFeedback();
         /**
          * Generates and sets feedback for a waiting remoting progress
          * monitor corresponding to the given uuid.
+         *
          * @param uuid of target waiting remoting progress monitor
          */
         public void setFeedbackForMonitor(UUID uuid);
+    }

     // $Id$
     /**
     * Copyright (C) 2015 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.taxeditor.ui.dialog;
     import java.io.Serializable;
     import org.eclipse.swt.SWT;
     import org.eclipse.swt.widgets.MessageBox;
     import org.eclipse.swt.widgets.Shell;
     import eu.etaxonomy.taxeditor.operation.FeedbackGenerator;
     /**
      * Feedback Generator corresponding to a {@link MessageBox}
+     *
      * @author cmathew
      * @date 29 Oct 2015
+     *
      */
     public class FeedbackMessageBox extends FeedbackGenerator {
         private Shell shell;
         /**
          * @param parent
          */
         public FeedbackMessageBox(Shell parent) {
             this.shell = parent;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public Serializable generateFeedback() {
          // create a dialog with ok and cancel buttons and a question icon
             MessageBox dialog =
               new MessageBox(shell, SWT.ICON_QUESTION | SWT.OK| SWT.CANCEL);
             dialog.setText("Monitor Feedback");
             dialog.setMessage("Do you really want to continue?");
             // open dialog and await user selection
             return dialog.open();
+        }
+    }

                     Thread.sleep(pollInterval);
                     remotingMonitor = progressMonitorService.getRemotingMonitor(uuid);
                     // check if remoting monitor is waiting for feedback
                     if(remotingMonitor.isWaitingForFeedback()) {
                     if(remotingMonitor.getIsWaitingForFeedback()) {
                         if(feedbackGenerators != null) {
                             // if we have run out of feedback generators while
                             // the remoting monitor is waiting on feedback
-...
                             if(feedbackCount + 1 > feedbackGenerators.size()) {
                                 throw new IllegalStateException("Remoting monitor waiting on feedback that does not exist");
+                            }
                             progressMonitorService.setFeedback(uuid, feedbackGenerators.get(feedbackCount).generateFeedback());
                             feedbackGenerators.get(feedbackCount).setFeedbackForMonitor(uuid);
                             feedbackCount++;
+                        }
+                    }

      */
     package eu.etaxonomy.taxeditor.service;
     import java.io.Serializable;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
-...
     import org.junit.Assert;
     import org.junit.Test;
     import eu.etaxonomy.cdm.api.application.CdmApplicationState;
     import eu.etaxonomy.cdm.api.service.IProgressMonitorService;
     import eu.etaxonomy.cdm.api.service.ITestService;
     import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
-...
         @Test
         public void testMonitLongRunningMethod() throws InterruptedException {
             UUID uuid = testService.monitLongRunningMethod(null, null);
             UUID uuid = testService.monitLongRunningMethod(null, null, 0);
             int pollInterval = 1000;
             RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult("Success");
-...
         public void testMonitLongRunningMethodByChangingUser() throws InterruptedException {
             IllegalStateException ise = new IllegalStateException("IllegalStateException");
             UUID uuid = testService.monitLongRunningMethod(ise, null);
             UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
             authenticateExtraUser();
             IRemotingProgressMonitor monitor = progressMonitorService.getRemotingMonitor(uuid);
             Assert.assertNull(monitor);
-...
         @Test
         public void testMonitLongRunningMethodWithException() throws InterruptedException {
             IllegalStateException ise = new IllegalStateException("IllegalStateException");
             UUID uuid = testService.monitLongRunningMethod(ise, null);
             UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
             int pollInterval = 1000;
             RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult(ise);
-...
         @Test
         public void testMonitLongRunningMethodWithInterrupt() {
             IllegalStateException ise = new IllegalStateException("Interrupted Exception");
             final UUID uuid = testService.monitLongRunningMethod(ise, null);
             final UUID uuid = testService.monitLongRunningMethod(ise, null, 0);
             final int pollInterval = 1000;
             final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult(ise);
-...
                                 null,
                                 (IFeedbackGenerator)null,
                                 new NullProgressMonitor());
                         Assert.fail("InterruptedException wrapped in an IllegalStateException should be thrown");
                     } catch (InterruptedException e) {
                     } catch (IllegalStateException e) {
+                    }
+                }
             };
-...
         @Test
         public void testMonitLongRunningMethodWithCancellation() throws InterruptedException {
             final UUID uuid = testService.monitLongRunningMethod(null, null);
             final UUID uuid = testService.monitLongRunningMethod(null, null, 0);
             final int pollInterval = 1000;
             final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult("Cancelled");
-...
             final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult("Success");
             for(String feedback : feedbacks) {
                 feebackGenerators.add(new MockFeedbackGenerator(feedback));
                 feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
                 expectedMonitor.addReport(feedback);
+            }
             expectedMonitor.addReport("Report");
             expectedMonitor.done();
             final UUID uuid = testService.monitLongRunningMethod(null, feedbacks);
             final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
             final int pollInterval = 1000;
             CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
-...
                     feebackGenerators,
                     new NullProgressMonitor());
+        }
         @Test
         public void testMonitLongRunningMethodWithInconsistentWaitForFeedback() throws InterruptedException {
             List<String> feedbacks = Arrays.asList("feedback1", "feedback2");
             List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
             final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult("Success");
             for(String feedback : feedbacks) {
                 feebackGenerators.add(new MockFeedbackGenerator(feedback, 0));
                 expectedMonitor.addReport(feedback);
+            }
             expectedMonitor.addReport("Report");
             expectedMonitor.done();
             final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 0);
             final int pollInterval = 1000;
             feebackGenerators.remove(1);
             final UUID newUuid = testService.monitLongRunningMethod(null, feedbacks);
             final UUID newUuid = testService.monitLongRunningMethod(null, feedbacks, 0);
             try {
                 CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
-...
             } catch(IllegalStateException ise) {
+            }
+        }
         @Test
         public void testMonitLongRunningMethodWithWaitForFeedbackTimeout() throws InterruptedException {
             List<String> feedbacks = Arrays.asList("feedback1");
             List<IFeedbackGenerator> feebackGenerators = new ArrayList<IFeedbackGenerator>();
             final RemotingProgressMonitor expectedMonitor = new RemotingProgressMonitor();
             expectedMonitor.setResult(new IllegalStateException(new InterruptedException()));
             for(String feedback : feedbacks) {
                 feebackGenerators.add(new MockFeedbackGenerator(feedback, 1000 * 15));
+            }
             expectedMonitor.setCanceled(true);
             expectedMonitor.setIsFailed(true);
             expectedMonitor.done();
             expectedMonitor.done();
             final UUID uuid = testService.monitLongRunningMethod(null, feedbacks, 1000 * 5);
             final int pollInterval = 1000;
             try {
                 CdmStore.getProgressMonitorClientManager().pollMonitor("Testing Progress Monitor",
                         uuid,
                         pollInterval,
                         new MockPostMoniteredOperationEnabled(expectedMonitor, uuid),
                         feebackGenerators,
                         new NullProgressMonitor());
                 Assert.fail("Exception due to inconsistent number of feedback generators not thrown");
             } catch(IllegalStateException ise) {
+            }
+        }
-...
         class MockFeedbackGenerator implements IFeedbackGenerator {
             private String feedback;
             private long waitTime;
             public MockFeedbackGenerator(String feedback) {
             public MockFeedbackGenerator(String feedback, long waitTime) {
                 this.feedback = feedback;
                 this.waitTime = waitTime;
+            }
             /**
              * {@inheritDoc}
              */
             @Override
             public Serializable generateFeedback() {
                 return feedback;
             public void setFeedbackForMonitor(UUID uuid) {
                 if(waitTime > 0) {
                     try {
                         Thread.sleep(waitTime);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
+                    }
+                }
                 CdmApplicationState.getCurrentAppConfig().getProgressMonitorService().setFeedback(uuid, feedback);
+            }
+        }

Project

General

Profile

EDIT

Revision cc7c531b

Added by Cherian Mathew about 8 years ago