1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 package ifc.ucb;
25 
26 import lib.MultiMethodTest;
27 import lib.Status;
28 import lib.StatusException;
29 
30 import com.sun.star.lang.XMultiServiceFactory;
31 import com.sun.star.task.XInteractionHandler;
32 import com.sun.star.ucb.XSimpleFileAccess;
33 import com.sun.star.uno.UnoRuntime;
34 import com.sun.star.util.DateTime;
35 
36 /**
37 * Testing <code>com.sun.star.ucb.XSimpleFileAccess</code>
38 * interface methods. <p>
39 * The following predefined files needed to complete the test:
40 * <ul>
41 *  <li> <code>XSimpleFileAccess/XSimpleFileAccess.txt</code> :
42 *   text file of length 17 and 2000 year created .</li>
43 *  <li> <code>XSimpleFileAccess/XSimpleFileAccess2.txt</code> :
44 *   text file for <code>openFileReadWrite</code> method test.</li>
45 * <ul> <p>
46 * This test needs the following object relations :
47 * <ul>
48 *  <li> <code>'InteractionHandler'</code>
49 *  (of type <code>XInteractionHandler</code>)
50 *  instance of <code>com.sun.star.sdb.InteractionHandler</code>
51 *  </li>
52 * </ul> <p>
53 * Test is <b> NOT </b> multithread compilant. <p>
54 * @see com.sun.star.ucb.XSimpleFileAccess
55 */
56 public class _XSimpleFileAccess extends MultiMethodTest {
57 
58     public static XSimpleFileAccess oObj = null;
59 
60     /**
61     * Copies <b>XSimpleFileAccess.txt</b> to a new file, checks
62     * if it was successfully copied and then deletes it. <p>
63     * Has <b> OK </b> status if after method call new copy of file
64     * exists and no exceptions were thrown. <p>
65     */
_copy()66     public void _copy() {
67         try {
68             String copiedFile = "";
69             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
70             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
71             String filename = dirname+"XSimpleFileAccess.txt";
72             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
73 
74             if (oObj.exists(copiedFile))
75                 oObj.kill(copiedFile);
76 
77             oObj.copy(filename,copiedFile);
78             tRes.tested("copy()",oObj.exists(copiedFile));
79             oObj.kill(copiedFile);
80         }
81         catch (com.sun.star.uno.Exception ex) {
82             log.println("Exception occurred while testing 'copy()'");
83             ex.printStackTrace(log);
84             tRes.tested("copy()",false);
85         }
86 
87     } //EOF copy()
88 
89     /**
90     * Copies <b>XSimpleFileAccess.txt</b> to a new file, tries to
91     * rename it, then checks
92     * if it was successfully renamed and then deletes it. <p>
93     * Has <b> OK </b> status if after method call new file
94     * exists and no exceptions were thrown. <p>
95     */
_move()96     public void _move() {
97         try {
98             String copiedFile = "";
99             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
100             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
101             String filename = dirname+"XSimpleFileAccess.txt";
102             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
103 
104             if (oObj.exists(copiedFile))
105                 oObj.kill(copiedFile);
106 
107             oObj.copy(filename,copiedFile);
108             filename = copiedFile;
109             copiedFile = dirnameTo + "XSimpleFileAccess_move.txt";
110             oObj.move(filename,copiedFile);
111             tRes.tested("move()",oObj.exists(copiedFile));
112             oObj.kill(copiedFile);
113         }
114         catch (com.sun.star.uno.Exception ex) {
115             log.println("Exception occurred while testing 'move()'");
116             ex.printStackTrace(log);
117             tRes.tested("move()",false);
118         }
119 
120     } //EOF move()
121 
122     /**
123     * Copies <b>XSimpleFileAccess.txt</b> to a new file, deletes it
124     * and checks if it isn't exist. <p>
125     * Has <b> OK </b> status if after method call new copy of file
126     * doesn't exist and no exceptions were thrown. <p>
127     */
_kill()128     public void _kill() {
129         try {
130             String copiedFile = "";
131             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
132             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
133             String filename = dirname+"XSimpleFileAccess.txt";
134             copiedFile = dirnameTo + "XSimpleFileAccess_copy.txt";
135 
136             if (oObj.exists(copiedFile))
137                 oObj.kill(copiedFile);
138 
139             oObj.copy(filename,copiedFile);
140             oObj.kill(copiedFile);
141             tRes.tested("kill()",!oObj.exists(copiedFile));
142         }
143         catch (com.sun.star.uno.Exception ex) {
144             log.println("Exception occurred while testing 'kill()'");
145             ex.printStackTrace(log);
146             tRes.tested("kill()",false);
147         }
148 
149     } //EOF kill()
150 
151     /**
152     * Tries to check if <b>XSimpleFileAccess</b> is folder. <p>
153     * Has <b>OK</b> status if the method returns <code>true</code>
154     */
_isFolder()155     public void _isFolder() {
156         try {
157             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
158             tRes.tested("isFolder()",oObj.isFolder(dirname));
159         }
160         catch (com.sun.star.uno.Exception ex) {
161             log.println("Exception occurred while testing 'isFolder()'");
162             ex.printStackTrace(log);
163             tRes.tested("isFolder()",false);
164         }
165 
166     } //EOF isFolder()
167 
168     /**
169      * Copies <b>XSimpleFileAccess.txt</b> to a new file, sets
170      * 'READONLY' attribute and checks it. Second clears 'READONLY'
171      * attribute and checks it again. The copy of file is deleted
172      * finally.<p>
173      *
174      * Has <b> OK </b> status if in the first case method returns
175      * <code></code>, and in the second case - <code>false</code>
176      * and no exceptions were thrown. <p>
177      *
178      * The following method tests are to be completed successfully before :
179      * <ul>
180      *  <li> <code> setReadOnly </code> </li>
181      * </ul>
182      */
_isReadOnly()183     public void _isReadOnly() {
184         requiredMethod("setReadOnly()");
185         try {
186             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
187             String filename = dirname+"XSimpleFileAccess.txt";
188             boolean result = true;
189 
190             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
191             String readonlyCopy = dirnameTo + "XSimpleFileAccess_copy.txt" ;
192 
193             if (oObj.exists(readonlyCopy))
194                 oObj.kill(readonlyCopy);
195 
196             oObj.copy(filename, readonlyCopy);
197 
198             oObj.setReadOnly(readonlyCopy, true);
199             result &= oObj.isReadOnly(readonlyCopy);
200             oObj.setReadOnly(readonlyCopy, false);
201             result &= !oObj.isReadOnly(readonlyCopy);
202 
203             oObj.kill(readonlyCopy);
204             tRes.tested("isReadOnly()",result);
205         } catch (com.sun.star.uno.Exception ex) {
206             log.println("Exception occurred while testing 'isReadOnly()'");
207             ex.printStackTrace(log);
208             tRes.tested("isReadOnly()",false);
209         }
210 
211     } //EOF isReadOnly()
212 
213 
214     /**
215      * Copies <b>XSimpleFileAccess.txt</b> to a new file, sets
216      * 'READONLY' attribute and checks it. Second clears 'READONLY'
217      * attribute and checks it again. The copy of file is deleted
218      * finally.<p>
219      *
220      * Has <b> OK </b> status if in the first case method returns
221      * <code></code>, and in the second case - <code>false</code>
222      * and no exceptions were thrown. <p>
223      *
224      * The following method tests are to be completed successfully before :
225      * <ul>
226      *  <li> <code> setReadOnly </code> </li>
227      * </ul>
228      */
_setReadOnly()229     public void _setReadOnly() {
230         boolean result = true ;
231 
232         try {
233             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
234             String filename = dirname+"XSimpleFileAccess.txt";
235 
236             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
237             String readonlyCopy = dirnameTo + "XSimpleFileAccess_copy.txt" ;
238 
239             if (oObj.exists(readonlyCopy))
240                 oObj.kill(readonlyCopy);
241 
242             oObj.copy(filename, readonlyCopy);
243 
244             oObj.setReadOnly(readonlyCopy, true);
245             result &= oObj.isReadOnly(readonlyCopy) ;
246             oObj.setReadOnly(readonlyCopy, false);
247             result &= !oObj.isReadOnly(readonlyCopy) ;
248             tRes.tested("setReadOnly()", result);
249 
250             oObj.kill(readonlyCopy);
251         }
252         catch (Exception ex) {
253             log.println("Exception occurred while testing 'setReadOnly()'");
254             ex.printStackTrace(log);
255             tRes.tested("setReadOnly()",false);
256         }
257     } //EOF setReadOnly()
258 
259     /**
260      * Creates folder and then checks if it was successfully created. <p>
261      * Has <b>OK</b> status if folder was created and no exceptions
262      * were thrown.
263      */
_createFolder()264     public void _createFolder() {
265         try {
266             String tmpdirname = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
267             String newFolder = tmpdirname+"SimpleSubFolder";
268 
269             if (oObj.exists(newFolder))
270                 oObj.kill(newFolder);
271 
272             oObj.createFolder(newFolder);
273             tRes.tested("createFolder()",oObj.isFolder(newFolder));
274             oObj.kill(newFolder);
275         }
276         catch (com.sun.star.uno.Exception ex) {
277             log.println("Exception occurred while testing 'createFolder()'");
278             ex.printStackTrace(log);
279             tRes.tested("createFolder()",false);
280         }
281 
282     } //EOF createFolder()
283 
284     /**
285     * Test calls the method and checks return value and that
286     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
287     * file tested.<p>
288     * Has <b> OK </b> status if the method returns <code>17</code>
289     * and no exceptions were thrown. <p>
290     */
_getSize()291     public void _getSize() {
292         try {
293             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
294             String filename = dirname+"XSimpleFileAccess.txt";
295             int fSize = oObj.getSize(filename);
296             tRes.tested("getSize()", fSize == 17 );
297         }
298         catch (com.sun.star.uno.Exception ex) {
299             log.println("Exception occurred while testing 'getSize()'");
300             ex.printStackTrace(log);
301             tRes.tested("getSize()",false);
302         }
303 
304     } //EOF getSize()
305 
306     /**
307     * Test calls the method and checks return value and that
308     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
309     * file tested.<p>
310     * Has <b> OK </b> status if the method returns String
311     * <code>'application/vnd.sun.staroffice.fsys-file'</code>
312     * and no exceptions were thrown. <p>
313     */
_getContentType()314     public void _getContentType() {
315         try {
316             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
317             String filename = dirname+"XSimpleFileAccess.txt";
318             String fType = oObj.getContentType(filename);
319             tRes.tested("getContentType()",
320                 "application/vnd.sun.staroffice.fsys-file".equals(fType) );
321         }
322         catch (com.sun.star.uno.Exception ex) {
323             log.println("Exception occurred while testing 'getContentType()'");
324             ex.printStackTrace(log);
325             tRes.tested("getContentType()",false);
326         }
327 
328     } //EOF getContentType()
329 
330     /**
331     * Test calls the method and checks return value and that
332     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
333     * file tested.<p>
334     * Has <b> OK </b> status if the method returns date with
335     * 2001 year and no exceptions were thrown. <p>
336     */
_getDateTimeModified()337     public void _getDateTimeModified() {
338         try {
339             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
340             String filename = dirname+"XSimpleFileAccess.txt";
341             DateTime fTime = oObj.getDateTimeModified(filename);
342 
343             java.io.File the_file = new java.io.File(filename);
344             long lastModified = the_file.lastModified();
345             java.util.Date lastMod = new java.util.Date(lastModified);
346 
347             //compare the dates gained by java with those gained by this method
348             boolean res = true;
349             boolean partResult = (fTime.Day == lastMod.getDay());
350             if (!partResult) {
351                 log.println("Wrong Day");
352                 log.println("Expected: "+lastMod.getDay());
353                 log.println("Gained: "+fTime.Day);
354                 log.println("------------------------------");
355             }
356             partResult = (fTime.Month == lastMod.getMonth());
357             if (!partResult) {
358                 log.println("Wrong Month");
359                 log.println("Expected: "+lastMod.getMonth());
360                 log.println("Gained: "+fTime.Month);
361                 log.println("------------------------------");
362             }
363 
364             partResult = (fTime.Year == lastMod.getYear());
365             if (!partResult) {
366                 log.println("Wrong Year");
367                 log.println("Expected: "+lastMod.getYear());
368                 log.println("Gained: "+fTime.Year);
369                 log.println("------------------------------");
370             }
371 
372             tRes.tested("getDateTimeModified()", res);
373         }
374         catch (com.sun.star.uno.Exception ex) {
375             log.println("Exception occurred while testing 'getDateTimeModified()'");
376             ex.printStackTrace(log);
377             tRes.tested("getDateTimeModified()",false);
378         }
379 
380     } //EOF getDateTimeModified()
381 
382     /**
383     * Test calls the method and checks return value and that
384     * no exceptions were thrown. <b>XSimpleFileAccess</b>
385     * directory used.<p>
386     * Has <b> OK </b> status if the method returns non zero length
387     * array and no exceptions were thrown. <p>
388     */
_getFolderContents()389     public void _getFolderContents() {
390         try {
391             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
392             String[] cont = oObj.getFolderContents(dirname,false);
393             tRes.tested("getFolderContents()", cont.length>0);
394         }
395         catch (com.sun.star.uno.Exception ex) {
396             log.println("Exception occurred while testing 'getFolderContents()'");
397             ex.printStackTrace(log);
398             tRes.tested("getFolderContents()",false);
399         }
400 
401     } //EOF getFolderContents()
402 
403     /**
404     * First it check file <b>XSimpleFileAccess.txt</b> for
405     * existence, second file <b>I_do_not_exists.txt</b> is checked
406     * for existence. <p>
407     * Has <b> OK </b> status if in the first case method returns
408     * <code>true</code> and in the second - <code>flase</code>
409     * and no exceptions were thrown. <p>
410     */
_exists()411     public void _exists() {
412         try {
413             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
414             String filename = dirname+"XSimpleFileAccess.txt";
415             String wrongname = dirname+"I_do_not_exists.txt";
416             tRes.tested("exists()",
417                 oObj.exists(filename) && !oObj.exists(wrongname));
418         }
419         catch (com.sun.star.uno.Exception ex) {
420             log.println("Exception occurred while testing 'exists()'");
421             ex.printStackTrace(log);
422             tRes.tested("exists()",false);
423         }
424 
425     } //EOF exists()
426 
427     /**
428     * Test calls the method and checks return value and that
429     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
430     * file used.<p>
431     * Has <b> OK </b> status if the method returns not
432     * <code>null</code> value and no exceptions were thrown. <p>
433     */
_openFileRead()434     public void _openFileRead() {
435         try {
436             String dirname = util.utils.getFullTestURL("XSimpleFileAccess");
437             String filename = dirname+"XSimpleFileAccess.txt";
438             com.sun.star.io.XInputStream iStream = oObj.openFileRead(filename);
439             tRes.tested("openFileRead()", iStream != null);
440         }
441         catch (com.sun.star.uno.Exception ex) {
442             log.println("Exception occurred while testing 'openFileRead()'");
443             ex.printStackTrace(log);
444             tRes.tested("openFileRead()",false);
445         }
446 
447     } //EOF openFileRead()
448 
449     /**
450     * Test calls the method and checks return value and that
451     * no exceptions were thrown. <b>XSimpleFileAccess.txt</b>
452     * file used.<p>
453     * Has <b> OK </b> status if the method returns not
454     * <code>null</code> value and no exceptions were thrown. <p>
455     */
_openFileWrite()456     public void _openFileWrite() {
457         try {
458             String tmpdirname = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
459 
460             String copiedFile = tmpdirname+"XSimpleFileAccess_openWrite.txt";
461 
462             if (oObj.exists(copiedFile))
463                 oObj.kill(copiedFile);
464 
465             com.sun.star.io.XOutputStream oStream =
466                 oObj.openFileWrite(copiedFile);
467             tRes.tested("openFileWrite()", oStream != null);
468 
469             oStream.closeOutput();
470             oObj.kill(copiedFile);
471         }
472         catch (com.sun.star.uno.Exception ex) {
473             log.println("Exception occurred while testing 'openFileWrite()'");
474             ex.printStackTrace(log);
475             tRes.tested("openFileWrite()",false);
476         }
477 
478     } //EOF openFileWrite()
479 
480     /**
481     * Test calls the method and checks return value and that
482     * no exceptions were thrown. <b>XSimpleFileAccess2.txt</b>
483     * file used.<p>
484     * Has <b> OK </b> status if the method returns not
485     * <code>null</code> value and no exceptions were thrown. <p>
486     */
_openFileReadWrite()487     public void _openFileReadWrite() {
488         try {
489             String dirnameTo = util.utils.getOfficeTemp((XMultiServiceFactory)tParam.getMSF()) ;
490             String copiedFile = dirnameTo + "XSimpleFileAccess2.txt" ;
491 
492             if (oObj.exists(copiedFile))
493                 oObj.kill(copiedFile);
494 
495             com.sun.star.io.XStream aStream =
496                 oObj.openFileReadWrite(copiedFile);
497             tRes.tested("openFileReadWrite()", aStream != null);
498 
499             aStream.getInputStream().closeInput();
500             aStream.getOutputStream().closeOutput();
501 
502             oObj.kill(copiedFile);
503         }
504         catch (com.sun.star.uno.Exception ex) {
505             log.println("Exception occurred while testing 'openFileReadWrite()'");
506             ex.printStackTrace(log);
507             tRes.tested("openFileReadWrite()",false);
508         }
509 
510     } //EOF openFileReadWrite()
511 
512     /**
513     * Test calls the method and checks that no exceptions were thrown.
514     * Has <b> OK </b> status if no exceptions were thrown. <p>
515     */
_setInteractionHandler()516     public void _setInteractionHandler() {
517         XInteractionHandler handler = null;
518         Object oHandler = tEnv.getObjRelation("InteractionHandler");
519 
520         if (oHandler == null)
521             throw new StatusException
522                 (Status.failed("Reelation InteractionHandler not found"));
523 
524         try {
525             handler = (XInteractionHandler)UnoRuntime.queryInterface
526                 (XInteractionHandler.class, oHandler);
527             oObj.setInteractionHandler(handler);
528             tRes.tested("setInteractionHandler()", true);
529         } catch (Exception ex) {
530             log.println("Exception occurred while testing 'setInteractionHandler()'");
531             ex.printStackTrace(log);
532             tRes.tested("setInteractionHandler()", false);
533         }
534 
535     } //EOF setInteractionHandler()
536 
537 }  // finish class _XSimpleFileAccess
538 
539