Unchecked warnings fixed.

Kai Reinhard

29.34.2018 f4fb8b03d89942c777e25c8a0b38d4aa1e5e61eb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package de.micromata.borgbutler.jobs;
 
import org.apache.commons.io.FileUtils;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.List;
 
import static org.junit.jupiter.api.Assertions.*;
 
public class JobQueueTest {
    private Logger log = LoggerFactory.getLogger(JobQueueTest.class);
    // Bash script with simple counter and forced error if second argument is a valid counter.
    private static String bashScript = "#!/bin/bash\n" +
            "COUNTER=0\n" +
            "while [ $COUNTER -lt $1 ]; do\n" +
            "  if [ $COUNTER -eq $2 ]; then\n" +
            "    echo Error on counter $COUNTER >&2\n" +
            "    exit 2\n" +
            "  fi\n" +
            "  sleep 0.1\n" +
            "  echo The counter is $COUNTER >&2\n" +
            "  let COUNTER=COUNTER+1 \n" +
            "done\n" +
            "echo $COUNTER\n";
 
    private static File file;
 
    @BeforeAll
    static void createScript() throws IOException {
        file = File.createTempFile("counter", ".sh");
        file.deleteOnExit();
        FileUtils.write(file, bashScript, Charset.forName("UTF-8"));
        Files.setPosixFilePermissions(file.toPath(), PosixFilePermissions.fromString("rwxr-xr-x"));
    }
 
    @Test
    void queueTest() {
        JobQueue<String> queue = new JobQueue<>();
        assertEquals(0, queue.getQueueSize());
        queue.append(new TestJob(10, file));
        assertEquals(1, queue.getQueueSize());
        queue.append(new TestJob(5, 2, file));
        assertEquals(2, queue.getQueueSize());
        queue.append(new TestJob(10, file));
        assertEquals(2, queue.getQueueSize());
        TestJob job1 = (TestJob) queue.getQueuedJob(10);
        int counter = 100;
        while (job1.getStatus() != AbstractJob.Status.RUNNING && counter-- > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                log.error(ex.getMessage(), ex);
            }
        }
        assertEquals(AbstractJob.Status.RUNNING, job1.getStatus());
 
        TestJob job = (TestJob) queue.getQueuedJob(5);
        assertEquals(AbstractJob.Status.QUEUED, job.getStatus());
        String result = job1.getResultObject();
        assertEquals("10\n", result);
        assertEquals(AbstractJob.Status.DONE, job1.getStatus());
 
        queue.append(new TestJob(10, file));
        queue.append(new TestJob(100, file));
        job1 = (TestJob) queue.getQueuedJob(10);
        assertEquals(AbstractJob.Status.QUEUED, job1.getStatus());
 
        job = (TestJob) queue.getQueuedJob(100);
        job.cancel();
        assertEquals(AbstractJob.Status.CANCELLED, job.getStatus());
 
        result = job1.getResultObject();
        assertEquals("10\n", result);
 
        assertEquals(0, queue.getQueueSize());
        List<AbstractJob<String>> doneJobs = queue.getDoneJobs();
        assertEquals(4, doneJobs.size());
        check(((TestJob) doneJobs.get(0)), AbstractJob.Status.DONE, "10");
        check(((TestJob) doneJobs.get(1)), AbstractJob.Status.CANCELLED, null);
        check(((TestJob) doneJobs.get(2)), AbstractJob.Status.FAILED, null);
        check(((TestJob) doneJobs.get(3)), AbstractJob.Status.DONE, "10");
    }
 
    @Test
    void queueStopRunningProcessTest() {
        JobQueue<String> queue = new JobQueue<>();
        assertEquals(0, queue.getQueueSize());
        queue.append(new TestJob(1000, file));
        queue.append(new TestJob(10, file));
        TestJob job = (TestJob) queue.getQueuedJob(1000);
        int counter = 100;
        while (!job.isExecuteStarted() && counter-- > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                log.error(ex.getMessage(), ex);
            }
        }
        assertTrue(counter > 0);
        assertEquals(AbstractJob.Status.RUNNING, job.getStatus());
        job.cancel();
        counter = 100;
        while (job.getStatus() == AbstractJob.Status.RUNNING && counter-- > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException ex) {
                log.error(ex.getMessage(), ex);
            }
        }
        assertTrue(counter > 0);
        assertEquals(AbstractJob.Status.CANCELLED, job.getStatus());
        job = (TestJob)queue.getQueuedJob(10);
        assertEquals("10\n", job.getResultObject());
        List<AbstractJob<String>> doneJobs = queue.getDoneJobs();
        assertEquals(2, doneJobs.size());
        check(((TestJob) doneJobs.get(0)), AbstractJob.Status.DONE, null);
        check(((TestJob) doneJobs.get(1)), AbstractJob.Status.CANCELLED, null);
    }
 
    private void check(TestJob job, AbstractJob.Status status, String result) {
        assertEquals(status, job.getStatus());
        if (result != null) {
            assertEquals(result + "\n", job.getResultObject());
        }
    }
}