Mercurial > repos > yufei-luo > s_mart
comparison commons/core/checker/test/Test_CheckerUtils.py @ 31:0ab839023fe4
Uploaded
author | m-zytnicki |
---|---|
date | Tue, 30 Apr 2013 14:33:21 -0400 |
parents | 769e306b7933 |
children |
comparison
equal
deleted
inserted
replaced
30:5677346472b5 | 31:0ab839023fe4 |
---|---|
1 # Copyright INRA (Institut National de la Recherche Agronomique) | |
2 # http://www.inra.fr | |
3 # http://urgi.versailles.inra.fr | |
4 # | |
5 # This software is governed by the CeCILL license under French law and | |
6 # abiding by the rules of distribution of free software. You can use, | |
7 # modify and/ or redistribute the software under the terms of the CeCILL | |
8 # license as circulated by CEA, CNRS and INRIA at the following URL | |
9 # "http://www.cecill.info". | |
10 # | |
11 # As a counterpart to the access to the source code and rights to copy, | |
12 # modify and redistribute granted by the license, users are provided only | |
13 # with a limited warranty and the software's author, the holder of the | |
14 # economic rights, and the successive licensors have only limited | |
15 # liability. | |
16 # | |
17 # In this respect, the user's attention is drawn to the risks associated | |
18 # with loading, using, modifying and/or developing or reproducing the | |
19 # software by the user in light of its specific status of free software, | |
20 # that may mean that it is complicated to manipulate, and that also | |
21 # therefore means that it is reserved for developers and experienced | |
22 # professionals having in-depth computer knowledge. Users are therefore | |
23 # encouraged to load and test the software's suitability as regards their | |
24 # requirements in conditions enabling the security of their systems and/or | |
25 # data to be ensured and, more generally, to use and operate it in the | |
26 # same conditions as regards security. | |
27 # | |
28 # The fact that you are presently reading this means that you have had | |
29 # knowledge of the CeCILL license and that you accept its terms. | |
30 | |
31 | |
32 import unittest | |
33 import os | |
34 import ConfigParser | |
35 from commons.core.checker.CheckerUtils import CheckerUtils | |
36 from commons.core.checker.CheckerException import CheckerException | |
37 from ConfigParser import NoOptionError | |
38 from ConfigParser import NoSectionError | |
39 | |
40 class Test_CheckerUtils( unittest.TestCase ): | |
41 | |
42 def setUp(self): | |
43 self.queueFileName = "queueName.txt" | |
44 self.configFileName = "dummyConfig.cfg" | |
45 | |
46 def tearDown(self): | |
47 if os.path.exists(self.queueFileName): | |
48 os.remove(self.queueFileName) | |
49 if os.path.exists(self.configFileName): | |
50 os.remove(self.configFileName) | |
51 | |
52 def test_isBlastNameInBlastValues( self ): | |
53 correctValueList = [ "blastn", "blastp", "blastx", "tblastn", "tblastx" ] | |
54 for value in correctValueList: | |
55 self.assertFalse( CheckerUtils.isBlastNameNotInBlastValues( value ) ) | |
56 | |
57 incorrectValueList = [ "badbalst", "wublast" ] | |
58 for value in incorrectValueList: | |
59 self.assertTrue( CheckerUtils.isBlastNameNotInBlastValues( value ) ) | |
60 | |
61 def test_isNotTRUEisNotFALSE( self ): | |
62 correctValueList = [ "TRUE", "FALSE" ] | |
63 for value in correctValueList: | |
64 self.assertFalse( CheckerUtils.isNotTRUEisNotFALSE( value ) ) | |
65 | |
66 incorrectValueList = [ "True", "False" ] | |
67 for value in incorrectValueList: | |
68 self.assertTrue( CheckerUtils.isNotTRUEisNotFALSE( value ) ) | |
69 | |
70 def test_isRessourceNotExists( self ): | |
71 fileName = "dummyFile.txt" | |
72 self.assertTrue( CheckerUtils.isRessourceNotExits( fileName ) ) | |
73 os.system( "touch %s" % ( fileName ) ) | |
74 self.assertFalse( CheckerUtils.isRessourceNotExits( fileName ) ) | |
75 os.remove( fileName ) | |
76 | |
77 def test_isNotAeValueWithOneDigit2DecimalsAtLeast( self ): | |
78 correctEValueList = [ "5e-32", "7e-45", "1e-2122", "9e-32" ] | |
79 for value in correctEValueList: | |
80 self.assertFalse( CheckerUtils.isNotAeValueWithOneDigit2DecimalsAtLeast( value ) ) | |
81 | |
82 incorrecEValueStr = [ "10e-32", "2e-3", "2e-2", "1", "cxhhe" ] | |
83 for value in incorrecEValueStr: | |
84 self.assertTrue( CheckerUtils.isNotAeValueWithOneDigit2DecimalsAtLeast( value ) ) | |
85 | |
86 def test_isNotADigit( self ): | |
87 correctDigitList = [ "1", "21", "345" ] | |
88 for value in correctDigitList: | |
89 self.assertFalse( CheckerUtils.isNotANumber( value ) ) | |
90 | |
91 incorrectDigitList = [ "A", "dfdf", "((((" ] | |
92 for value in incorrectDigitList: | |
93 self.assertTrue( CheckerUtils.isNotANumber( value ) ) | |
94 | |
95 def test_isExecutableInUserPath( self ): | |
96 exeName = "ls" | |
97 self.assertTrue( CheckerUtils.isExecutableInUserPath( exeName ) ) | |
98 | |
99 exeName = "hsvegdtefaobfbcheta" | |
100 self.assertFalse( CheckerUtils.isExecutableInUserPath( exeName ) ) | |
101 | |
102 def test_isExecutableInUserPath_case_endsWith( self ): | |
103 exeName = "s" | |
104 self.assertFalse( CheckerUtils.isExecutableInUserPath( exeName ) ) | |
105 | |
106 def test_isQueueNameValid_valid(self): | |
107 cmd = "qconf -sql > " + self.queueFileName | |
108 os.system(cmd) | |
109 f = open(self.queueFileName, "r") | |
110 lQueueNames = f.readlines() | |
111 f.close() | |
112 if lQueueNames == []: | |
113 print "Warning you need SGE installed\n" | |
114 else: | |
115 self.assertTrue(CheckerUtils.isQueueNameValid(lQueueNames[0].strip())) | |
116 | |
117 def test_isQueueNameValid_not_valid(self): | |
118 cmd = "qconf -sql > " + self.queueFileName | |
119 os.system(cmd) | |
120 f = open(self.queueFileName, "r") | |
121 lQueueNames = f.readlines() | |
122 f.close() | |
123 if lQueueNames == []: | |
124 print "Warning you need SGE installed\n" | |
125 else: | |
126 self.assertFalse(CheckerUtils.isQueueNameValid("dummyQueueName")) | |
127 | |
128 def test_isQueueNameValid_valid_with_parameter(self): | |
129 cmd = "qconf -sql > " + self.queueFileName | |
130 os.system(cmd) | |
131 f = open(self.queueFileName, "r") | |
132 lQueueNames = f.readlines() | |
133 f.close() | |
134 if lQueueNames == []: | |
135 print "Warning you need SGE installed\n" | |
136 else: | |
137 queueNameWithParameter = lQueueNames[0].strip() + " test=TRUE" | |
138 self.assertTrue(CheckerUtils.isQueueNameValid(queueNameWithParameter)) | |
139 | |
140 def test_isCharAlphanumOrUnderscore_valid(self): | |
141 project_name = "Project_Name" | |
142 self.assertTrue(CheckerUtils.isCharAlphanumOrUnderscore(project_name)) | |
143 | |
144 def test_isCharAlphanumOrUnderscore_not_valid(self): | |
145 project_name = "Project_Name," | |
146 self.assertFalse(CheckerUtils.isCharAlphanumOrUnderscore(project_name)) | |
147 | |
148 def test_isMax15Char_valid(self): | |
149 project_name = "Project_Name" | |
150 self.assertTrue(CheckerUtils.isMax15Char(project_name)) | |
151 | |
152 def test_isMax15Char_not_valid(self): | |
153 project_name = "Project_Name_tooLong" | |
154 self.assertFalse(CheckerUtils.isMax15Char(project_name)) | |
155 | |
156 def test_checkSectionInConfigFile_empty_section(self): | |
157 sectionName = "sectionName" | |
158 line = "[" + sectionName + "]" | |
159 configFile = open(self.configFileName, "w") | |
160 configFile.write(line) | |
161 configFile.close() | |
162 configFile = open(self.configFileName, "r") | |
163 | |
164 config = ConfigParser.ConfigParser() | |
165 config.readfp(configFile) | |
166 | |
167 isSectionExceptionRaised = False | |
168 try: | |
169 CheckerUtils.checkSectionInConfigFile(config, sectionName) | |
170 except NoSectionError: | |
171 isSectionExceptionRaised = True | |
172 configFile.close() | |
173 self.assertFalse(isSectionExceptionRaised) | |
174 | |
175 def test_checkSectionInConfigFile(self): | |
176 sectionName = "sectionName" | |
177 lines = "[" + sectionName + "]\ndummyOption : dummyOption\n" | |
178 configFile = open(self.configFileName, "w") | |
179 configFile.write(lines) | |
180 configFile.close() | |
181 configFile = open(self.configFileName, "r") | |
182 | |
183 config = ConfigParser.ConfigParser() | |
184 config.readfp(configFile) | |
185 | |
186 isSectionExceptionRaised = False | |
187 try: | |
188 CheckerUtils.checkSectionInConfigFile(config, sectionName) | |
189 except NoSectionError: | |
190 isSectionExceptionRaised = True | |
191 configFile.close() | |
192 self.assertFalse(isSectionExceptionRaised) | |
193 | |
194 def test_checkSectionInConfigFile_not_valid(self): | |
195 sectionName = "sectionName" | |
196 line = " " | |
197 configFile = open(self.configFileName, "w") | |
198 configFile.write(line) | |
199 configFile.close() | |
200 configFile = open(self.configFileName, "r") | |
201 | |
202 config = ConfigParser.ConfigParser() | |
203 config.readfp(configFile) | |
204 | |
205 isSectionExceptionRaised = False | |
206 try: | |
207 CheckerUtils.checkSectionInConfigFile(config, sectionName) | |
208 except NoSectionError: | |
209 isSectionExceptionRaised = True | |
210 configFile.close() | |
211 self.assertTrue(isSectionExceptionRaised) | |
212 | |
213 def test_checkOptionInSectionInConfigFile(self): | |
214 optionName = "optionName" | |
215 sectionName = "sectionName" | |
216 configFile = open(self.configFileName, "w") | |
217 configFile.write("[" + sectionName + "]\n") | |
218 configFile.write(optionName + ": ") | |
219 configFile.close() | |
220 configFile = open(self.configFileName, "r") | |
221 | |
222 config = ConfigParser.ConfigParser() | |
223 config.readfp(configFile) | |
224 | |
225 isSectionExceptionRaised = False | |
226 try: | |
227 CheckerUtils.checkOptionInSectionInConfigFile(config, sectionName, optionName) | |
228 except NoOptionError: | |
229 isSectionExceptionRaised = True | |
230 configFile.close() | |
231 self.assertFalse(isSectionExceptionRaised) | |
232 | |
233 def test_checkOptionInSectionInConfigFile_not_present(self): | |
234 optionName = " " | |
235 sectionName = "sectionName" | |
236 configFile = open(self.configFileName, "w") | |
237 configFile.write("[" + sectionName + "]\n") | |
238 configFile.write(optionName) | |
239 configFile.close() | |
240 configFile = open(self.configFileName, "r") | |
241 | |
242 config = ConfigParser.ConfigParser() | |
243 config.readfp(configFile) | |
244 | |
245 isSectionExceptionRaised = False | |
246 try: | |
247 CheckerUtils.checkOptionInSectionInConfigFile(config, sectionName, optionName) | |
248 except NoOptionError: | |
249 isSectionExceptionRaised = True | |
250 configFile.close() | |
251 self.assertTrue(isSectionExceptionRaised) | |
252 | |
253 def test_checkOptionInSectionInConfigFile_not_in_the_right_section(self): | |
254 optionName = "optionName" | |
255 rightSection = "dummySection2" | |
256 configFile = open(self.configFileName, "w") | |
257 configFile.write("[dummySection1]\n") | |
258 configFile.write(optionName + ": \n") | |
259 configFile.write("[" + rightSection + "]") | |
260 configFile.close() | |
261 configFile = open(self.configFileName, "r") | |
262 | |
263 config = ConfigParser.ConfigParser() | |
264 config.readfp(configFile) | |
265 | |
266 isSectionExceptionRaised = False | |
267 try: | |
268 CheckerUtils.checkOptionInSectionInConfigFile(config, rightSection, optionName) | |
269 except NoOptionError: | |
270 isSectionExceptionRaised = True | |
271 configFile.close() | |
272 self.assertTrue(isSectionExceptionRaised) | |
273 | |
274 def test_checkConfigVersion_different_version_between_changeLog_and_configFile(self): | |
275 changeLogFileName = "dummyCHANGELOG" | |
276 | |
277 self._writeChangeLogFile(changeLogFileName) | |
278 self._writeConfigFile("repet_version: 1.3.5\n") | |
279 | |
280 changeLogFileHandler = open(changeLogFileName, "r") | |
281 configFileHandler = open(self.configFileName, "r") | |
282 config = ConfigParser.ConfigParser() | |
283 config.readfp(configFileHandler) | |
284 | |
285 self.assertRaises(CheckerException, CheckerUtils.checkConfigVersion, changeLogFileHandler, config) | |
286 | |
287 changeLogFileHandler.close() | |
288 configFileHandler.close() | |
289 os.remove(changeLogFileName) | |
290 | |
291 def test_checkConfigVersion_same_version_between_changeLog_and_configFile(self): | |
292 changeLogFileName = "dummyCHANGELOG" | |
293 self._writeChangeLogFile(changeLogFileName) | |
294 self._writeConfigFile("repet_version: 1.3.6\n") | |
295 | |
296 changeLogFileHandler = open(changeLogFileName, "r") | |
297 configFileHandler = open(self.configFileName, "r") | |
298 config = ConfigParser.ConfigParser() | |
299 config.readfp(configFileHandler) | |
300 | |
301 isCheckerExceptionRaised = False | |
302 try: | |
303 CheckerUtils.checkConfigVersion(changeLogFileHandler, config) | |
304 except CheckerException: | |
305 isCheckerExceptionRaised = True | |
306 self.assertFalse(isCheckerExceptionRaised) | |
307 | |
308 changeLogFileHandler.close() | |
309 configFileHandler.close() | |
310 os.remove(changeLogFileName) | |
311 | |
312 def test_getVersionFromChangelogFile(self): | |
313 changeLogFileName = "dummyCHANGELOG" | |
314 self._writeChangeLogFile(changeLogFileName) | |
315 obsVer = CheckerUtils.getVersionFromChangelogFile(changeLogFileName) | |
316 expVer = "1.3.6" | |
317 | |
318 self.assertEquals(obsVer, expVer) | |
319 | |
320 os.remove(changeLogFileName) | |
321 | |
322 def test_checkConfigVersion_check_exception_message(self): | |
323 changeLogFileName = "dummyCHANGELOG" | |
324 self._writeChangeLogFile(changeLogFileName) | |
325 self._writeConfigFile("repet_version: 1.3.5\n") | |
326 | |
327 changeLogFileHandler = open(changeLogFileName, "r") | |
328 configFileHandler = open(self.configFileName, "r") | |
329 config = ConfigParser.ConfigParser() | |
330 config.readfp(configFileHandler) | |
331 | |
332 checkerExceptionInstance = None | |
333 try: | |
334 CheckerUtils.checkConfigVersion(changeLogFileHandler, config) | |
335 except CheckerException, e: | |
336 checkerExceptionInstance = e | |
337 | |
338 expMessage = "*** Error: wrong config file version. Expected version num is 1.3.6 but actual in config file is 1.3.5" | |
339 obsMessage = checkerExceptionInstance.msg | |
340 | |
341 self.assertEquals(expMessage, obsMessage) | |
342 | |
343 def test_checkHeaders_first_header_with_question_mark(self): | |
344 fastaFileName = "dummyFasta.fa" | |
345 self._writeFastaFile_first_header_with_question_mark(fastaFileName) | |
346 fastaFileHandler = open(fastaFileName,"r") | |
347 isExceptionRaised = False | |
348 try: | |
349 CheckerUtils.checkHeaders(fastaFileHandler) | |
350 except CheckerException, e: | |
351 isExceptionRaised = True | |
352 | |
353 fastaFileHandler.close() | |
354 os.remove(fastaFileName) | |
355 | |
356 self.assertTrue(isExceptionRaised) | |
357 | |
358 expMessages = ["DmelChr4_Bla?ster_Piler_0.0_Map_3"] | |
359 obsMessages = e.getMessages() | |
360 | |
361 self.assertEquals(expMessages, obsMessages) | |
362 | |
363 def test_checkHeaders_with_2_wrong_headers(self): | |
364 fastaFileName = "dummyFasta.fa" | |
365 self._writeFastaFile_with_2_wrong_headers(fastaFileName) | |
366 fastaFileHandler = open(fastaFileName,"r") | |
367 isExceptionRaised = False | |
368 try: | |
369 CheckerUtils.checkHeaders(fastaFileHandler) | |
370 except CheckerException, e: | |
371 isExceptionRaised = True | |
372 | |
373 fastaFileHandler.close() | |
374 os.remove(fastaFileName) | |
375 | |
376 self.assertTrue(isExceptionRaised) | |
377 | |
378 expMessages = ["DmelChr4_Bla?ster_Piler_0.0_Map_3","DmelChr4_Bla!ster_Piler_1.0_Map_9"] | |
379 obsMessages = e.getMessages() | |
380 | |
381 self.assertEquals(expMessages, obsMessages) | |
382 | |
383 def test_checkHeaders_with_pipe(self): | |
384 fastaFileName = "dummyFasta.fa" | |
385 self._writeFastaFile_with_pipe(fastaFileName) | |
386 fastaFileHandler = open(fastaFileName,"r") | |
387 isExceptionRaised = False | |
388 try: | |
389 CheckerUtils.checkHeaders(fastaFileHandler) | |
390 except CheckerException, e: | |
391 isExceptionRaised = True | |
392 | |
393 fastaFileHandler.close() | |
394 os.remove(fastaFileName) | |
395 | |
396 self.assertTrue(isExceptionRaised) | |
397 | |
398 expMessages = ["DmelC|hr4_Blas-ter_Piler_1.0_Map_9"] | |
399 obsMessages = e.getMessages() | |
400 | |
401 self.assertEquals(expMessages, obsMessages) | |
402 | |
403 def test_checkHeaders_with_equal(self): | |
404 fastaFileName = "dummyFasta.fa" | |
405 self._writeFastaFile_with_equal(fastaFileName) | |
406 fastaFileHandler = open(fastaFileName,"r") | |
407 isExceptionRaised = False | |
408 try: | |
409 CheckerUtils.checkHeaders(fastaFileHandler) | |
410 except CheckerException, e: | |
411 isExceptionRaised = True | |
412 | |
413 fastaFileHandler.close() | |
414 os.remove(fastaFileName) | |
415 | |
416 self.assertTrue(isExceptionRaised) | |
417 | |
418 expMessages = ["DmelC:hr4_Blas=ter_Piler_1.0_Map_9"] | |
419 obsMessages = e.getMessages() | |
420 | |
421 self.assertEquals(expMessages, obsMessages) | |
422 | |
423 def test_checkHeaders_all_headers_ok(self): | |
424 fastaFileName = "dummyFasta.fa" | |
425 self._writeFastaFile_all_headers_ok(fastaFileName) | |
426 fastaFileHandler = open(fastaFileName,"r") | |
427 isExceptionRaised = False | |
428 try: | |
429 CheckerUtils.checkHeaders(fastaFileHandler) | |
430 except CheckerException: | |
431 isExceptionRaised = True | |
432 | |
433 fastaFileHandler.close() | |
434 os.remove(fastaFileName) | |
435 | |
436 self.assertFalse(isExceptionRaised) | |
437 | |
438 def _writeFastaFile_first_header_with_question_mark(self, fastaFileName): | |
439 fastaFileHandler = open(fastaFileName, "w") | |
440 fastaFileHandler.write(">DmelChr4_Bla?ster_Piler_0.0_Map_3\n") | |
441 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n") | |
442 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n") | |
443 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n") | |
444 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n") | |
445 fastaFileHandler.write(">DmelChr4_Blaster_Piler_1.0_Map_9\n") | |
446 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n") | |
447 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n") | |
448 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n") | |
449 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n") | |
450 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n") | |
451 fastaFileHandler.close() | |
452 | |
453 def _writeFastaFile_with_2_wrong_headers(self, fastaFileName): | |
454 fastaFileHandler = open(fastaFileName, "w") | |
455 fastaFileHandler.write(">DmelChr4_Bla?ster_Piler_0.0_Map_3\n") | |
456 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n") | |
457 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n") | |
458 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n") | |
459 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n") | |
460 fastaFileHandler.write(">DmelChr4_Bla!ster_Piler_1.0_Map_9\n") | |
461 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n") | |
462 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n") | |
463 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n") | |
464 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n") | |
465 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n") | |
466 fastaFileHandler.close() | |
467 | |
468 def _writeFastaFile_all_headers_ok(self, fastaFileName): | |
469 fastaFileHandler = open(fastaFileName, "w") | |
470 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n") | |
471 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n") | |
472 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n") | |
473 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n") | |
474 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n") | |
475 fastaFileHandler.write(">DmelC:hr4_Blas-ter_Piler_1.0_Map_9\n") | |
476 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n") | |
477 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n") | |
478 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n") | |
479 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n") | |
480 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n") | |
481 fastaFileHandler.close() | |
482 | |
483 def _writeFastaFile_with_pipe(self, fastaFileName): | |
484 fastaFileHandler = open(fastaFileName, "w") | |
485 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n") | |
486 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n") | |
487 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n") | |
488 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n") | |
489 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n") | |
490 fastaFileHandler.write(">DmelC|hr4_Blas-ter_Piler_1.0_Map_9\n") | |
491 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n") | |
492 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n") | |
493 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n") | |
494 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n") | |
495 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n") | |
496 fastaFileHandler.close() | |
497 | |
498 def _writeFastaFile_with_equal(self, fastaFileName): | |
499 fastaFileHandler = open(fastaFileName, "w") | |
500 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n") | |
501 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n") | |
502 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n") | |
503 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n") | |
504 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n") | |
505 fastaFileHandler.write(">DmelC:hr4_Blas=ter_Piler_1.0_Map_9\n") | |
506 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n") | |
507 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n") | |
508 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n") | |
509 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n") | |
510 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n") | |
511 fastaFileHandler.close() | |
512 | |
513 def _writeChangeLogFile(self, changeLogFileName ): | |
514 changeLogFileHandler = open(changeLogFileName, "w") | |
515 changeLogFileHandler.write("ChangeLog of REPET\n") | |
516 changeLogFileHandler.write("\n") | |
517 changeLogFileHandler.write("\n") | |
518 changeLogFileHandler.write("\n") | |
519 changeLogFileHandler.write("REPET release 1.3.6\n") | |
520 changeLogFileHandler.write("(release date XX/XX/2010)\n") | |
521 changeLogFileHandler.write("\n") | |
522 changeLogFileHandler.close() | |
523 | |
524 def _writeConfigFile(self, lineVersion): | |
525 configFileHandler = open(self.configFileName, "w") | |
526 configFileHandler.write("[repet_env]\n") | |
527 configFileHandler.write(lineVersion) | |
528 configFileHandler.write("repet_host: <your_MySQL_host>\n") | |
529 configFileHandler.close() | |
530 | |
531 | |
532 test_suite = unittest.TestSuite() | |
533 test_suite.addTest( unittest.makeSuite( Test_CheckerUtils ) ) | |
534 if __name__ == "__main__": | |
535 unittest.TextTestRunner(verbosity=2).run( test_suite ) |