| /******************************************************************************* |
| * Copyright (c) 2006, 2012 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.core.tests.runtime; |
| |
| import junit.framework.Assert; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| |
| /** |
| * |
| */ |
| public class TestProgressMonitor implements IProgressMonitor { |
| |
| private double totalWork; |
| |
| /** |
| * Records the number of times worked or internalWorked was called with |
| * an argument of 0. |
| */ |
| private int redundantWorkCalls; |
| |
| /** |
| * Records the number of times setTaskName was called without changing the |
| * existing task name. |
| */ |
| private int redundantSetTaskCalls; |
| |
| /** |
| * Records the number of times subTask was called without changing the |
| * existing task name |
| */ |
| private int redundantSubTaskCalls; |
| |
| /** |
| * Stores the number of calls to the integer worked(...) method |
| */ |
| private int intWorkedCalls; |
| |
| /** |
| * Stores the number of calls to the double internalWorked(...) method |
| */ |
| private int doubleWorkedCalls; |
| |
| /** |
| * Stores the total number of calls to worked and internalWorked |
| */ |
| private int workCalls; |
| |
| /** |
| * Stores the total number of calls to setTaskName |
| */ |
| private int taskNameCalls; |
| |
| /** |
| * Stores the total number of calls to subTask |
| */ |
| private int subTaskCalls; |
| |
| /** |
| * Stores the total number of calls to isCanceled |
| */ |
| private int isCanceledCalls; |
| |
| private int beginTaskCalls; |
| |
| private int doneCalls; |
| |
| private String taskName = null; |
| |
| private String subTaskName = null; |
| |
| private int expectedWork; |
| |
| private String beginTaskName = ""; |
| |
| private boolean cancelled = false; |
| |
| public String getBeginTaskName() { |
| return beginTaskName; |
| } |
| |
| private static boolean equals(Object o1, Object o2) { |
| if (o1 == null) |
| return o2 == null; |
| if (o2 == null) |
| return false; |
| return o1.equals(o2); |
| } |
| |
| /** |
| * Returns the number of times beginTask() was called. For a correctly written job, |
| * this should equal 1 on completion. |
| * |
| * @return the number of calls to beginTask |
| */ |
| public int getBeginTaskCalls() { |
| return beginTaskCalls; |
| } |
| |
| /** |
| * Returns the number of times done() was called. For a correctly written job, |
| * this should equal 1 on completion. |
| * |
| * @return the number of calls to done |
| */ |
| public int getDoneCalls() { |
| return doneCalls; |
| } |
| |
| /** |
| * Returns the number of times worked was called as a no-op. |
| * That is, it counts the number of times worked() or internalWorked() had |
| * ever been called with a value of 0. This should return 0 for an |
| * optimally-written job. |
| * |
| * @return true iff redundant calls were ever made to *worked() on this |
| * monitor. |
| */ |
| public int getRedundantWorkCalls() { |
| return redundantWorkCalls; |
| } |
| |
| /** |
| * Returns the number of calls to isCancelled(). Optimally-written |
| * jobs may call this an unbounded number of times. |
| * |
| * @return the number of calls to isCancelled(). |
| */ |
| public int getIsCanceledCalls() { |
| return isCanceledCalls; |
| } |
| |
| /** |
| * Returns the number of calls to subTask(). |
| */ |
| public int getSubTaskCalls() { |
| return subTaskCalls; |
| } |
| |
| /** |
| * Returs the number of calls to setTaskName(). |
| */ |
| public int getTaskNameCalls() { |
| return taskNameCalls; |
| } |
| |
| /** |
| * Returns the number of calls to work() and internalWorked(). For the top-level |
| * progress monitor in an optimally-written job, this should be at least 100 and |
| * no more than 1000. A job that reports work less often than this will seem to |
| * have jumpy progress, and a job that reports work more often than this is reporting |
| * progress that won't be visible to the user and is wasting time in progress monitoring |
| * code. |
| * |
| * @return the number of calls to worked(int) or internalWorked(double) |
| */ |
| public int getWorkCalls() { |
| return workCalls; |
| } |
| |
| /** |
| * Returns the number of calls to internalWorked. For an optimally-written job, |
| * this should be 0, since integer work is faster and has no chance |
| * of floating-point rounding errors. |
| * |
| * @return the number of calls to internalWorked |
| */ |
| public int getDoubleWorkedCalls() { |
| return doubleWorkedCalls; |
| } |
| |
| /** |
| * Returns the number of calls to worked(int). For an optimally-written job, |
| * this should equal getWorkCalls, since integer work is faster and has no |
| * chance of floating-point rounding errors. |
| * |
| * @return the number of calls to worked(int) |
| */ |
| public int getIntWorkedCalls() { |
| return intWorkedCalls; |
| } |
| |
| public int getRedundantSetTaskCalls() { |
| return redundantSetTaskCalls; |
| } |
| |
| public int getRedundantSubTaskCalls() { |
| return redundantSubTaskCalls; |
| } |
| |
| /** |
| * Returns the total work reported on this monitor. For an optimally-written job, |
| * this should be +/- a small epsilon to account for floating point error. |
| * |
| * @return the total work reported on this job |
| */ |
| public double getTotalWork() { |
| return totalWork; |
| } |
| |
| public void beginTask(String name, int workToDo) { |
| beginTaskCalls++; |
| this.expectedWork = workToDo; |
| this.beginTaskName = name; |
| } |
| |
| public void done() { |
| doneCalls++; |
| } |
| |
| public void internalWorked(double work) { |
| workCalls++; |
| doubleWorkedCalls++; |
| if (work == 0.0) |
| redundantWorkCalls++; |
| totalWork += work; |
| } |
| |
| public boolean isCanceled() { |
| isCanceledCalls++; |
| return cancelled; |
| } |
| |
| public void setCanceled(boolean value) { |
| this.cancelled = value; |
| } |
| |
| public void setTaskName(String name) { |
| taskNameCalls++; |
| if (equals(name, taskName)) |
| redundantSetTaskCalls++; |
| taskName = name; |
| } |
| |
| public void subTask(String name) { |
| subTaskCalls++; |
| if (equals(name, subTaskName)) |
| redundantSubTaskCalls++; |
| subTaskName = name; |
| } |
| |
| public void worked(int work) { |
| workCalls++; |
| intWorkedCalls++; |
| if (work == 0) |
| redundantWorkCalls++; |
| totalWork += work; |
| } |
| |
| public int getExpectedWork() { |
| return expectedWork; |
| } |
| |
| /** |
| * <p>Asserts that the progress reported on this monitor was optimal. That is, |
| * there were no redundant method calls, and progress was reported in between |
| * 100 and 1000 increments.</p> |
| */ |
| public void assertOptimal() { |
| Assert.assertEquals("The progress monitor did not reach 100%", expectedWork, getTotalWork(), 0.01d); |
| Assert.assertTrue("This monitor reported progress with less than 1% accuracy", getWorkCalls() >= 100); |
| Assert.assertTrue("This monitor reported progress with more than 0.1% accuracy (the job spent too much time reporting redundant progress)", getWorkCalls() <= 1000); |
| Assert.assertEquals("Null work was reported on this monitor", 0, getRedundantWorkCalls()); |
| |
| if (expectedWork >= 1000) { |
| // Only check for internalWorked usage if there were enough ticks allocated on this progress |
| // monitor that worked(int) could have been used |
| Assert.assertEquals("internalWorked was being used instead of worked()", 0, getDoubleWorkedCalls()); |
| } |
| |
| Assert.assertEquals("Redundant calls were made to setTaskName", 0, getRedundantSetTaskCalls()); |
| Assert.assertEquals("Redundant calls were made to subTask", 0, getRedundantSubTaskCalls()); |
| Assert.assertEquals("The number of calls to done should match the number of calls to beginTask", getBeginTaskCalls(), getDoneCalls()); |
| Assert.assertEquals("beginTask should be called exactly once", getBeginTaskCalls(), 1); |
| } |
| |
| public String getSubTaskName() { |
| return subTaskName == null ? "" : subTaskName; |
| } |
| |
| public String getTaskName() { |
| return taskName == null ? "" : taskName; |
| } |
| |
| } |