[nikiroo-utils.git] / test_code / ProgressTest.java

package be.nikiroo.utils.test_code;

import be.nikiroo.utils.Progress;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

class ProgressTest extends TestLauncher {
	public ProgressTest(String[] args) {
		super("Progress reporting", args);

		addSeries(new TestLauncher("Simple progress", args) {
			{
				addTest(new TestCase("Relative values and direct values") {
					@Override
					public void test() throws Exception {
						Progress p = new Progress();
						assertEquals(0, p.getProgress());
						assertEquals(0, p.getRelativeProgress());
						p.setProgress(33);
						assertEquals(33, p.getProgress());
						assertEquals(0.33, p.getRelativeProgress());
						p.setMax(3);
						p.setProgress(1);
						assertEquals(1, p.getProgress());
						assertEquals(
								generateAssertMessage("0.33..",
										p.getRelativeProgress()), true,
								p.getRelativeProgress() >= 0.332);
						assertEquals(
								generateAssertMessage("0.33..",
										p.getRelativeProgress()), true,
								p.getRelativeProgress() <= 0.334);
					}
				});

				addTest(new TestCase("Listeners at first level") {
					int pg;

					@Override
					public void test() throws Exception {
						Progress p = new Progress();
						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								pg = progress.getProgress();
							}
						});

						p.setProgress(42);
						assertEquals(42, pg);
						p.setProgress(0);
						assertEquals(0, pg);
					}
				});
			}
		});

		addSeries(new TestLauncher("Progress with children", args) {
			{
				addTest(new TestCase("One child") {
					@Override
					public void test() throws Exception {
						Progress p = new Progress();
						Progress child = new Progress();

						p.addProgress(child, 100);

						child.setProgress(42);
						assertEquals(42, p.getProgress());
					}
				});

				addTest(new TestCase("Multiple children") {
					@Override
					public void test() throws Exception {
						Progress p = new Progress();
						Progress child1 = new Progress();
						Progress child2 = new Progress();
						Progress child3 = new Progress();

						p.addProgress(child1, 20);
						p.addProgress(child2, 60);
						p.addProgress(child3, 20);

						child1.setProgress(50);
						assertEquals(10, p.getProgress());
						child2.setProgress(100);
						assertEquals(70, p.getProgress());
						child3.setProgress(100);
						assertEquals(90, p.getProgress());
						child1.setProgress(100);
						assertEquals(100, p.getProgress());
					}
				});

				addTest(new TestCase("Listeners with children") {
					int pg;

					@Override
					public void test() throws Exception {
						final Progress p = new Progress();
						Progress child1 = new Progress();
						Progress child2 = new Progress();
						p.addProgress(child1, 50);
						p.addProgress(child2, 50);

						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								pg = p.getProgress();
							}
						});

						child1.setProgress(50);
						assertEquals(25, pg);
						child2.setProgress(100);
						assertEquals(75, pg);
						child1.setProgress(100);
						assertEquals(100, pg);
					}
				});

				addTest(new TestCase("Listeners with children, not 1-100") {
					int pg;

					@Override
					public void test() throws Exception {
						final Progress p = new Progress();
						p.setMax(1000);

						Progress child1 = new Progress();
						child1.setMax(2);

						Progress child2 = new Progress();
						p.addProgress(child1, 500);
						p.addProgress(child2, 500);

						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								pg = p.getProgress();
							}
						});

						child1.setProgress(1);
						assertEquals(250, pg);
						child2.setProgress(100);
						assertEquals(750, pg);
						child1.setProgress(2);
						assertEquals(1000, pg);
					}
				});

				addTest(new TestCase(
						"Listeners with children, not 1-100, local progress") {
					int pg;

					@Override
					public void test() throws Exception {
						final Progress p = new Progress();
						p.setMax(1000);

						Progress child1 = new Progress();
						child1.setMax(2);

						Progress child2 = new Progress();
						p.addProgress(child1, 400);
						p.addProgress(child2, 400);
						// 200 = local progress

						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								pg = p.getProgress();
							}
						});

						child1.setProgress(1);
						assertEquals(200, pg);
						child2.setProgress(100);
						assertEquals(600, pg);
						p.setProgress(100);
						assertEquals(700, pg);
						child1.setProgress(2);
						assertEquals(900, pg);
						p.setProgress(200);
						assertEquals(1000, pg);
					}
				});

				addTest(new TestCase("Listeners with 5+ children, 4+ depth") {
					int pg;

					@Override
					public void test() throws Exception {
						final Progress p = new Progress();
						Progress child1 = new Progress();
						Progress child2 = new Progress();
						p.addProgress(child1, 50);
						p.addProgress(child2, 50);
						Progress child11 = new Progress();
						child1.addProgress(child11, 100);
						Progress child111 = new Progress();
						child11.addProgress(child111, 100);
						Progress child1111 = new Progress();
						child111.addProgress(child1111, 20);
						Progress child1112 = new Progress();
						child111.addProgress(child1112, 20);
						Progress child1113 = new Progress();
						child111.addProgress(child1113, 20);
						Progress child1114 = new Progress();
						child111.addProgress(child1114, 20);
						Progress child1115 = new Progress();
						child111.addProgress(child1115, 20);

						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								pg = p.getProgress();
							}
						});

						child1111.setProgress(100);
						child1112.setProgress(50);
						child1113.setProgress(25);
						child1114.setProgress(25);
						child1115.setProgress(50);
						assertEquals(25, pg);
						child2.setProgress(100);
						assertEquals(75, pg);
						child1111.setProgress(100);
						child1112.setProgress(100);
						child1113.setProgress(100);
						child1114.setProgress(100);
						child1115.setProgress(100);
						assertEquals(100, pg);
					}
				});

				addTest(new TestCase("Listeners with children, multi-thread") {
					int pg;
					boolean decrease;
					Object lock1 = new Object();
					Object lock2 = new Object();
					int currentStep1;
					int currentStep2;

					@Override
					public void test() throws Exception {
						final Progress p = new Progress(0, 200);

						final Progress child1 = new Progress();
						final Progress child2 = new Progress();
						p.addProgress(child1, 100);
						p.addProgress(child2, 100);

						p.addProgressListener(new Progress.ProgressListener() {
							@Override
							public void progress(Progress progress, String name) {
								int now = p.getProgress();
								if (now < pg) {
									decrease = true;
								}
								pg = now;
							}
						});

						// Run 200 concurrent threads, 2 at a time allowed to
						// make progress (each on a different child)
						for (int i = 0; i <= 100; i++) {
							final int step = i;
							new Thread(new Runnable() {
								@Override
								public void run() {
									synchronized (lock1) {
										if (step > currentStep1) {
											currentStep1 = step;
											child1.setProgress(step);
										}
									}
								}
							}).start();

							new Thread(new Runnable() {
								@Override
								public void run() {
									synchronized (lock2) {
										if (step > currentStep2) {
											currentStep2 = step;
											child2.setProgress(step);
										}
									}
								}
							}).start();
						}

						int i;
						int timeout = 20; // in 1/10th of seconds
						for (i = 0; i < timeout
								&& (currentStep1 + currentStep2) < 200; i++) {
							Thread.sleep(100);
						}

						assertEquals("The test froze at step " + currentStep1
								+ " + " + currentStep2, true, i < timeout);
						assertEquals(
								"There should not have any decresing steps",
								decrease, false);
						assertEquals("The progress should have reached 200",
								200, p.getProgress());
						assertEquals(
								"The progress should have reached completion",
								true, p.isDone());
					}
				});
			}
		});
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils.test_code;
	2
	3	import be.nikiroo.utils.Progress;
	4	import be.nikiroo.utils.test.TestCase;
	5	import be.nikiroo.utils.test.TestLauncher;
	6
	7	class ProgressTest extends TestLauncher {
	8	public ProgressTest(String[] args) {
	9	super("Progress reporting", args);
	10
	11	addSeries(new TestLauncher("Simple progress", args) {
	12	{
	13	addTest(new TestCase("Relative values and direct values") {
	14	@Override
	15	public void test() throws Exception {
	16	Progress p = new Progress();
	17	assertEquals(0, p.getProgress());
	18	assertEquals(0, p.getRelativeProgress());
	19	p.setProgress(33);
	20	assertEquals(33, p.getProgress());
	21	assertEquals(0.33, p.getRelativeProgress());
	22	p.setMax(3);
	23	p.setProgress(1);
	24	assertEquals(1, p.getProgress());
	25	assertEquals(
	26	generateAssertMessage("0.33..",
	27	p.getRelativeProgress()), true,
	28	p.getRelativeProgress() >= 0.332);
	29	assertEquals(
	30	generateAssertMessage("0.33..",
	31	p.getRelativeProgress()), true,
	32	p.getRelativeProgress() <= 0.334);
	33	}
	34	});
	35
	36	addTest(new TestCase("Listeners at first level") {
	37	int pg;
	38
	39	@Override
	40	public void test() throws Exception {
	41	Progress p = new Progress();
	42	p.addProgressListener(new Progress.ProgressListener() {
	43	@Override
	44	public void progress(Progress progress, String name) {
	45	pg = progress.getProgress();
	46	}
	47	});
	48
	49	p.setProgress(42);
	50	assertEquals(42, pg);
	51	p.setProgress(0);
	52	assertEquals(0, pg);
	53	}
	54	});
	55	}
	56	});
	57
	58	addSeries(new TestLauncher("Progress with children", args) {
	59	{
	60	addTest(new TestCase("One child") {
	61	@Override
	62	public void test() throws Exception {
	63	Progress p = new Progress();
	64	Progress child = new Progress();
	65
	66	p.addProgress(child, 100);
	67
	68	child.setProgress(42);
	69	assertEquals(42, p.getProgress());
	70	}
	71	});
	72
	73	addTest(new TestCase("Multiple children") {
	74	@Override
	75	public void test() throws Exception {
	76	Progress p = new Progress();
	77	Progress child1 = new Progress();
	78	Progress child2 = new Progress();
	79	Progress child3 = new Progress();
	80
	81	p.addProgress(child1, 20);
	82	p.addProgress(child2, 60);
	83	p.addProgress(child3, 20);
	84
	85	child1.setProgress(50);
	86	assertEquals(10, p.getProgress());
	87	child2.setProgress(100);
	88	assertEquals(70, p.getProgress());
	89	child3.setProgress(100);
	90	assertEquals(90, p.getProgress());
	91	child1.setProgress(100);
	92	assertEquals(100, p.getProgress());
	93	}
	94	});
	95
	96	addTest(new TestCase("Listeners with children") {
	97	int pg;
	98
	99	@Override
	100	public void test() throws Exception {
	101	final Progress p = new Progress();
	102	Progress child1 = new Progress();
	103	Progress child2 = new Progress();
	104	p.addProgress(child1, 50);
	105	p.addProgress(child2, 50);
	106
	107	p.addProgressListener(new Progress.ProgressListener() {
	108	@Override
	109	public void progress(Progress progress, String name) {
	110	pg = p.getProgress();
	111	}
	112	});
	113
	114	child1.setProgress(50);
	115	assertEquals(25, pg);
	116	child2.setProgress(100);
	117	assertEquals(75, pg);
	118	child1.setProgress(100);
	119	assertEquals(100, pg);
	120	}
	121	});
	122
	123	addTest(new TestCase("Listeners with children, not 1-100") {
	124	int pg;
	125
	126	@Override
	127	public void test() throws Exception {
	128	final Progress p = new Progress();
	129	p.setMax(1000);
	130
	131	Progress child1 = new Progress();
	132	child1.setMax(2);
	133
	134	Progress child2 = new Progress();
	135	p.addProgress(child1, 500);
	136	p.addProgress(child2, 500);
	137
	138	p.addProgressListener(new Progress.ProgressListener() {
	139	@Override
	140	public void progress(Progress progress, String name) {
	141	pg = p.getProgress();
	142	}
	143	});
	144
	145	child1.setProgress(1);
	146	assertEquals(250, pg);
	147	child2.setProgress(100);
	148	assertEquals(750, pg);
	149	child1.setProgress(2);
	150	assertEquals(1000, pg);
	151	}
	152	});
	153
	154	addTest(new TestCase(
	155	"Listeners with children, not 1-100, local progress") {
	156	int pg;
	157
	158	@Override
	159	public void test() throws Exception {
	160	final Progress p = new Progress();
	161	p.setMax(1000);
	162
	163	Progress child1 = new Progress();
	164	child1.setMax(2);
	165
	166	Progress child2 = new Progress();
	167	p.addProgress(child1, 400);
	168	p.addProgress(child2, 400);
	169	// 200 = local progress
	170
	171	p.addProgressListener(new Progress.ProgressListener() {
	172	@Override
	173	public void progress(Progress progress, String name) {
	174	pg = p.getProgress();
	175	}
	176	});
	177
	178	child1.setProgress(1);
	179	assertEquals(200, pg);
	180	child2.setProgress(100);
	181	assertEquals(600, pg);
	182	p.setProgress(100);
	183	assertEquals(700, pg);
	184	child1.setProgress(2);
	185	assertEquals(900, pg);
	186	p.setProgress(200);
	187	assertEquals(1000, pg);
	188	}
	189	});
	190
	191	addTest(new TestCase("Listeners with 5+ children, 4+ depth") {
	192	int pg;
	193
	194	@Override
	195	public void test() throws Exception {
	196	final Progress p = new Progress();
	197	Progress child1 = new Progress();
	198	Progress child2 = new Progress();
	199	p.addProgress(child1, 50);
	200	p.addProgress(child2, 50);
	201	Progress child11 = new Progress();
	202	child1.addProgress(child11, 100);
	203	Progress child111 = new Progress();
	204	child11.addProgress(child111, 100);
	205	Progress child1111 = new Progress();
	206	child111.addProgress(child1111, 20);
	207	Progress child1112 = new Progress();
	208	child111.addProgress(child1112, 20);
	209	Progress child1113 = new Progress();
	210	child111.addProgress(child1113, 20);
	211	Progress child1114 = new Progress();
	212	child111.addProgress(child1114, 20);
	213	Progress child1115 = new Progress();
	214	child111.addProgress(child1115, 20);
	215
	216	p.addProgressListener(new Progress.ProgressListener() {
	217	@Override
	218	public void progress(Progress progress, String name) {
	219	pg = p.getProgress();
	220	}
	221	});
	222
	223	child1111.setProgress(100);
	224	child1112.setProgress(50);
	225	child1113.setProgress(25);
	226	child1114.setProgress(25);
	227	child1115.setProgress(50);
	228	assertEquals(25, pg);
	229	child2.setProgress(100);
	230	assertEquals(75, pg);
	231	child1111.setProgress(100);
	232	child1112.setProgress(100);
	233	child1113.setProgress(100);
	234	child1114.setProgress(100);
	235	child1115.setProgress(100);
	236	assertEquals(100, pg);
	237	}
	238	});
	239
	240	addTest(new TestCase("Listeners with children, multi-thread") {
	241	int pg;
	242	boolean decrease;
	243	Object lock1 = new Object();
	244	Object lock2 = new Object();
	245	int currentStep1;
	246	int currentStep2;
	247
	248	@Override
	249	public void test() throws Exception {
	250	final Progress p = new Progress(0, 200);
	251
	252	final Progress child1 = new Progress();
	253	final Progress child2 = new Progress();
	254	p.addProgress(child1, 100);
	255	p.addProgress(child2, 100);
	256
	257	p.addProgressListener(new Progress.ProgressListener() {
	258	@Override
	259	public void progress(Progress progress, String name) {
	260	int now = p.getProgress();
	261	if (now < pg) {
	262	decrease = true;
	263	}
	264	pg = now;
	265	}
	266	});
	267
	268	// Run 200 concurrent threads, 2 at a time allowed to
	269	// make progress (each on a different child)
	270	for (int i = 0; i <= 100; i++) {
	271	final int step = i;
	272	new Thread(new Runnable() {
	273	@Override
	274	public void run() {
	275	synchronized (lock1) {
	276	if (step > currentStep1) {
	277	currentStep1 = step;
	278	child1.setProgress(step);
	279	}
	280	}
	281	}
	282	}).start();
	283
	284	new Thread(new Runnable() {
	285	@Override
	286	public void run() {
	287	synchronized (lock2) {
	288	if (step > currentStep2) {
	289	currentStep2 = step;
	290	child2.setProgress(step);
	291	}
	292	}
	293	}
	294	}).start();
	295	}
	296
	297	int i;
	298	int timeout = 20; // in 1/10th of seconds
	299	for (i = 0; i < timeout
	300	&& (currentStep1 + currentStep2) < 200; i++) {
	301	Thread.sleep(100);
	302	}
	303
	304	assertEquals("The test froze at step " + currentStep1
	305	+ " + " + currentStep2, true, i < timeout);
	306	assertEquals(
	307	"There should not have any decresing steps",
	308	decrease, false);
	309	assertEquals("The progress should have reached 200",
	310	200, p.getProgress());
	311	assertEquals(
	312	"The progress should have reached completion",
	313	true, p.isDone());
	314	}
	315	});
	316	}
	317	});
	318	}
	319	}