modules/graphics/src/test/java/test/javafx/concurrent/TaskProgressTest.java
Print this page
rev 9250 : 8134762: Refactor Javafx graphics module tests for clear separation of tests
Reviewed-by:
@@ -21,13 +21,15 @@
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
-package javafx.concurrent;
+package test.javafx.concurrent;
-import javafx.concurrent.mocks.ProgressingTask;
+import javafx.concurrent.Task;
+import javafx.concurrent.TaskShim;
+import test.javafx.concurrent.mocks.ProgressingTask;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
@@ -68,201 +70,201 @@
* Test the updateProgress method on Task, that various inputs lead to
* expected outputs according to the specification
***********************************************************************/
@Test public void updateProgress_Long_0_100() {
- task.updateProgress(0, 100);
+ TaskShim.updateProgress(task, 0, 100);
assertEquals(0, task.getProgress(), 0);
assertEquals(0, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_n1_100() {
- task.updateProgress(-1, 100);
+ TaskShim.updateProgress(task, -1, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_n10_100() {
- task.updateProgress(-10, 100);
+ TaskShim.updateProgress(task, -10, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_MIN_VALUE_100() {
- task.updateProgress(Long.MIN_VALUE, 100);
+ TaskShim.updateProgress(task, Long.MIN_VALUE, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_10_100() {
- task.updateProgress(10, 100);
+ TaskShim.updateProgress(task, 10, 100);
assertEquals(.1, task.getProgress(), 0);
assertEquals(10, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_100_100() {
- task.updateProgress(100, 100);
+ TaskShim.updateProgress(task, 100, 100);
assertEquals(1, task.getProgress(), 0);
assertEquals(100, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_110_100() {
- task.updateProgress(110, 100);
+ TaskShim.updateProgress(task, 110, 100);
assertEquals(1, task.getProgress(), 0);
assertEquals(100, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_MAX_VALUE_100() {
- task.updateProgress(Long.MAX_VALUE, 100);
+ TaskShim.updateProgress(task, Long.MAX_VALUE, 100);
assertEquals(1, task.getProgress(), 0);
assertEquals(100, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_0_n1() {
- task.updateProgress(0, -1);
+ TaskShim.updateProgress(task, 0, -1);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_0_n10() {
- task.updateProgress(0, -10);
+ TaskShim.updateProgress(task, 0, -10);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_0_MIN_VALUE() {
- task.updateProgress(0, Long.MIN_VALUE);
+ TaskShim.updateProgress(task, 0, Long.MIN_VALUE);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_100_10() {
- task.updateProgress(100, 10);
+ TaskShim.updateProgress(task, 100, 10);
assertEquals(1, task.getProgress(), 0);
assertEquals(10, task.getWorkDone(), 0);
assertEquals(10, task.getTotalWork(), 0);
}
@Test public void updateProgress_Long_100_MAX_VALUE() {
- task.updateProgress(100, Long.MAX_VALUE);
+ TaskShim.updateProgress(task, 100, Long.MAX_VALUE);
assertEquals(100.0 / Long.MAX_VALUE, task.getProgress(), 0);
assertEquals(100, task.getWorkDone(), 0);
assertEquals(Long.MAX_VALUE, task.getTotalWork(), 0);
}
/* Now test the Double variants (Infinity, NaN)*/
@Test public void updateProgress_Double_Infinity_100() {
- task.updateProgress(Double.POSITIVE_INFINITY, 100);
+ TaskShim.updateProgress(task, Double.POSITIVE_INFINITY, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NInfinity_100() {
- task.updateProgress(Double.NEGATIVE_INFINITY, 100);
+ TaskShim.updateProgress(task, Double.NEGATIVE_INFINITY, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NaN_100() {
- task.updateProgress(Double.NaN, 100);
+ TaskShim.updateProgress(task, Double.NaN, 100);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(100, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_0_Infinity() {
- task.updateProgress(0, Double.POSITIVE_INFINITY);
+ TaskShim.updateProgress(task, 0, Double.POSITIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_0_NInfinity() {
- task.updateProgress(0, Double.NEGATIVE_INFINITY);
+ TaskShim.updateProgress(task, 0, Double.NEGATIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_0_NaN() {
- task.updateProgress(0, Double.NaN);
+ TaskShim.updateProgress(task, 0, Double.NaN);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_Infinity_Infinity() {
- task.updateProgress(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NInfinity_Infinity() {
- task.updateProgress(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_Infinity_NInfinity() {
- task.updateProgress(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NInfinity_NInfinity() {
- task.updateProgress(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_Infinity_NaN() {
- task.updateProgress(Double.POSITIVE_INFINITY, Double.NaN);
+ TaskShim.updateProgress(task, Double.POSITIVE_INFINITY, Double.NaN);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NInfinity_NaN() {
- task.updateProgress(Double.NEGATIVE_INFINITY, Double.NaN);
+ TaskShim.updateProgress(task, Double.NEGATIVE_INFINITY, Double.NaN);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NaN_Infinity() {
- task.updateProgress(Double.NaN, Double.POSITIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.NaN, Double.POSITIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NaN_NInfinity() {
- task.updateProgress(Double.NaN, Double.NEGATIVE_INFINITY);
+ TaskShim.updateProgress(task, Double.NaN, Double.NEGATIVE_INFINITY);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
@Test public void updateProgress_Double_NaN_NaN() {
- task.updateProgress(Double.NaN, Double.NaN);
+ TaskShim.updateProgress(task, Double.NaN, Double.NaN);
assertEquals(-1, task.getProgress(), 0);
assertEquals(-1, task.getWorkDone(), 0);
assertEquals(-1, task.getTotalWork(), 0);
}
}