| 
12 | 12 | 
 
  | 
13 | 13 | class TestJavacoreSet(unittest.TestCase):  | 
14 | 14 | 
 
  | 
15 |  | -    def setUp(self):  | 
16 |  | -        self.snapshot = JavacoreSet("")  | 
17 |  | -        self.javacore_set = JavacoreSet('data' + os.path.sep + 'javacores')  | 
 | 15 | +    @classmethod  | 
 | 16 | +    def setUpClass(self):  | 
18 | 17 |         javacores_path = os.getcwd() + os.sep + 'test' + os.sep + 'data' + os.sep + 'javacores'  | 
19 |  | -        self.jset = self.javacore_set.create(javacores_path)  | 
20 |  | -        self.jset.generate_tips()  | 
 | 18 | +        self.javacore_set_from_test_data = JavacoreSet(javacores_path)  | 
 | 19 | +        self.javacore_set_from_test_data = self.javacore_set_from_test_data.create(javacores_path)  | 
 | 20 | +        self.javacore_set_from_test_data.generate_tips()  | 
 | 21 | + | 
 | 22 | +    def setUp(self):  | 
 | 23 | +        self.dummy_javacore_set = JavacoreSet("")  | 
21 | 24 | 
 
  | 
22 | 25 |     def test_parse_mem_arg(self):  | 
23 | 26 |         line = "2CIUSERARG               -Xmx32g"  | 
24 |  | -        mem = self.snapshot.parse_mem_arg(line)  | 
 | 27 | +        mem = self.dummy_javacore_set.parse_mem_arg(line)  | 
25 | 28 |         self.assertEqual(mem, "32g")  | 
26 | 29 |         #  | 
27 | 30 |         line = "2CIUSERARG               -Xmx"  | 
28 |  | -        mem = self.snapshot.parse_mem_arg(line)  | 
 | 31 | +        mem = self.dummy_javacore_set.parse_mem_arg(line)  | 
29 | 32 |         self.assertEqual(mem, UNKNOWN)  | 
30 | 33 | 
 
  | 
31 | 34 |     def test_parse_xmx(self):  | 
32 | 35 |         line = "2CIUSERARG               -Xmx32g"  | 
33 |  | -        self.snapshot.parse_xmx(line)  | 
34 |  | -        self.assertEqual(self.snapshot.xmx, "32g")  | 
 | 36 | +        self.dummy_javacore_set.parse_xmx(line)  | 
 | 37 | +        self.assertEqual(self.dummy_javacore_set.xmx, "32g")  | 
35 | 38 |         #  | 
36 | 39 |         line = "2CIUSERARG               -Xmxg"  | 
37 |  | -        self.snapshot.parse_xmx(line)  | 
38 |  | -        self.assertEqual(self.snapshot.xmx, UNKNOWN)  | 
 | 40 | +        self.dummy_javacore_set.parse_xmx(line)  | 
 | 41 | +        self.assertEqual(self.dummy_javacore_set.xmx, UNKNOWN)  | 
39 | 42 | 
 
  | 
40 | 43 |     def test_parse_xms(self):  | 
41 | 44 |         line = "2CIUSERARG               -Xms32g"  | 
42 |  | -        self.snapshot.parse_xms(line)  | 
43 |  | -        self.assertEqual(self.snapshot.xms, "32g")  | 
 | 45 | +        self.dummy_javacore_set.parse_xms(line)  | 
 | 46 | +        self.assertEqual(self.dummy_javacore_set.xms, "32g")  | 
44 | 47 |         #  | 
45 | 48 |         line = "2CIUSERARG               -Xmsg"  | 
46 |  | -        self.snapshot.parse_xms(line)  | 
47 |  | -        self.assertEqual(self.snapshot.xms, UNKNOWN)  | 
 | 49 | +        self.dummy_javacore_set.parse_xms(line)  | 
 | 50 | +        self.assertEqual(self.dummy_javacore_set.xms, UNKNOWN)  | 
48 | 51 | 
 
  | 
49 | 52 |     def test_parse_xmn(self):  | 
50 | 53 |         line = "2CIUSERARG               -Xmn2g"  | 
51 |  | -        self.snapshot.parse_xmn(line)  | 
52 |  | -        self.assertEqual(self.snapshot.xmn, "2g")  | 
 | 54 | +        self.dummy_javacore_set.parse_xmn(line)  | 
 | 55 | +        self.assertEqual(self.dummy_javacore_set.xmn, "2g")  | 
53 | 56 |         #  | 
54 | 57 |         line = "2CIUSERARG               -Xmng"  | 
55 |  | -        self.snapshot.parse_xmn(line)  | 
56 |  | -        self.assertEqual(self.snapshot.xmn, UNKNOWN)  | 
 | 58 | +        self.dummy_javacore_set.parse_xmn(line)  | 
 | 59 | +        self.assertEqual(self.dummy_javacore_set.xmn, UNKNOWN)  | 
57 | 60 | 
 
  | 
58 | 61 |     def test_parse_gc_policy(self):  | 
59 | 62 |         line = "2CIUSERARG               -Xgcpolicy:gencon"  | 
60 |  | -        self.snapshot.parse_gc_policy(line)  | 
61 |  | -        self.assertEqual(self.snapshot.gc_policy, "gencon")  | 
 | 63 | +        self.dummy_javacore_set.parse_gc_policy(line)  | 
 | 64 | +        self.assertEqual(self.dummy_javacore_set.gc_policy, "gencon")  | 
62 | 65 | 
 
  | 
63 | 66 |     def test_parse_compressed_refs(self):  | 
64 | 67 |         line = "2CIUSERARG               -Xcompressedrefs"  | 
65 |  | -        self.snapshot.parse_compressed_refs(line)  | 
66 |  | -        self.assertTrue(self.snapshot.compressed_refs)  | 
 | 68 | +        self.dummy_javacore_set.parse_compressed_refs(line)  | 
 | 69 | +        self.assertTrue(self.dummy_javacore_set.compressed_refs)  | 
67 | 70 |         #  | 
68 | 71 |         line = "2CIUSERARG               -Xnocompressedrefs"  | 
69 |  | -        self.snapshot.parse_compressed_refs(line)  | 
70 |  | -        self.assertFalse(self.snapshot.compressed_refs)  | 
 | 72 | +        self.dummy_javacore_set.parse_compressed_refs(line)  | 
 | 73 | +        self.assertFalse(self.dummy_javacore_set.compressed_refs)  | 
71 | 74 | 
 
  | 
72 | 75 |     def test_parse_verbose_gc(self):  | 
73 | 76 |         line = ""  | 
74 |  | -        self.snapshot.parse_verbose_gc(line)  | 
75 |  | -        self.assertFalse(self.snapshot.verbose_gc)  | 
 | 77 | +        self.dummy_javacore_set.verbose_gc = False  | 
 | 78 | +        self.dummy_javacore_set.parse_verbose_gc(line)  | 
 | 79 | +        self.assertFalse(self.dummy_javacore_set.verbose_gc)  | 
76 | 80 |         #  | 
77 | 81 |         line = "2CIUSERARG               -verbose:gc"  | 
78 |  | -        self.snapshot.parse_verbose_gc(line)  | 
79 |  | -        self.assertTrue(self.snapshot.verbose_gc)  | 
 | 82 | +        self.dummy_javacore_set.parse_verbose_gc(line)  | 
 | 83 | +        self.assertTrue(self.dummy_javacore_set.verbose_gc)  | 
80 | 84 | 
 
  | 
81 | 85 |     def test_parse_user_args(self):  | 
82 | 86 |         line = "2CIUSERARG               -Xmx32g"  | 
83 |  | -        self.snapshot.parse_user_args(line)  | 
84 |  | -        self.assertEqual(self.snapshot.xmx, "32g")  | 
85 |  | -        self.assertTrue("-Xmx32g" in self.snapshot.user_args)  | 
 | 87 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 88 | +        self.assertEqual(self.dummy_javacore_set.xmx, "32g")  | 
 | 89 | +        self.assertTrue("-Xmx32g" in self.dummy_javacore_set.user_args)  | 
86 | 90 |         #  | 
87 | 91 |         line = "2CIUSERARG               -Xms32g"  | 
88 |  | -        self.snapshot.parse_user_args(line)  | 
89 |  | -        self.assertEqual(self.snapshot.xms, "32g")  | 
 | 92 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 93 | +        self.assertEqual(self.dummy_javacore_set.xms, "32g")  | 
90 | 94 |         #  | 
91 | 95 |         line = "2CIUSERARG               -Xmn2g"  | 
92 |  | -        self.snapshot.parse_user_args(line)  | 
93 |  | -        self.assertEqual(self.snapshot.xmn, "2g")  | 
 | 96 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 97 | +        self.assertEqual(self.dummy_javacore_set.xmn, "2g")  | 
94 | 98 |         #  | 
95 | 99 |         line = "2CIUSERARG               -Xgcpolicy:gencon"  | 
96 |  | -        self.snapshot.parse_user_args(line)  | 
97 |  | -        self.assertEqual(self.snapshot.gc_policy, "gencon")  | 
 | 100 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 101 | +        self.assertEqual(self.dummy_javacore_set.gc_policy, "gencon")  | 
98 | 102 |         #  | 
99 | 103 |         line = "2CIUSERARG               -Xcompressedrefs"  | 
100 |  | -        self.snapshot.parse_user_args(line)  | 
101 |  | -        self.assertTrue(self.snapshot.compressed_refs)  | 
 | 104 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 105 | +        self.assertTrue(self.dummy_javacore_set.compressed_refs)  | 
102 | 106 |         #  | 
103 | 107 |         line = "2CIUSERARG               -Xnocompressedrefs"  | 
104 |  | -        self.snapshot.parse_user_args(line)  | 
105 |  | -        self.assertFalse(self.snapshot.compressed_refs)  | 
 | 108 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 109 | +        self.assertFalse(self.dummy_javacore_set.compressed_refs)  | 
106 | 110 |         #  | 
107 | 111 |         line = ""  | 
108 |  | -        self.snapshot.parse_user_args(line)  | 
109 |  | -        self.assertFalse(self.snapshot.verbose_gc)  | 
 | 112 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 113 | +        self.assertFalse(self.dummy_javacore_set.verbose_gc)  | 
110 | 114 |         #  | 
111 | 115 |         line = "2CIUSERARG               -verbose:gc"  | 
112 |  | -        self.snapshot.parse_user_args(line)  | 
113 |  | -        self.assertTrue(self.snapshot.verbose_gc)  | 
114 |  | -        self.assertTrue("-verbose:gc" in self.snapshot.user_args)  | 
 | 116 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 117 | +        self.assertTrue(self.dummy_javacore_set.verbose_gc)  | 
 | 118 | +        self.assertTrue("-verbose:gc" in self.dummy_javacore_set.user_args)  | 
115 | 119 | 
 
  | 
116 | 120 |         line = "2CIUSERARG               -Ddefault.client.encoding=UTF-8"  | 
117 |  | -        self.snapshot.parse_user_args(line)  | 
118 |  | -        self.assertTrue("-Ddefault.client.encoding=UTF-8" in self.snapshot.user_args)  | 
 | 121 | +        self.dummy_javacore_set.parse_user_args(line)  | 
 | 122 | +        self.assertTrue("-Ddefault.client.encoding=UTF-8" in self.dummy_javacore_set.user_args)  | 
119 | 123 | 
 
  | 
120 | 124 |     def test_sort_snapshots(self):  | 
121 | 125 |         # tested in test_java_thread.py in function test_sort_snapshots  | 
122 | 126 |         pass  | 
123 | 127 | 
 
  | 
124 | 128 |     def test_parse_javacores_contain_valid_file(self):  | 
125 |  | -        self.assertTrue(self.jset.files.index('javacore.20220606.114458.32888.0001.txt') >= 0) #Object is on the list  | 
 | 129 | +        self.assertTrue(self.javacore_set_from_test_data.files.index('javacore.20220606.114458.32888.0001.txt') >= 0) #Object is on the list  | 
126 | 130 | 
 
  | 
127 | 131 |     def test_parse_javacores_not_contain_wrong_file(self):  | 
128 | 132 |         # Check whether javacore.wrong.corr is in the list  | 
129 | 133 |         with self.assertRaises(ValueError):  | 
130 |  | -            self.jset.files.index('javacore.wrong.corr')  | 
 | 134 | +            self.javacore_set_from_test_data.files.index('javacore.wrong.corr')  | 
131 | 135 | 
 
  | 
132 | 136 |     # Note: the test below rely on the javacores stored in test directory  | 
133 | 137 |     def test_have_tips(self):  | 
134 |  | -        self.assertTrue(any("OutOfMemoryError" in tip for tip in self.jset.tips))  | 
135 |  | -        self.assertTrue(any("[WARNING] The time interval between javacore" in tip for tip in self.jset.tips))  | 
 | 138 | +        self.assertTrue(any("OutOfMemoryError" in tip for tip in self.javacore_set_from_test_data.tips))  | 
 | 139 | +        self.assertTrue(any("[WARNING] The time interval between javacore" in tip for tip in  | 
 | 140 | +                            self.javacore_set_from_test_data.tips))  | 
136 | 141 | 
 
  | 
137 | 142 |     # Note: the test below rely on the javacores stored in test directory  | 
138 | 143 |     def test_generate_blocked_snapshots_list(self):  | 
139 |  | -        self.assertEqual(len(self.jset.blocked_snapshots),7, "The javacores from test dir have different number of "  | 
140 |  | -                                                             "blocking threads")  | 
141 |  | -        self.assertEqual(len(self.jset.blocked_snapshots[0].get_threads_set()), 14)  | 
 | 144 | +        self.assertEqual(len(self.javacore_set_from_test_data.blocked_snapshots), 7,  | 
 | 145 | +                         "The javacores from test dir have different number of blocking threads")  | 
 | 146 | +        self.assertEqual(len(self.javacore_set_from_test_data.blocked_snapshots[0].get_threads_set()), 14)  | 
0 commit comments