1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.tests.java.io;
19
20import java.io.File;
21import java.io.FileFilter;
22import java.io.FileOutputStream;
23import java.io.FilenameFilter;
24import java.io.IOException;
25import java.io.ObjectStreamClass;
26import java.io.ObjectStreamField;
27import java.io.RandomAccessFile;
28import java.net.MalformedURLException;
29import java.net.URI;
30import java.net.URISyntaxException;
31import java.net.URL;
32import junit.framework.TestCase;
33import libcore.io.Libcore;
34import org.apache.harmony.testframework.serialization.SerializationTest;
35
36public class FileTest extends TestCase {
37
38    private static String platformId = "JDK"
39            + System.getProperty("java.vm.version").replace('.', '-');
40
41    private static void deleteTempFolder(File dir) {
42        String files[] = dir.list();
43        if (files != null) {
44            for (int i = 0; i < files.length; i++) {
45                File f = new File(dir, files[i]);
46                if (f.isDirectory()) {
47                    deleteTempFolder(f);
48                } else {
49                    f.delete();
50                }
51            }
52        }
53        dir.delete();
54    }
55
56    private static String addTrailingSlash(String path) {
57        if (File.separatorChar == path.charAt(path.length() - 1)) {
58            return path;
59        }
60        return path + File.separator;
61    }
62
63    /**
64     * Location to store tests in
65     */
66    private File tempDirectory;
67
68    public String fileString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_java_io_DataInputStream\nTest_File\nTest_FileDescriptor\nTest_FileInputStream\nTest_FileNotFoundException\nTest_FileOutputStream\nTest_java_io_FilterInputStream\nTest_java_io_FilterOutputStream\nTest_java_io_InputStream\nTest_java_io_IOException\nTest_java_io_OutputStream\nTest_java_io_PrintStream\nTest_java_io_RandomAccessFile\nTest_java_io_SyncFailedException\nTest_java_lang_AbstractMethodError\nTest_java_lang_ArithmeticException\nTest_java_lang_ArrayIndexOutOfBoundsException\nTest_java_lang_ArrayStoreException\nTest_java_lang_Boolean\nTest_java_lang_Byte\nTest_java_lang_Character\nTest_java_lang_Class\nTest_java_lang_ClassCastException\nTest_java_lang_ClassCircularityError\nTest_java_lang_ClassFormatError\nTest_java_lang_ClassLoader\nTest_java_lang_ClassNotFoundException\nTest_java_lang_CloneNotSupportedException\nTest_java_lang_Double\nTest_java_lang_Error\nTest_java_lang_Exception\nTest_java_lang_ExceptionInInitializerError\nTest_java_lang_Float\nTest_java_lang_IllegalAccessError\nTest_java_lang_IllegalAccessException\nTest_java_lang_IllegalArgumentException\nTest_java_lang_IllegalMonitorStateException\nTest_java_lang_IllegalThreadStateException\nTest_java_lang_IncompatibleClassChangeError\nTest_java_lang_IndexOutOfBoundsException\nTest_java_lang_InstantiationError\nTest_java_lang_InstantiationException\nTest_java_lang_Integer\nTest_java_lang_InternalError\nTest_java_lang_InterruptedException\nTest_java_lang_LinkageError\nTest_java_lang_Long\nTest_java_lang_Math\nTest_java_lang_NegativeArraySizeException\nTest_java_lang_NoClassDefFoundError\nTest_java_lang_NoSuchFieldError\nTest_java_lang_NoSuchMethodError\nTest_java_lang_NullPointerException\nTest_java_lang_Number\nTest_java_lang_NumberFormatException\nTest_java_lang_Object\nTest_java_lang_OutOfMemoryError\nTest_java_lang_RuntimeException\nTest_java_lang_SecurityManager\nTest_java_lang_Short\nTest_java_lang_StackOverflowError\nTest_java_lang_String\nTest_java_lang_StringBuffer\nTest_java_lang_StringIndexOutOfBoundsException\nTest_java_lang_System\nTest_java_lang_Thread\nTest_java_lang_ThreadDeath\nTest_java_lang_ThreadGroup\nTest_java_lang_Throwable\nTest_java_lang_UnknownError\nTest_java_lang_UnsatisfiedLinkError\nTest_java_lang_VerifyError\nTest_java_lang_VirtualMachineError\nTest_java_lang_vm_Image\nTest_java_lang_vm_MemorySegment\nTest_java_lang_vm_ROMStoreException\nTest_java_lang_vm_VM\nTest_java_lang_Void\nTest_java_net_BindException\nTest_java_net_ConnectException\nTest_java_net_DatagramPacket\nTest_java_net_DatagramSocket\nTest_java_net_DatagramSocketImpl\nTest_java_net_InetAddress\nTest_java_net_NoRouteToHostException\nTest_java_net_PlainDatagramSocketImpl\nTest_java_net_PlainSocketImpl\nTest_java_net_Socket\nTest_java_net_SocketException\nTest_java_net_SocketImpl\nTest_java_net_SocketInputStream\nTest_java_net_SocketOutputStream\nTest_java_net_UnknownHostException\nTest_java_util_ArrayEnumerator\nTest_java_util_Date\nTest_java_util_EventObject\nTest_java_util_HashEnumerator\nTest_java_util_Hashtable\nTest_java_util_Properties\nTest_java_util_ResourceBundle\nTest_java_util_tm\nTest_java_util_Vector\n";
69
70    protected void setUp() throws IOException {
71        /** Setup the temporary directory */
72        tempDirectory = new File(addTrailingSlash(System.getProperty("java.io.tmpdir")) + "harmony-test-" + getClass().getSimpleName() + File.separator);
73        tempDirectory.mkdirs();
74    }
75
76    protected void tearDown() {
77        if (tempDirectory != null) {
78            deleteTempFolder(tempDirectory);
79            tempDirectory = null;
80        }
81    }
82
83    /**
84     * java.io.File#File(java.io.File, java.lang.String)
85     */
86    public void test_ConstructorLjava_io_FileLjava_lang_String0() {
87        File f = new File(tempDirectory.getPath(), "input.tst");
88        assertEquals("Created Incorrect File ", addTrailingSlash(tempDirectory.getPath()) + "input.tst", f.getPath());
89    }
90
91    public void test_ConstructorLjava_io_FileLjava_lang_String1() {
92        try {
93            new File(tempDirectory, null);
94            fail("NullPointerException Not Thrown.");
95        } catch (NullPointerException e) {
96        }
97    }
98
99    public void test_ConstructorLjava_io_FileLjava_lang_String2() throws IOException {
100        File f = new File((File) null, "input.tst");
101        assertEquals("Created Incorrect File",
102                new File("input.tst").getAbsolutePath(),
103                f.getAbsolutePath());
104    }
105
106    public void test_ConstructorLjava_io_FileLjava_lang_String3() {
107        // Regression test for HARMONY-382
108        File f = new File("/abc");
109        File d = new File((File) null, "/abc");
110        assertEquals("Test3: Created Incorrect File",
111                d.getAbsolutePath(), f.getAbsolutePath());
112    }
113
114    public void test_ConstructorLjava_io_FileLjava_lang_String4() {
115        // Regression test for HARMONY-21
116        File path = new File("/dir/file");
117        File root = new File("/");
118        File file = new File(root, "/dir/file");
119        assertEquals("Assert 1: wrong path result ", path.getPath(), file
120                .getPath());
121        if (File.separatorChar == '\\') {
122            assertTrue("Assert 1.1: path not absolute ", new File("\\\\\\a\b")
123                    .isAbsolute());
124        } else {
125            assertFalse("Assert 1.1: path absolute ", new File("\\\\\\a\b")
126                    .isAbsolute());
127        }
128    }
129
130    public void test_ConstructorLjava_io_FileLjava_lang_String5() {
131        // Test data used in a few places below
132        String dirName = tempDirectory.getPath();
133        String fileName = "input.tst";
134
135        // Check filename is preserved correctly
136        File d = new File(dirName);
137        File f = new File(d, fileName);
138        dirName = addTrailingSlash(dirName);
139        dirName += fileName;
140        assertEquals("Assert 1: Created incorrect file ",
141                dirName, f.getPath());
142
143        // Check null argument is handled
144        try {
145            f = new File(d, null);
146            fail("Assert 2: NullPointerException not thrown.");
147        } catch (NullPointerException e) {
148            // Expected.
149        }
150    }
151
152    public void test_ConstructorLjava_io_FileLjava_lang_String6() {
153        // Regression for HARMONY-46
154        File f1 = new File("a");
155        File f2 = new File("a/");
156        assertEquals("Trailing slash file name is incorrect", f1, f2);
157    }
158
159    /**
160     * java.io.File#File(java.lang.String)
161     */
162    public void test_ConstructorLjava_lang_String() {
163        String fileName = null;
164        try {
165            new File(fileName);
166            fail("NullPointerException Not Thrown.");
167        } catch (NullPointerException e) {
168            // Expected
169        }
170
171        fileName = addTrailingSlash(tempDirectory.getPath());
172        fileName += "input.tst";
173
174        File f = new File(fileName);
175        assertEquals("Created incorrect File", fileName, f.getPath());
176    }
177
178    /**
179     * java.io.File#File(java.lang.String, java.lang.String)
180     */
181    public void test_ConstructorLjava_lang_StringLjava_lang_String() throws IOException {
182        String dirName = null;
183        String fileName = "input.tst";
184        File f = new File(dirName, fileName);
185        assertEquals("Test 1: Created Incorrect File",
186                new File("input.tst").getAbsolutePath(),
187                f.getAbsolutePath());
188
189        dirName = tempDirectory.getPath();
190        fileName = null;
191        try {
192            f = new File(dirName, fileName);
193            fail("NullPointerException Not Thrown.");
194        } catch (NullPointerException e) {
195            // Expected
196        }
197
198        fileName = "input.tst";
199        f = new File(dirName, fileName);
200        assertEquals("Test 2: Created Incorrect File",
201                addTrailingSlash(tempDirectory.getPath()) + "input.tst",
202                f.getPath());
203
204        // Regression test for HARMONY-382
205        String s = null;
206        f = new File("/abc");
207        File d = new File(s, "/abc");
208        assertEquals("Test3: Created Incorrect File", d.getAbsolutePath(), f
209                .getAbsolutePath());
210    }
211
212    /**
213     * java.io.File#File(java.lang.String, java.lang.String)
214     */
215    public void test_Constructor_String_String_112270() {
216        File ref1 = new File("/dir1/file1");
217
218        File file1 = new File("/", "/dir1/file1");
219        assertEquals("wrong result 1", ref1.getPath(), file1.getPath());
220        File file2 = new File("/", "//dir1/file1");
221        assertEquals("wrong result 2", ref1.getPath(), file2.getPath());
222
223        if (File.separatorChar == '\\') {
224            File file3 = new File("\\", "\\dir1\\file1");
225            assertEquals("wrong result 3", ref1.getPath(), file3.getPath());
226            File file4 = new File("\\", "\\\\dir1\\file1");
227            assertEquals("wrong result 4", ref1.getPath(), file4.getPath());
228        }
229
230        File ref2 = new File("/lib/test_112270.properties");
231        File file5 = new File("/", "lib/test_112270.properties");
232        assertEquals("wrong result 5", ref2.getPath(), file5.getPath());
233    }
234
235    /**
236     * java.io.File#File(java.io.File, java.lang.String)
237     */
238    public void test_Constructor_File_String_112270() {
239        File ref1 = new File("/dir1/file1");
240
241        File root = new File("/");
242        File file1 = new File(root, "/dir1/file1");
243        assertEquals("wrong result 1", ref1.getPath(), file1.getPath());
244        File file2 = new File(root, "//dir1/file1");
245        assertEquals("wrong result 2", ref1.getPath(), file2.getPath());
246
247        if (File.separatorChar == '\\') {
248            File file3 = new File(root, "\\dir1\\file1");
249            assertEquals("wrong result 3", ref1.getPath(), file3.getPath());
250            File file4 = new File(root, "\\\\dir1\\file1");
251            assertEquals("wrong result 4", ref1.getPath(), file4.getPath());
252        }
253
254        File ref2 = new File("/lib/content-types.properties");
255        File file5 = new File(root, "lib/content-types.properties");
256        assertEquals("wrong result 5", ref2.getPath(), file5.getPath());
257    }
258
259    /**
260     * java.io.File#File(java.net.URI)
261     */
262    public void test_ConstructorLjava_net_URI() throws URISyntaxException {
263        URI uri = null;
264        try {
265            new File(uri);
266            fail("NullPointerException Not Thrown.");
267        } catch (NullPointerException e) {
268            // Expected
269        }
270
271        // invalid file URIs
272        String[] uris = new String[] { "mailto:user@domain.com", // not
273                // hierarchical
274                "ftp:///path", // not file scheme
275                "//host/path/", // not absolute
276                "file://host/path", // non empty authority
277                "file:///path?query", // non empty query
278                "file:///path#fragment", // non empty fragment
279                "file:///path?", "file:///path#" };
280
281        for (int i = 0; i < uris.length; i++) {
282            uri = new URI(uris[i]);
283            try {
284                new File(uri);
285                fail("Expected IllegalArgumentException for new File(" + uri
286                        + ")");
287            } catch (IllegalArgumentException e) {
288                // Expected
289            }
290        }
291
292        // a valid File URI
293        File f = new File(new URI("file:///pa%20th/another\u20ac/pa%25th"));
294        assertTrue("Created incorrect File " + f.getPath(), f.getPath().equals(
295                File.separator + "pa th" + File.separator + "another\u20ac" + File.separator + "pa%th"));
296    }
297
298    /**
299     * java.io.File#canRead()
300     */
301    public void test_canRead() throws IOException {
302        // canRead only returns if the file exists so cannot be fully tested.
303        File f = new File(tempDirectory, platformId + "canRead.tst");
304        try {
305            FileOutputStream fos = new FileOutputStream(f);
306            fos.close();
307            assertTrue("canRead returned false", f.canRead());
308        } finally {
309            f.delete();
310        }
311    }
312
313    /**
314     * java.io.File#canWrite()
315     */
316    public void test_canWrite() throws IOException {
317        // canWrite only returns if the file exists so cannot be fully tested.
318        File f = new File(tempDirectory, platformId + "canWrite.tst");
319        try {
320            FileOutputStream fos = new FileOutputStream(f);
321            fos.close();
322            assertTrue("canWrite returned false", f.canWrite());
323        } finally {
324            f.delete();
325        }
326    }
327
328    /**
329     * java.io.File#compareTo(java.io.File)
330     */
331    public void test_compareToLjava_io_File() {
332        File f1 = new File("thisFile.file");
333        File f2 = new File("thisFile.file");
334        File f3 = new File("thatFile.file");
335        assertEquals("Equal files did not answer zero for compareTo", 0, f1
336                .compareTo(f2));
337        assertTrue("f3.compareTo(f1) did not result in value < 0", f3
338                .compareTo(f1) < 0);
339        assertTrue("f1.compareTo(f3) did not result in value > 0", f1
340                .compareTo(f3) > 0);
341    }
342
343    /**
344     * java.io.File#createNewFile()
345     */
346    public void test_createNewFile_EmptyString() {
347        File f = new File("");
348        try {
349            f.createNewFile();
350            fail("should throw IOException");
351        } catch (IOException e) {
352            // expected
353        }
354    }
355
356    /**
357     * java.io.File#createNewFile()
358     */
359    public void test_createNewFile() throws IOException {
360        String base = tempDirectory.getPath();
361        boolean dirExists = true;
362        int numDir = 1;
363        File dir = new File(base, String.valueOf(numDir));
364        // Making sure that the directory does not exist.
365        while (dirExists) {
366            // If the directory exists, add one to the directory number
367            // (making it a new directory name.)
368            if (dir.exists()) {
369                numDir++;
370                dir = new File(base, String.valueOf(numDir));
371            } else {
372                dirExists = false;
373            }
374        }
375
376        // Test for trying to create a file in a directory that does not
377        // exist.
378        try {
379            // Try to create a file in a directory that does not exist
380            File f1 = new File(dir, "tempfile.tst");
381            f1.createNewFile();
382            fail("IOException not thrown");
383        } catch (IOException e) {
384            // Expected
385        }
386
387        dir.mkdir();
388
389        File f1 = new File(dir, "tempfile.tst");
390        File f2 = new File(dir, "tempfile.tst");
391        f1.deleteOnExit();
392        f2.deleteOnExit();
393        dir.deleteOnExit();
394        assertFalse("File Should Not Exist", f1.isFile());
395        f1.createNewFile();
396        assertTrue("File Should Exist.", f1.isFile());
397        assertTrue("File Should Exist.", f2.isFile());
398        String dirName = f1.getParent();
399        if (!dirName.endsWith(File.separator)) {
400            dirName += File.separator;
401        }
402        assertEquals("File Saved To Wrong Directory.",
403                dir.getPath() + File.separator, dirName);
404        assertEquals("File Saved With Incorrect Name.", "tempfile.tst",
405                f1.getName());
406
407        // Test for creating a file that already exists.
408        assertFalse("File Already Exists, createNewFile Should Return False.",
409                f2.createNewFile());
410
411        // Test create an illegal file
412        String sep = File.separator;
413        f1 = new File(sep + "..");
414        try {
415            f1.createNewFile();
416            fail("should throw IOE");
417        } catch (IOException e) {
418            // expected;
419        }
420        f1 = new File(sep + "a" + sep + ".." + sep + ".." + sep);
421        try {
422            f1.createNewFile();
423            fail("should throw IOE");
424        } catch (IOException e) {
425            // expected;
426        }
427
428        // This test is invalid. createNewFile should return false
429        // not IOE when the file exists (in this case it exists and is
430        // a directory). TODO: We should probably replace this test
431        // with some that cover this behaviour. It might even be
432        // different on unix and windows since it directly reflects
433        // the open syscall behaviour.
434        //
435        // // Test create an exist path
436        // f1 = new File(base);
437        // try {
438        // assertFalse(f1.createNewFile());
439        // fail("should throw IOE");
440        // } catch (IOException e) {
441        // // expected;
442        // }
443    }
444
445    /**
446     * java.io.File#createTempFile(java.lang.String, java.lang.String)
447     */
448    public void test_createTempFileLjava_lang_StringLjava_lang_String()
449            throws IOException {
450        // Error protection against using a suffix without a "."?
451        File f1 = null;
452        File f2 = null;
453        try {
454            f1 = File.createTempFile("harmony-test-FileTest_tempFile_abc", ".tmp");
455            f2 = File.createTempFile("harmony-test-FileTest_tempFile_tf", null);
456
457            String fileLocation = addTrailingSlash(f1.getParent());
458
459            String tempDir = addTrailingSlash(System.getProperty("java.io.tmpdir"));
460
461            assertEquals(
462                    "File did not save to the default temporary-file location.",
463                    tempDir, fileLocation);
464
465            // Test to see if correct suffix was used to create the tempfile.
466            File currentFile;
467            String fileName;
468            // Testing two files, one with suffix ".tmp" and one with null
469            for (int i = 0; i < 2; i++) {
470                currentFile = i == 0 ? f1 : f2;
471                fileName = currentFile.getPath();
472                assertTrue("File Created With Incorrect Suffix.", fileName
473                        .endsWith(".tmp"));
474            }
475
476            // Tests to see if the correct prefix was used to create the
477            // tempfiles.
478            fileName = f1.getName();
479            assertTrue("Test 1: File Created With Incorrect Prefix.", fileName
480                    .startsWith("harmony-test-FileTest_tempFile_abc"));
481            fileName = f2.getName();
482            assertTrue("Test 2: File Created With Incorrect Prefix.", fileName
483                    .startsWith("harmony-test-FileTest_tempFile_tf"));
484
485            // Tests for creating a tempfile with a filename shorter than 3
486            // characters.
487            try {
488                File f3 = File.createTempFile("ab", ".tst");
489                f3.delete();
490                fail("IllegalArgumentException Not Thrown.");
491            } catch (IllegalArgumentException e) {
492                // Expected
493            }
494            try {
495                File f3 = File.createTempFile("a", ".tst");
496                f3.delete();
497                fail("IllegalArgumentException Not Thrown.");
498            } catch (IllegalArgumentException e) {
499                // Expected
500            }
501            try {
502                File f3 = File.createTempFile("", ".tst");
503                f3.delete();
504                fail("IllegalArgumentException Not Thrown.");
505            } catch (IllegalArgumentException e) {
506                // Expected
507            }
508        } finally {
509            if (f1 != null) {
510                f1.delete();
511            }
512            if (f2 != null) {
513                f2.delete();
514            }
515        }
516    }
517
518    /**
519     * java.io.File#createTempFile(java.lang.String, java.lang.String,
520     *java.io.File)
521     */
522    public void test_createTempFileLjava_lang_StringLjava_lang_StringLjava_io_File()
523            throws IOException {
524        File f1 = null;
525        File f2 = null;
526        String base = System.getProperty("java.io.tmpdir");
527        try {
528            // Test to make sure that the tempfile was saved in the correct
529            // location and with the correct prefix/suffix.
530            f1 = File.createTempFile("harmony-test-FileTest_tempFile2_tf", null, null);
531            File dir = new File(base);
532            f2 = File.createTempFile("harmony-test-FileTest_tempFile2_tf", ".tmp", dir);
533            File currentFile;
534            String fileLocation;
535            String fileName;
536            for (int i = 0; i < 2; i++) {
537                currentFile = i == 0 ? f1 : f2;
538                fileLocation = addTrailingSlash(currentFile.getParent());
539                base = addTrailingSlash(base);
540                assertEquals(
541                        "File not created in the default temporary-file location.",
542                        base, fileLocation);
543                fileName = currentFile.getName();
544                assertTrue("File created with incorrect suffix.", fileName
545                        .endsWith(".tmp"));
546                assertTrue("File created with incorrect prefix.", fileName
547                        .startsWith("harmony-test-FileTest_tempFile2_tf"));
548                currentFile.delete();
549            }
550
551            // Test for creating a tempfile in a directory that does not exist.
552            int dirNumber = 1;
553            boolean dirExists = true;
554            // Set dir to a non-existent directory inside the temporary
555            // directory
556            dir = new File(base, String.valueOf(dirNumber));
557            // Making sure that the directory does not exist.
558            while (dirExists) {
559                // If the directory exists, add one to the directory number
560                // (making it
561                // a new directory name.)
562                if (dir.exists()) {
563                    dirNumber++;
564                    dir = new File(base, String.valueOf(dirNumber));
565                } else {
566                    dirExists = false;
567                }
568            }
569            try {
570                // Try to create a file in a directory that does not exist
571                File f3 = File.createTempFile("harmony-test-FileTest_tempFile2_tf", null, dir);
572                f3.delete();
573                fail("IOException not thrown");
574            } catch (IOException e) {
575                // Expected
576            }
577            dir.delete();
578
579            // Tests for creating a tempfile with a filename shorter than 3
580            // characters.
581            try {
582                File f4 = File.createTempFile("ab", null, null);
583                f4.delete();
584                fail("IllegalArgumentException not thrown.");
585            } catch (IllegalArgumentException e) {
586                // Expected
587            }
588            try {
589                File f4 = File.createTempFile("a", null, null);
590                f4.delete();
591                fail("IllegalArgumentException not thrown.");
592            } catch (IllegalArgumentException e) {
593                // Expected
594            }
595            try {
596                File f4 = File.createTempFile("", null, null);
597                f4.delete();
598                fail("IllegalArgumentException not thrown.");
599            } catch (IllegalArgumentException e) {
600                // Expected
601            }
602        } finally {
603            if (f1 != null) {
604                f1.delete();
605            }
606            if (f2 != null) {
607                f1.delete();
608            }
609        }
610    }
611
612    /**
613     * java.io.File#delete()
614     */
615    public void test_delete() throws IOException {
616        File dir = new File(tempDirectory, platformId
617                + "filechk");
618        dir.mkdir();
619        assertTrue("Directory does not exist", dir.exists());
620        assertTrue("Directory is not directory", dir.isDirectory());
621        File f = new File(dir, "filechk.tst");
622        FileOutputStream fos = new FileOutputStream(f);
623        fos.close();
624        assertTrue("Error Creating File For Delete Test", f.exists());
625        dir.delete();
626        assertTrue("Directory Should Not Have Been Deleted.", dir.exists());
627        f.delete();
628        assertTrue("File Was Not Deleted", !f.exists());
629        dir.delete();
630        assertTrue("Directory Was Not Deleted", !dir.exists());
631    }
632
633    // GCH
634    // TODO : This test passes on Windows but fails on Linux with a
635    // java.lang.NoClassDefFoundError. Temporarily removing from the test
636    // suite while I investigate the cause.
637    // /**
638    // * java.io.File#deleteOnExit()
639    // */
640    // public void test_deleteOnExit() {
641    // File f1 = new File(System.getProperty("java.io.tmpdir"), platformId
642    // + "deleteOnExit.tst");
643    // try {
644    // FileOutputStream fos = new FileOutputStream(f1);
645    // fos.close();
646    // } catch (IOException e) {
647    // fail("Unexpected IOException During Test : " + e.getMessage());
648    // }
649    // assertTrue("File Should Exist.", f1.exists());
650    //
651    // try {
652    // Support_Exec.execJava(new String[] {
653    // "tests.support.Support_DeleteOnExitTest", f1.getPath() },
654    // null, true);
655    // } catch (IOException e) {
656    // fail("Unexpected IOException During Test + " + e.getMessage());
657    // } catch (InterruptedException e) {
658    // fail("Unexpected InterruptedException During Test: " + e);
659    // }
660    //
661    // boolean gone = !f1.exists();
662    // f1.delete();
663    // assertTrue("File Should Already Be Deleted.", gone);
664    // }
665
666    /**
667     * java.io.File#equals(java.lang.Object)
668     */
669    public void test_equalsLjava_lang_Object() throws IOException {
670        File f1 = new File("filechk.tst");
671        File f2 = new File("filechk.tst");
672        File f3 = new File("xxxx");
673
674        assertTrue("Equality test failed", f1.equals(f2));
675        assertTrue("Files Should Not Return Equal.", !f1.equals(f3));
676
677        f1 = new File(tempDirectory, "casetest.tmp");
678        f2 = new File(tempDirectory, "CaseTest.tmp");
679        assertFalse(f1.equals(f2));
680        assertTrue(f1.createNewFile());
681        f1.delete();
682    }
683
684    /**
685     * java.io.File#exists()
686     */
687    public void test_exists() throws IOException {
688        File f = new File(tempDirectory, platformId
689                + "exists.tst");
690        assertTrue("Exists returned true for non-existent file", !f.exists());
691        FileOutputStream fos = new FileOutputStream(f);
692        fos.close();
693        assertTrue("Exists returned false file", f.exists());
694        f.delete();
695    }
696
697    /**
698     * java.io.File#getAbsoluteFile()
699     */
700    public void test_getAbsoluteFile() {
701        String base = addTrailingSlash(tempDirectory.getPath());
702        File f = new File(base, "temp.tst");
703        File f2 = f.getAbsoluteFile();
704        assertEquals("Test 1: Incorrect File Returned.", 0, f2.compareTo(f
705                .getAbsoluteFile()));
706        f = new File(base + "Temp" + File.separator + File.separator + "temp.tst");
707        f2 = f.getAbsoluteFile();
708        assertEquals("Test 2: Incorrect File Returned.", 0, f2.compareTo(f
709                .getAbsoluteFile()));
710        f = new File(base + File.separator + ".." + File.separator + "temp.tst");
711        f2 = f.getAbsoluteFile();
712        assertEquals("Test 3: Incorrect File Returned.", 0, f2.compareTo(f
713                .getAbsoluteFile()));
714        f.delete();
715        f2.delete();
716    }
717
718    /**
719     * java.io.File#getAbsolutePath()
720     */
721    public void test_getAbsolutePath() {
722        String base = addTrailingSlash(tempDirectory.getPath());
723        File f = new File(base, "temp.tst");
724        assertEquals("Test 1: Incorrect Path Returned.",
725                base + "temp.tst", f.getAbsolutePath());
726
727        f = new File(base + "Temp" + File.separator + File.separator + File.separator + "Testing" + File.separator
728                + "temp.tst");
729        assertEquals("Test 2: Incorrect Path Returned.",
730                base + "Temp" + File.separator + "Testing" + File.separator + "temp.tst",
731                f.getAbsolutePath());
732
733        f = new File(base + "a" + File.separator + File.separator + ".." + File.separator + "temp.tst");
734        assertEquals("Test 3: Incorrect Path Returned.",
735                base + "a" + File.separator + ".." + File.separator + "temp.tst",
736                f.getAbsolutePath());
737        f.delete();
738    }
739
740    /**
741     * java.io.File#getCanonicalFile()
742     */
743    public void test_getCanonicalFile() throws IOException {
744        String base = addTrailingSlash(tempDirectory.getPath());
745        File f = new File(base, "temp.tst");
746        File f2 = f.getCanonicalFile();
747        assertEquals("Test 1: Incorrect File Returned.", 0, f2
748                .getCanonicalFile().compareTo(f.getCanonicalFile()));
749        f = new File(base + "Temp" + File.separator + File.separator + "temp.tst");
750        f2 = f.getCanonicalFile();
751        assertEquals("Test 2: Incorrect File Returned.", 0, f2
752                .getCanonicalFile().compareTo(f.getCanonicalFile()));
753        f = new File(base + "Temp" + File.separator + File.separator + ".." + File.separator + "temp.tst");
754        f2 = f.getCanonicalFile();
755        assertEquals("Test 3: Incorrect File Returned.", 0, f2
756                .getCanonicalFile().compareTo(f.getCanonicalFile()));
757
758        // Test for when long directory/file names in Windows
759        boolean onWindows = File.separatorChar == '\\';
760        if (onWindows) {
761            File testdir = new File(base, "long-" + platformId);
762            testdir.mkdir();
763            File dir = new File(testdir, "longdirectory" + platformId);
764            try {
765                dir.mkdir();
766                f = new File(dir, "longfilename.tst");
767                f2 = f.getCanonicalFile();
768                assertEquals("Test 4: Incorrect File Returned.", 0, f2
769                        .getCanonicalFile().compareTo(f.getCanonicalFile()));
770                FileOutputStream fos = new FileOutputStream(f);
771                fos.close();
772                f2 = new File(testdir + File.separator + "longdi~1" + File.separator
773                        + "longfi~1.tst");
774                File canonicalf2 = f2.getCanonicalFile();
775                /*
776                 * If the "short file name" doesn't exist, then assume that the
777                 * 8.3 file name compatibility is disabled.
778                 */
779                if (canonicalf2.exists()) {
780                    assertTrue("Test 5: Incorrect File Returned: "
781                            + canonicalf2, canonicalf2.compareTo(f
782                            .getCanonicalFile()) == 0);
783                }
784            } finally {
785                f.delete();
786                f2.delete();
787                dir.delete();
788                testdir.delete();
789            }
790        }
791    }
792
793    /**
794     * java.io.File#getCanonicalPath()
795     */
796    public void test_getCanonicalPath() throws IOException {
797        // Should work for Unix/Windows.
798        String dots = "..";
799        String base = tempDirectory.getCanonicalPath();
800        base = addTrailingSlash(base);
801        File f = new File(base, "temp.tst");
802        assertEquals("Test 1: Incorrect Path Returned.", base + "temp.tst", f
803                .getCanonicalPath());
804        f = new File(base + "Temp" + File.separator + dots + File.separator + "temp.tst");
805        assertEquals("Test 2: Incorrect Path Returned.", base + "temp.tst", f
806                .getCanonicalPath());
807
808        // Finding a non-existent directory for tests 3 and 4
809        // This is necessary because getCanonicalPath is case sensitive and
810        // could cause a failure in the test if the directory exists but with
811        // different case letters (e.g "Temp" and "temp")
812        int dirNumber = 1;
813        boolean dirExists = true;
814        File dir1 = new File(base, String.valueOf(dirNumber));
815        while (dirExists) {
816            if (dir1.exists()) {
817                dirNumber++;
818                dir1 = new File(base, String.valueOf(dirNumber));
819            } else {
820                dirExists = false;
821            }
822        }
823        f = new File(base + dirNumber + File.separator + dots + File.separator + dirNumber
824                + File.separator + "temp.tst");
825        assertEquals("Test 3: Incorrect Path Returned.", base + dirNumber
826                + File.separator + "temp.tst", f.getCanonicalPath());
827        f = new File(base + dirNumber + File.separator + "Temp" + File.separator + dots + File.separator
828                + "Test" + File.separator + "temp.tst");
829        assertEquals("Test 4: Incorrect Path Returned.", base + dirNumber
830                + File.separator + "Test" + File.separator + "temp.tst", f.getCanonicalPath());
831
832        f = new File(base + "1234.567");
833        assertEquals("Test 5: Incorrect Path Returned.", base + "1234.567", f
834                .getCanonicalPath());
835
836        // Test for long file names on Windows
837        boolean onWindows = (File.separatorChar == '\\');
838        if (onWindows) {
839            File testdir = new File(base, "long-" + platformId);
840            testdir.mkdir();
841            File f1 = new File(testdir, "longfilename" + platformId + ".tst");
842            FileOutputStream fos = new FileOutputStream(f1);
843            File f2 = null, f3 = null, dir2 = null;
844            try {
845                fos.close();
846                String dirName1 = f1.getCanonicalPath();
847                File f4 = new File(testdir, "longfi~1.tst");
848                /*
849                 * If the "short file name" doesn't exist, then assume that the
850                 * 8.3 file name compatibility is disabled.
851                 */
852                if (f4.exists()) {
853                    String dirName2 = f4.getCanonicalPath();
854                    assertEquals("Test 6: Incorrect Path Returned.", dirName1,
855                            dirName2);
856                    dir2 = new File(testdir, "longdirectory" + platformId);
857                    if (!dir2.exists()) {
858                        assertTrue("Could not create dir: " + dir2, dir2
859                                .mkdir());
860                    }
861                    f2 = new File(testdir.getPath() + File.separator + "longdirectory"
862                            + platformId + File.separator + "Test" + File.separator + dots
863                            + File.separator + "longfilename.tst");
864                    FileOutputStream fos2 = new FileOutputStream(f2);
865                    fos2.close();
866                    dirName1 = f2.getCanonicalPath();
867                    f3 = new File(testdir.getPath() + File.separator + "longdi~1"
868                            + File.separator + "Test" + File.separator + dots + File.separator
869                            + "longfi~1.tst");
870                    dirName2 = f3.getCanonicalPath();
871                    assertEquals("Test 7: Incorrect Path Returned.", dirName1,
872                            dirName2);
873                }
874            } finally {
875                f1.delete();
876                if (f2 != null) {
877                    f2.delete();
878                }
879                if (dir2 != null) {
880                    dir2.delete();
881                }
882                testdir.delete();
883            }
884        }
885    }
886
887    /**
888     * java.io.File#getName()
889     */
890    public void test_getName() {
891        File f = new File("name.tst");
892        assertEquals("Test 1: Returned incorrect name", "name.tst", f.getName());
893
894        f = new File("");
895        assertEquals("Test 2: Returned incorrect name", "", f.getName());
896
897        f.delete();
898    }
899
900    /**
901     * java.io.File#getParent()
902     */
903    public void test_getParent() {
904        File f = new File("p.tst");
905        assertNull("Incorrect path returned", f.getParent());
906        f = new File("/user/home/p.tst");
907        assertEquals("Incorrect path returned",
908                "/user/home", f.getParent());
909
910        File f1 = new File("/directory");
911        assertEquals("Wrong parent test 1", File.separator, f1.getParent());
912        f1 = new File("/directory/file");
913        assertEquals("Wrong parent test 2",
914                File.separator + "directory", f1.getParent());
915        f1 = new File("directory/file");
916        assertEquals("Wrong parent test 3", "directory", f1.getParent());
917        f1 = new File("/");
918        assertNull("Wrong parent test 4", f1.getParent());
919        f1 = new File("directory");
920        assertNull("Wrong parent test 5", f1.getParent());
921
922        if (File.separatorChar == '\\' && new File("d:/").isAbsolute()) {
923            f1 = new File("d:/directory");
924            assertEquals("Wrong parent test 1a", "d:" + File.separator, f1.getParent());
925            f1 = new File("d:/directory/file");
926            assertEquals("Wrong parent test 2a",
927                    "d:" + File.separator + "directory", f1.getParent());
928            f1 = new File("d:directory/file");
929            assertEquals("Wrong parent test 3a", "d:directory", f1.getParent());
930            f1 = new File("d:/");
931            assertNull("Wrong parent test 4a", f1.getParent());
932            f1 = new File("d:directory");
933            assertEquals("Wrong parent test 5a", "d:", f1.getParent());
934        }
935    }
936
937    /**
938     * java.io.File#getParentFile()
939     */
940    public void test_getParentFile() {
941        File f = new File("tempfile.tst");
942        assertNull("Incorrect path returned", f.getParentFile());
943        f = new File(tempDirectory, "tempfile1.tmp");
944        File f2 = new File(tempDirectory, "tempfile2.tmp");
945        File f3 = new File(tempDirectory, "/a/tempfile.tmp");
946        assertEquals("Incorrect File Returned", 0, f.getParentFile().compareTo(
947                f2.getParentFile()));
948        assertTrue("Incorrect File Returned", f.getParentFile().compareTo(
949                f3.getParentFile()) != 0);
950        f.delete();
951        f2.delete();
952        f3.delete();
953    }
954
955    /**
956     * java.io.File#getPath()
957     */
958    public void test_getPath() {
959        String base = System.getProperty("user.home");
960        String fname;
961        File f1;
962        if (!base.regionMatches((base.length() - 1), File.separator, 0, 1)) {
963            base += File.separator;
964        }
965        fname = base + "filechk.tst";
966        f1 = new File(base, "filechk.tst");
967        File f2 = new File("filechk.tst");
968        File f3 = new File("c:");
969        File f4 = new File(base + "a" + File.separator + File.separator + ".." + File.separator
970                + "filechk.tst");
971        assertEquals("getPath returned incorrect path(f1)",
972                fname, f1.getPath());
973        assertEquals("getPath returned incorrect path(f2)",
974                "filechk.tst", f2.getPath());
975        assertEquals("getPath returned incorrect path(f3)", "c:", f3.getPath());
976        assertEquals("getPath returned incorrect path(f4)",
977                base + "a" + File.separator + ".." + File.separator + "filechk.tst",
978                f4.getPath());
979        f1.delete();
980        f2.delete();
981        f3.delete();
982        f4.delete();
983
984        // Regression for HARMONY-444
985        File file;
986        String separator = File.separator;
987
988        file = new File((File) null, "x/y/z");
989        assertEquals("x" + separator + "y" + separator + "z", file.getPath());
990
991        file = new File((String) null, "x/y/z");
992        assertEquals("x" + separator + "y" + separator + "z", file.getPath());
993
994        // Regression for HARMONY-829
995        String f1ParentName = "01";
996        f1 = new File(f1ParentName, "");
997        assertEquals(f1ParentName, f1.getPath());
998
999        String f2ParentName = "0";
1000        f2 = new File(f2ParentName, "");
1001
1002        assertEquals(-1, f2.compareTo(f1));
1003        assertEquals(1, f1.compareTo(f2));
1004
1005        File parent = tempDirectory;
1006        f3 = new File(parent, "");
1007
1008        assertEquals(parent.getPath(), f3.getPath());
1009
1010        File file0 = new File("");
1011        assertEquals("", file0.getPath());
1012
1013        // Regression for HARMONY-3869
1014        // Behavior here is system-dependent according to the RI javadoc.
1015        String path1 = new File("", "").getPath();
1016        assertTrue(path1.equals(File.separator) || path1.isEmpty());
1017        String path2 = new File(new File(""), "").getPath();
1018        assertTrue(path2.equals(File.separator) || path2.isEmpty());
1019    }
1020
1021    /**
1022     * java.io.File#hashCode()
1023     */
1024    public void test_hashCode() {
1025        // Regression for HARMONY-53
1026        File mfile = new File("SoMe FiLeNaMe"); // Mixed case
1027        File lfile = new File("some filename"); // Lower case
1028
1029        if (mfile.equals(lfile)) {
1030            assertTrue("Assert 0: wrong hashcode", mfile.hashCode() == lfile
1031                    .hashCode());
1032        } else {
1033            assertFalse("Assert 1: wrong hashcode", mfile.hashCode() == lfile
1034                    .hashCode());
1035        }
1036    }
1037
1038    /**
1039     * java.io.File#isAbsolute()
1040     */
1041    public void test_isAbsolute() {
1042        if (File.separatorChar == '\\') {
1043            File f = new File("c:\\test");
1044            File f1 = new File("\\test");
1045            // One or the other should be absolute on Windows or CE
1046            assertTrue("Absolute returned false", (f.isAbsolute() && !f1
1047                    .isAbsolute())
1048                    || (!f.isAbsolute() && f1.isAbsolute()));
1049
1050            assertTrue(new File("C:/").isAbsolute());
1051            assertTrue(new File("f:/").isAbsolute());
1052            assertTrue(new File("f:\\").isAbsolute());
1053            assertFalse(new File("f:").isAbsolute());
1054            assertFalse(new File("K:").isAbsolute());
1055            assertTrue(new File("\\\\").isAbsolute());
1056            assertTrue(new File("\\\\\\").isAbsolute());
1057            assertTrue(new File("\\\\hello").isAbsolute());
1058            assertFalse(new File("\\").isAbsolute());
1059            assertFalse(new File("/").isAbsolute());
1060        } else {
1061            File f = new File("/test");
1062            File f1 = new File("\\test");
1063            assertTrue("Absolute returned false", f.isAbsolute());
1064            assertFalse("Absolute returned true", f1.isAbsolute());
1065            assertTrue(new File("//test").isAbsolute());
1066            assertFalse(new File("test").isAbsolute());
1067            assertFalse(new File("c:/").isAbsolute());
1068            assertFalse(new File("c:\\").isAbsolute());
1069            assertFalse(new File("c:").isAbsolute());
1070            assertFalse(new File("\\").isAbsolute());
1071            assertFalse(new File("\\\\").isAbsolute());
1072        }
1073        assertTrue("Non-Absolute returned true", !new File("../test")
1074                .isAbsolute());
1075    }
1076
1077    /**
1078     * java.io.File#isDirectory()
1079     */
1080    public void test_isDirectory() {
1081        String base = addTrailingSlash(tempDirectory.getPath());
1082        File f = new File(base);
1083        assertTrue("Test 1: Directory Returned False", f.isDirectory());
1084        f = new File(base + "zxzxzxz" + platformId);
1085        assertTrue("Test 2: (Not Created) Directory Returned True.", !f
1086                .isDirectory());
1087        f.mkdir();
1088        try {
1089            assertTrue("Test 3: Directory Returned False.", f.isDirectory());
1090        } finally {
1091            f.delete();
1092        }
1093    }
1094
1095    /**
1096     * java.io.File#isFile()
1097     */
1098    public void test_isFile() throws IOException {
1099        String base = tempDirectory.getPath();
1100        File f = new File(base);
1101        assertFalse("Directory Returned True As Being A File.", f.isFile());
1102
1103        base = addTrailingSlash(base);
1104        f = new File(base, platformId + "amiafile");
1105        assertTrue("Non-existent File Returned True", !f.isFile());
1106        FileOutputStream fos = new FileOutputStream(f);
1107        fos.close();
1108        assertTrue("File returned false", f.isFile());
1109        f.delete();
1110    }
1111
1112    public void test_isHidden() throws IOException, InterruptedException {
1113        boolean onUnix = File.separatorChar == '/';
1114        assertTrue(onUnix);
1115
1116        // On Unix hidden files are marked with a "." at the beginning
1117        // of the file name.
1118        File f1 = File.createTempFile("harmony-test-FileTest_notHidden_", ".tmp");
1119        File f2 = File.createTempFile(".harmony-test-FileTest_isHidden_", ".tmp");
1120        assertFalse(f1.isHidden());
1121        assertTrue(f2.isHidden());
1122        // We can still delete hidden files.
1123        assertTrue(f2.delete());
1124        f1.delete();
1125    }
1126
1127    /**
1128     * java.io.File#lastModified()
1129     */
1130    public void test_lastModified() throws IOException {
1131        File f = new File(System.getProperty("java.io.tmpdir"), platformId
1132                + "lModTest.tst");
1133        f.delete();
1134        long lastModifiedTime = f.lastModified();
1135        assertEquals("LastModified Time Should Have Returned 0.", 0,
1136                lastModifiedTime);
1137        FileOutputStream fos = new FileOutputStream(f);
1138        fos.close();
1139        f.setLastModified(315550800000L);
1140        lastModifiedTime = f.lastModified();
1141        assertEquals("LastModified Time Incorrect",
1142                315550800000L, lastModifiedTime);
1143        f.delete();
1144    }
1145
1146    /**
1147     * java.io.File#length()
1148     */
1149    public void test_length() throws IOException {
1150        File f = new File(tempDirectory, platformId
1151                + "input.tst");
1152        assertEquals("File Length Should Have Returned 0.", 0, f.length());
1153        FileOutputStream fos = new FileOutputStream(f);
1154        fos.write(fileString.getBytes());
1155        fos.close();
1156        assertEquals("Incorrect file length returned",
1157                fileString.length(), f.length());
1158        f.delete();
1159
1160        // regression test for HARMONY-1497
1161        f = File.createTempFile("test", "tmp");
1162        f.deleteOnExit();
1163        RandomAccessFile raf = new RandomAccessFile(f, "rwd");
1164        raf.write(0x41);
1165        assertEquals(1, f.length());
1166    }
1167
1168    /**
1169     * java.io.File#list()
1170     */
1171    public void test_list() throws IOException {
1172        String base = tempDirectory.getPath();
1173        // Old test left behind "garbage files" so this time it creates a
1174        // directory that is guaranteed not to already exist (and deletes it
1175        // afterward.)
1176        int dirNumber = 1;
1177        boolean dirExists = true;
1178        File dir = null;
1179        dir = new File(base, platformId + String.valueOf(dirNumber));
1180        while (dirExists) {
1181            if (dir.exists()) {
1182                dirNumber++;
1183                dir = new File(base, String.valueOf(dirNumber));
1184            } else {
1185                dirExists = false;
1186            }
1187        }
1188
1189        String[] flist = dir.list();
1190
1191        assertNull("Method list() Should Have Returned null.", flist);
1192
1193        assertTrue("Could not create parent directory for list test", dir
1194                .mkdir());
1195
1196        String[] files = { "mtzz1.xx", "mtzz2.xx", "mtzz3.yy", "mtzz4.yy" };
1197        try {
1198            assertEquals(
1199                    "Method list() Should Have Returned An Array Of Length 0.",
1200                    0, dir.list().length);
1201
1202            File file = new File(dir, "notADir.tst");
1203            try {
1204                FileOutputStream fos = new FileOutputStream(file);
1205                fos.close();
1206                assertNull(
1207                        "listFiles Should Have Returned Null When Used On A File Instead Of A Directory.",
1208                        file.list());
1209            } finally {
1210                file.delete();
1211            }
1212
1213            for (int i = 0; i < files.length; i++) {
1214                File f = new File(dir, files[i]);
1215                FileOutputStream fos = new FileOutputStream(f);
1216                fos.close();
1217            }
1218
1219            flist = dir.list();
1220            if (flist.length != files.length) {
1221                fail("Incorrect list returned");
1222            }
1223
1224            // Checking to make sure the correct files were are listed in the
1225            // array.
1226            boolean[] check = new boolean[flist.length];
1227            for (int i = 0; i < check.length; i++) {
1228                check[i] = false;
1229            }
1230            for (int i = 0; i < files.length; i++) {
1231                for (int j = 0; j < flist.length; j++) {
1232                    if (flist[j].equals(files[i])) {
1233                        check[i] = true;
1234                        break;
1235                    }
1236                }
1237            }
1238            int checkCount = 0;
1239            for (int i = 0; i < check.length; i++) {
1240                if (check[i] == false) {
1241                    checkCount++;
1242                }
1243            }
1244            assertEquals("Invalid file returned in listing", 0, checkCount);
1245
1246            for (int i = 0; i < files.length; i++) {
1247                File f = new File(dir, files[i]);
1248                f.delete();
1249            }
1250
1251            assertTrue("Could not delete parent directory for list test.", dir
1252                    .delete());
1253        } finally {
1254            for (int i = 0; i < files.length; i++) {
1255                File f = new File(dir, files[i]);
1256                f.delete();
1257            }
1258            dir.delete();
1259        }
1260    }
1261
1262    /**
1263     * java.io.File#listFiles()
1264     */
1265    public void test_listFiles() throws IOException, InterruptedException {
1266        String base = tempDirectory.getPath();
1267        // Finding a non-existent directory to create.
1268        int dirNumber = 1;
1269        boolean dirExists = true;
1270        File dir = new File(base, platformId + String.valueOf(dirNumber));
1271        // Making sure that the directory does not exist.
1272        while (dirExists) {
1273            // If the directory exists, add one to the directory number
1274            // (making it a new directory name.)
1275            if (dir.exists()) {
1276                dirNumber++;
1277                dir = new File(base, String.valueOf(dirNumber));
1278            } else {
1279                dirExists = false;
1280            }
1281        }
1282        // Test for attempting to call listFiles on a non-existent directory.
1283        assertNull("listFiles Should Return Null.", dir.listFiles());
1284
1285        assertTrue("Failed To Create Parent Directory.", dir.mkdir());
1286
1287        String[] files = { "1.tst", "2.tst", "3.tst", "" };
1288        try {
1289            assertEquals("listFiles Should Return An Array Of Length 0.", 0,
1290                    dir.listFiles().length);
1291
1292            File file = new File(dir, "notADir.tst");
1293            try {
1294                FileOutputStream fos = new FileOutputStream(file);
1295                fos.close();
1296                assertNull(
1297                        "listFiles Should Have Returned Null When Used On A File Instead Of A Directory.",
1298                        file.listFiles());
1299            } finally {
1300                file.delete();
1301            }
1302
1303            for (int i = 0; i < (files.length - 1); i++) {
1304                File f = new File(dir, files[i]);
1305                FileOutputStream fos = new FileOutputStream(f);
1306                fos.close();
1307            }
1308
1309            new File(dir, "doesNotExist.tst");
1310            File[] flist = dir.listFiles();
1311
1312            // Test to make sure that only the 3 files that were created are
1313            // listed.
1314            assertEquals("Incorrect Number Of Files Returned.", 3, flist.length);
1315
1316            // Test to make sure that listFiles can read hidden files.
1317            boolean onUnix = File.separatorChar == '/';
1318            boolean onWindows = File.separatorChar == '\\';
1319            if (onWindows) {
1320                files[3] = "4.tst";
1321                File f = new File(dir, "4.tst");
1322                FileOutputStream fos = new FileOutputStream(f);
1323                fos.close();
1324                Runtime r = Runtime.getRuntime();
1325                Process p = r.exec("attrib +h \"" + f.getPath() + "\"");
1326                p.waitFor();
1327            }
1328            if (onUnix) {
1329                files[3] = ".4.tst";
1330                File f = new File(dir, ".4.tst");
1331                FileOutputStream fos = new FileOutputStream(f);
1332                fos.close();
1333            }
1334            flist = dir.listFiles();
1335            assertEquals("Incorrect Number Of Files Returned.", 4, flist.length);
1336
1337            // Checking to make sure the correct files were are listed in
1338            // the array.
1339            boolean[] check = new boolean[flist.length];
1340            for (int i = 0; i < check.length; i++) {
1341                check[i] = false;
1342            }
1343            for (int i = 0; i < files.length; i++) {
1344                for (int j = 0; j < flist.length; j++) {
1345                    if (flist[j].getName().equals(files[i])) {
1346                        check[i] = true;
1347                        break;
1348                    }
1349                }
1350            }
1351            int checkCount = 0;
1352            for (int i = 0; i < check.length; i++) {
1353                if (check[i] == false) {
1354                    checkCount++;
1355                }
1356            }
1357            assertEquals("Invalid file returned in listing", 0, checkCount);
1358
1359            if (onWindows) {
1360                Runtime r = Runtime.getRuntime();
1361                Process p = r.exec("attrib -h \""
1362                        + new File(dir, files[3]).getPath() + "\"");
1363                p.waitFor();
1364            }
1365
1366            for (int i = 0; i < files.length; i++) {
1367                File f = new File(dir, files[i]);
1368                f.delete();
1369            }
1370            assertTrue("Parent Directory Not Deleted.", dir.delete());
1371        } finally {
1372            for (int i = 0; i < files.length; i++) {
1373                File f = new File(dir, files[i]);
1374                f.delete();
1375            }
1376            dir.delete();
1377        }
1378    }
1379
1380    /**
1381     * java.io.File#listFiles(java.io.FileFilter)
1382     */
1383    public void test_listFilesLjava_io_FileFilter() throws IOException {
1384        String base = System.getProperty("java.io.tmpdir");
1385        // Finding a non-existent directory to create.
1386        int dirNumber = 1;
1387        boolean dirExists = true;
1388        File baseDir = new File(base, platformId + String.valueOf(dirNumber));
1389        // Making sure that the directory does not exist.
1390        while (dirExists) {
1391            // If the directory exists, add one to the directory number (making
1392            // it a new directory name.)
1393            if (baseDir.exists()) {
1394                dirNumber++;
1395                baseDir = new File(base, String.valueOf(dirNumber));
1396            } else {
1397                dirExists = false;
1398            }
1399        }
1400
1401        // Creating a filter that catches directories.
1402        FileFilter dirFilter = new FileFilter() {
1403            public boolean accept(File f) {
1404                return f.isDirectory();
1405            }
1406        };
1407
1408        assertNull("listFiles Should Return Null.", baseDir
1409                .listFiles(dirFilter));
1410
1411        assertTrue("Failed To Create Parent Directory.", baseDir.mkdir());
1412
1413        File dir1 = null;
1414        String[] files = { "1.tst", "2.tst", "3.tst" };
1415        try {
1416            assertEquals("listFiles Should Return An Array Of Length 0.", 0,
1417                    baseDir.listFiles(dirFilter).length);
1418
1419            File file = new File(baseDir, "notADir.tst");
1420            try {
1421                FileOutputStream fos = new FileOutputStream(file);
1422                fos.close();
1423                assertNull(
1424                        "listFiles Should Have Returned Null When Used On A File Instead Of A Directory.",
1425                        file.listFiles(dirFilter));
1426            } finally {
1427                file.delete();
1428            }
1429
1430            for (int i = 0; i < files.length; i++) {
1431                File f = new File(baseDir, files[i]);
1432                FileOutputStream fos = new FileOutputStream(f);
1433                fos.close();
1434            }
1435            dir1 = new File(baseDir, "Temp1");
1436            dir1.mkdir();
1437
1438            // Creating a filter that catches files.
1439            FileFilter fileFilter = new FileFilter() {
1440                public boolean accept(File f) {
1441                    return f.isFile();
1442                }
1443            };
1444
1445            // Test to see if the correct number of directories are returned.
1446            File[] directories = baseDir.listFiles(dirFilter);
1447            assertEquals("Incorrect Number Of Directories Returned.", 1,
1448                    directories.length);
1449
1450            // Test to see if the directory was saved with the correct name.
1451            assertEquals("Incorrect Directory Returned.", 0, directories[0]
1452                    .compareTo(dir1));
1453
1454            // Test to see if the correct number of files are returned.
1455            File[] flist = baseDir.listFiles(fileFilter);
1456            assertEquals("Incorrect Number Of Files Returned.",
1457                    files.length, flist.length);
1458
1459            // Checking to make sure the correct files were are listed in the
1460            // array.
1461            boolean[] check = new boolean[flist.length];
1462            for (int i = 0; i < check.length; i++) {
1463                check[i] = false;
1464            }
1465            for (int i = 0; i < files.length; i++) {
1466                for (int j = 0; j < flist.length; j++) {
1467                    if (flist[j].getName().equals(files[i])) {
1468                        check[i] = true;
1469                        break;
1470                    }
1471                }
1472            }
1473            int checkCount = 0;
1474            for (int i = 0; i < check.length; i++) {
1475                if (check[i] == false) {
1476                    checkCount++;
1477                }
1478            }
1479            assertEquals("Invalid file returned in listing", 0, checkCount);
1480
1481            for (int i = 0; i < files.length; i++) {
1482                File f = new File(baseDir, files[i]);
1483                f.delete();
1484            }
1485            dir1.delete();
1486            assertTrue("Parent Directory Not Deleted.", baseDir.delete());
1487        } finally {
1488            for (int i = 0; i < files.length; i++) {
1489                File f = new File(baseDir, files[i]);
1490                f.delete();
1491            }
1492            if (dir1 != null) {
1493                dir1.delete();
1494            }
1495            baseDir.delete();
1496        }
1497    }
1498
1499    /**
1500     * java.io.File#listFiles(java.io.FilenameFilter)
1501     */
1502    public void test_listFilesLjava_io_FilenameFilter() throws IOException {
1503        String base = System.getProperty("java.io.tmpdir");
1504        // Finding a non-existent directory to create.
1505        int dirNumber = 1;
1506        boolean dirExists = true;
1507        File dir = new File(base, platformId + String.valueOf(dirNumber));
1508        // Making sure that the directory does not exist.
1509        while (dirExists) {
1510            // If the directory exists, add one to the directory number (making
1511            // it a new directory name.)
1512            if (dir.exists()) {
1513                dirNumber++;
1514                dir = new File(base, platformId + String.valueOf(dirNumber));
1515            } else {
1516                dirExists = false;
1517            }
1518        }
1519
1520        // Creating a filter that catches "*.tst" files.
1521        FilenameFilter tstFilter = new FilenameFilter() {
1522            public boolean accept(File f, String fileName) {
1523                return fileName.endsWith(".tst");
1524            }
1525        };
1526
1527        assertNull("listFiles Should Return Null.", dir.listFiles(tstFilter));
1528
1529        assertTrue("Failed To Create Parent Directory.", dir.mkdir());
1530
1531        String[] files = { "1.tst", "2.tst", "3.tmp" };
1532        try {
1533            assertEquals("listFiles Should Return An Array Of Length 0.", 0,
1534                    dir.listFiles(tstFilter).length);
1535
1536            File file = new File(dir, "notADir.tst");
1537            try {
1538                FileOutputStream fos = new FileOutputStream(file);
1539                fos.close();
1540                assertNull(
1541                        "listFiles Should Have Returned Null When Used On A File Instead Of A Directory.",
1542                        file.listFiles(tstFilter));
1543            } finally {
1544                file.delete();
1545            }
1546
1547            for (int i = 0; i < files.length; i++) {
1548                File f = new File(dir, files[i]);
1549                FileOutputStream fos = new FileOutputStream(f);
1550                fos.close();
1551            }
1552
1553            // Creating a filter that catches "*.tmp" files.
1554            FilenameFilter tmpFilter = new FilenameFilter() {
1555                public boolean accept(File f, String fileName) {
1556                    // If the suffix is ".tmp" then send it to the array
1557                    if (fileName.endsWith(".tmp")) {
1558                        return true;
1559                    } else {
1560                        return false;
1561                    }
1562                }
1563            };
1564
1565            // Tests to see if the correct number of files were returned.
1566            File[] flist = dir.listFiles(tstFilter);
1567            assertEquals("Incorrect Number Of Files Passed Through tstFilter.",
1568                    2, flist.length);
1569            for (int i = 0; i < flist.length; i++) {
1570                assertTrue("File Should Not Have Passed The tstFilter.",
1571                        flist[i].getPath().endsWith(".tst"));
1572            }
1573
1574            flist = dir.listFiles(tmpFilter);
1575            assertEquals("Incorrect Number Of Files Passed Through tmpFilter.",
1576                    1, flist.length);
1577            assertTrue("File Should Not Have Passed The tmpFilter.", flist[0]
1578                    .getPath().endsWith(".tmp"));
1579
1580            for (int i = 0; i < files.length; i++) {
1581                File f = new File(dir, files[i]);
1582                f.delete();
1583            }
1584            assertTrue("Parent Directory Not Deleted.", dir.delete());
1585        } finally {
1586            for (int i = 0; i < files.length; i++) {
1587                File f = new File(dir, files[i]);
1588                f.delete();
1589            }
1590            dir.delete();
1591        }
1592    }
1593
1594    /**
1595     * java.io.File#list(java.io.FilenameFilter)
1596     */
1597    public void test_listLjava_io_FilenameFilter() throws IOException {
1598        String base = tempDirectory.getPath();
1599        // Old test left behind "garbage files" so this time it creates a
1600        // directory that is guaranteed not to already exist (and deletes it
1601        // afterward.)
1602        int dirNumber = 1;
1603        boolean dirExists = true;
1604        File dir = new File(base, platformId + String.valueOf(dirNumber));
1605        while (dirExists) {
1606            if (dir.exists()) {
1607                dirNumber++;
1608                dir = new File(base, String.valueOf(dirNumber));
1609            } else {
1610                dirExists = false;
1611            }
1612        }
1613
1614        FilenameFilter filter = new FilenameFilter() {
1615            public boolean accept(File dir, String name) {
1616                return !name.equals("mtzz1.xx");
1617            }
1618        };
1619
1620        String[] flist = dir.list(filter);
1621        assertNull("Method list(FilenameFilter) Should Have Returned Null.",
1622                flist);
1623
1624        assertTrue("Could not create parent directory for test", dir.mkdir());
1625
1626        String[] files = { "mtzz1.xx", "mtzz2.xx", "mtzz3.yy", "mtzz4.yy" };
1627        try {
1628            /*
1629             * Do not return null when trying to use list(Filename Filter) on a
1630             * file rather than a directory. All other "list" methods return
1631             * null for this test case.
1632             */
1633            /*
1634             * File file = new File(dir, "notADir.tst"); try { FileOutputStream
1635             * fos = new FileOutputStream(file); fos.close(); } catch
1636             * (IOException e) { fail("Unexpected IOException During Test."); }
1637             * flist = dir.list(filter); assertNull("listFiles Should Have
1638             * Returned Null When Used On A File Instead Of A Directory.",
1639             * flist); file.delete();
1640             */
1641
1642            flist = dir.list(filter);
1643            assertEquals("Array Of Length 0 Should Have Returned.", 0,
1644                    flist.length);
1645
1646            for (int i = 0; i < files.length; i++) {
1647                File f = new File(dir, files[i]);
1648                FileOutputStream fos = new FileOutputStream(f);
1649                fos.close();
1650            }
1651
1652            flist = dir.list(filter);
1653
1654            assertEquals("Incorrect list returned", flist.length,
1655                    files.length - 1);
1656
1657            // Checking to make sure the correct files were are listed in the
1658            // array.
1659            boolean[] check = new boolean[flist.length];
1660            for (int i = 0; i < check.length; i++) {
1661                check[i] = false;
1662            }
1663            String[] wantedFiles = { "mtzz2.xx", "mtzz3.yy", "mtzz4.yy" };
1664            for (int i = 0; i < wantedFiles.length; i++) {
1665                for (int j = 0; j < flist.length; j++) {
1666                    if (flist[j].equals(wantedFiles[i])) {
1667                        check[i] = true;
1668                        break;
1669                    }
1670                }
1671            }
1672            int checkCount = 0;
1673            for (int i = 0; i < check.length; i++) {
1674                if (check[i] == false) {
1675                    checkCount++;
1676                }
1677            }
1678            assertEquals("Invalid file returned in listing", 0, checkCount);
1679
1680            for (int i = 0; i < files.length; i++) {
1681                File f = new File(dir, files[i]);
1682                f.delete();
1683            }
1684            assertTrue("Could not delete parent directory for test.", dir
1685                    .delete());
1686        } finally {
1687            for (int i = 0; i < files.length; i++) {
1688                File f = new File(dir, files[i]);
1689                f.delete();
1690            }
1691            dir.delete();
1692        }
1693    }
1694
1695    /**
1696     * java.io.File#listRoots()
1697     */
1698    public void test_listRoots() {
1699        File[] roots = File.listRoots();
1700        boolean onUnix = File.separatorChar == '/';
1701        boolean onWindows = File.separatorChar == '\\';
1702        if (onUnix) {
1703            assertEquals("Incorrect Number Of Root Directories.", 1,
1704                    roots.length);
1705            String fileLoc = roots[0].getPath();
1706            assertTrue("Incorrect Root Directory Returned.", fileLoc
1707                    .startsWith(File.separator));
1708        } else if (onWindows) {
1709            // Need better test for Windows
1710            assertTrue("Incorrect Number Of Root Directories.",
1711                    roots.length > 0);
1712        }
1713    }
1714
1715    /**
1716     * java.io.File#mkdir()
1717     */
1718    public void test_mkdir() throws IOException {
1719        String base = tempDirectory.getPath();
1720        // Old test left behind "garbage files" so this time it creates a
1721        // directory that is guaranteed not to already exist (and deletes it
1722        // afterward.)
1723        int dirNumber = 1;
1724        boolean dirExists = true;
1725        File dir = new File(base, String.valueOf(dirNumber));
1726        while (dirExists) {
1727            if (dir.exists()) {
1728                dirNumber++;
1729                dir = new File(base, String.valueOf(dirNumber));
1730            } else {
1731                dirExists = false;
1732            }
1733        }
1734
1735        assertTrue("mkdir failed", dir.mkdir());
1736        assertTrue("mkdir worked but exists check failed", dir.exists());
1737        dir.deleteOnExit();
1738
1739        String longDirName = "abcdefghijklmnopqrstuvwx";// 24 chars
1740        String newbase = new String(dir + File.separator);
1741        StringBuilder sb = new StringBuilder(dir + File.separator);
1742        StringBuilder sb2 = new StringBuilder(dir + File.separator);
1743
1744        // Test make a long path
1745        while (dir.getCanonicalPath().length() < 256 - longDirName.length()) {
1746            sb.append(longDirName + File.separator);
1747            dir = new File(sb.toString());
1748            assertTrue("mkdir failed", dir.mkdir());
1749            assertTrue("mkdir worked but exists check failed", dir.exists());
1750            dir.deleteOnExit();
1751        }
1752
1753        while (dir.getCanonicalPath().length() < 256) {
1754            sb.append(0);
1755            dir = new File(sb.toString());
1756            assertTrue("mkdir " + dir.getCanonicalPath().length() + " failed",
1757                    dir.mkdir());
1758            assertTrue("mkdir " + dir.getCanonicalPath().length()
1759                    + " worked but exists check failed", dir.exists());
1760            dir.deleteOnExit();
1761        }
1762        dir = new File(sb2.toString());
1763        // Test make many paths
1764        while (dir.getCanonicalPath().length() < 256) {
1765            sb2.append(0);
1766            dir = new File(sb2.toString());
1767            assertTrue("mkdir " + dir.getCanonicalPath().length() + " failed",
1768                    dir.mkdir());
1769            assertTrue("mkdir " + dir.getCanonicalPath().length()
1770                    + " worked but exists check failed", dir.exists());
1771            dir.deleteOnExit();
1772        }
1773
1774        // Regression test for HARMONY-3656
1775        String[] ss = { "dir\u3400", "abc", "abc@123", "!@#$%^&",
1776                "~\u4E00!\u4E8C@\u4E09$", "\u56DB\u4E94\u516D",
1777                "\u4E03\u516B\u4E5D" };
1778        for (int i = 0; i < ss.length; i++) {
1779            dir = new File(newbase, ss[i]);
1780            assertTrue("mkdir " + dir.getCanonicalPath() + " failed",
1781                    dir.mkdir());
1782            assertTrue("mkdir " + dir.getCanonicalPath()
1783                    + " worked but exists check failed",
1784                    dir.exists());
1785            dir.deleteOnExit();
1786        }
1787    }
1788
1789    /**
1790     * java.io.File#mkdir()
1791     * <p/>
1792     * HARMONY-6041
1793     */
1794    public void test_mkdir_special_unicode() throws IOException {
1795        File specialDir = new File(this.tempDirectory, "\u5C73");
1796        int i = 0;
1797        while (specialDir.exists()) {
1798            specialDir = new File("\u5C73" + i);
1799            ++i;
1800        }
1801        assertFalse(specialDir.exists());
1802        assertTrue(specialDir.mkdir());
1803        assertTrue(specialDir.exists());
1804    }
1805
1806    /**
1807     * java.io.File#mkdirs()
1808     */
1809    public void test_mkdirs() {
1810        String userHome = addTrailingSlash(tempDirectory.getPath());
1811        File f = new File(userHome + "mdtest" + platformId + File.separator + "mdtest2",
1812                "p.tst");
1813        File g = new File(userHome + "mdtest" + platformId + File.separator + "mdtest2");
1814        File h = new File(userHome + "mdtest" + platformId);
1815        f.mkdirs();
1816        try {
1817            assertTrue("Base Directory not created", h.exists());
1818            assertTrue("Directories not created", g.exists());
1819            assertTrue("File not created", f.exists());
1820        } finally {
1821            f.delete();
1822            g.delete();
1823            h.delete();
1824        }
1825    }
1826
1827    /**
1828     * java.io.File#renameTo(java.io.File)
1829     */
1830    public void test_renameToLjava_io_File() throws IOException {
1831        String base = tempDirectory.getPath();
1832        File dir = new File(base, platformId);
1833        dir.mkdir();
1834        File f = new File(dir, "xxx.xxx");
1835        File rfile = new File(dir, "yyy.yyy");
1836        File f2 = new File(dir, "zzz.zzz");
1837        try {
1838            FileOutputStream fos = new FileOutputStream(f);
1839            fos.write(fileString.getBytes());
1840            fos.close();
1841            long lengthOfFile = f.length();
1842
1843            rfile.delete(); // in case it already exists
1844
1845            assertTrue("Test 1: File Rename Failed", f.renameTo(rfile));
1846            assertTrue("Test 2: File Rename Failed.", rfile.exists());
1847            assertEquals("Test 3: Size Of File Changed.",
1848                    lengthOfFile, rfile.length());
1849
1850            fos = new FileOutputStream(rfile);
1851            fos.close();
1852
1853            f2.delete(); // in case it already exists
1854            assertTrue("Test 4: File Rename Failed", rfile.renameTo(f2));
1855            assertTrue("Test 5: File Rename Failed.", f2.exists());
1856        } finally {
1857            f.delete();
1858            rfile.delete();
1859            f2.delete();
1860            dir.delete();
1861        }
1862    }
1863
1864    /**
1865     * java.io.File#setLastModified(long)
1866     */
1867    public void test_setLastModifiedJ() throws IOException {
1868        File f1 = null;
1869        try {
1870            f1 = File.createTempFile("harmony-test-FileTest_setLastModified", ".tmp");
1871            long orgTime = f1.lastModified();
1872            // Subtracting 100 000 milliseconds from the orgTime of File f1
1873            f1.setLastModified(orgTime - 100000);
1874            long lastModified = f1.lastModified();
1875            assertEquals("Test 1: LastModifed time incorrect",
1876                    orgTime - 100000, lastModified);
1877            // Subtracting 10 000 000 milliseconds from the orgTime of File f1
1878            f1.setLastModified(orgTime - 10000000);
1879            lastModified = f1.lastModified();
1880            assertEquals("Test 2: LastModifed time incorrect",
1881                    orgTime - 10000000, lastModified);
1882            // Adding 100 000 milliseconds to the orgTime of File f1
1883            f1.setLastModified(orgTime + 100000);
1884            lastModified = f1.lastModified();
1885            assertEquals("Test 3: LastModifed time incorrect",
1886                    orgTime + 100000, lastModified);
1887            // Adding 10 000 000 milliseconds from the orgTime of File f1
1888            f1.setLastModified(orgTime + 10000000);
1889            lastModified = f1.lastModified();
1890            assertEquals("Test 4: LastModifed time incorrect",
1891                    orgTime + 10000000, lastModified);
1892            // Trying to set time to an exact number
1893            f1.setLastModified(315550800000L);
1894            lastModified = f1.lastModified();
1895            assertEquals("Test 5: LastModified time incorrect",
1896                    315550800000L, lastModified);
1897            String osName = System.getProperty("os.name", "unknown");
1898            if (osName.equals("Windows 2000") || osName.equals("Windows NT")) {
1899                // Trying to set time to a large exact number
1900                boolean result = f1.setLastModified(4354837199000L);
1901                long next = f1.lastModified();
1902                // Dec 31 23:59:59 EST 2107 is overflow on FAT file systems, and
1903                // the call fails
1904                if (result) {
1905                    assertEquals("Test 6: LastModified time incorrect",
1906                            4354837199000L, next);
1907                }
1908            }
1909            // Trying to set time to a negative number
1910            try {
1911                f1.setLastModified(-25);
1912                fail("IllegalArgumentException Not Thrown.");
1913            } catch (IllegalArgumentException e) {
1914            }
1915        } finally {
1916            if (f1 != null) {
1917                f1.delete();
1918            }
1919        }
1920    }
1921
1922    /**
1923     * java.io.File#setReadOnly()
1924     */
1925    public void test_setReadOnly() throws Exception {
1926        File f1 = null;
1927        File f2 = null;
1928        if (Libcore.os.getuid() == 0) {
1929            System.err.println("Skipping #test_setReadOnly: test runner is root");
1930            return;
1931        }
1932
1933        try {
1934            f1 = File.createTempFile("harmony-test-FileTest_setReadOnly", ".tmp");
1935            f2 = File.createTempFile("harmony-test-FileTest_setReadOnly", ".tmp");
1936            // Assert is flawed because canWrite does not work.
1937            // assertTrue("File f1 Is Set To ReadOnly." , f1.canWrite());
1938            assertTrue(f1.setReadOnly());
1939            assertFalse(f1.canWrite());
1940            // Assert is flawed because canWrite does not work.
1941            // assertTrue("File f1 Is Not Set To ReadOnly." , !f1.canWrite());
1942            try {
1943                // Attempt to write to a file that is setReadOnly.
1944                new FileOutputStream(f1);
1945                fail("IOException not thrown.");
1946            } catch (IOException e) {
1947                // Expected
1948            }
1949
1950            Libcore.os.chmod(f1.getAbsolutePath(), 666);
1951
1952            // Assert is flawed because canWrite does not work.
1953            // assertTrue("File f1 Is Set To ReadOnly." , f1.canWrite());
1954            FileOutputStream fos = new FileOutputStream(f1);
1955            fos.write(fileString.getBytes());
1956            fos.close();
1957            assertEquals(fileString.length(), f1.length());
1958            assertTrue(f1.delete());
1959
1960            // Assert is flawed because canWrite does not work.
1961            // assertTrue("File f2 Is Set To ReadOnly." , f2.canWrite());
1962            fos = new FileOutputStream(f2);
1963            // Write to a file.
1964            fos.write(fileString.getBytes());
1965            fos.close();
1966            f2.setReadOnly();
1967            // Assert is flawed because canWrite does not work.
1968            // assertTrue("File f2 Is Not Set To ReadOnly." , !f2.canWrite());
1969            try {
1970                // Attempt to write to a file that has previously been written
1971                // to.
1972                // and is now set to read only.
1973                fos = new FileOutputStream(f2);
1974                fail("IOException not thrown.");
1975            } catch (IOException e) {
1976                // Expected
1977            }
1978
1979            Libcore.os.chmod(f2.getAbsolutePath(), 666);
1980            assertTrue(f2.canWrite());
1981            fos = new FileOutputStream(f2);
1982            fos.write(fileString.getBytes());
1983            fos.close();
1984            f2.setReadOnly();
1985            assertTrue(f2.delete());
1986
1987            // Similarly, trying to delete a read-only directory should succeed
1988            f2 = new File(tempDirectory, "deltestdir");
1989            f2.mkdir();
1990            f2.setReadOnly();
1991            assertTrue("Directory f2 Did Not Delete", f2.delete());
1992            assertTrue("Directory f2 Did Not Delete", !f2.exists());
1993        } finally {
1994            if (f1 != null) {
1995                f1.delete();
1996            }
1997            if (f2 != null) {
1998                f2.delete();
1999            }
2000        }
2001    }
2002
2003    /**
2004     * java.io.File#toString()
2005     */
2006    public void test_toString() {
2007        String fileName = System.getProperty("user.home");
2008        if (!fileName.endsWith(File.separator)) {
2009            fileName += File.separator;
2010        }
2011        fileName += "input.tst";
2012        File f = new File(fileName);
2013        assertEquals("Incorrect string returned", fileName, f.toString());
2014
2015        if (File.separatorChar == '\\') {
2016            String result = new File("c:\\").toString();
2017            assertEquals("Removed backslash", "c:\\", result);
2018        }
2019    }
2020
2021    /**
2022     * java.io.File#toURI()
2023     */
2024    public void test_toURI() throws URISyntaxException {
2025        // Need a directory that exists
2026        File dir = tempDirectory;
2027
2028        // Test for toURI when the file is a directory.
2029        String newURIPath = dir.getAbsolutePath();
2030        newURIPath = newURIPath.replace(File.separatorChar, '/');
2031        if (!newURIPath.startsWith("/")) {
2032            newURIPath = "/" + newURIPath;
2033        }
2034        if (!newURIPath.endsWith("/")) {
2035            newURIPath += '/';
2036        }
2037
2038        URI uri = dir.toURI();
2039        assertEquals("Test 1A: Incorrect URI Returned.", dir.getAbsoluteFile(), new File(uri));
2040        assertEquals("Test 1B: Incorrect URI Returned.",
2041                new URI("file", null, newURIPath, null, null), uri);
2042
2043        // Test for toURI with a file name with illegal chars.
2044        File f = new File(dir, "te% \u20ac st.tst");
2045        newURIPath = f.getAbsolutePath();
2046        newURIPath = newURIPath.replace(File.separatorChar, '/');
2047        if (!newURIPath.startsWith("/")) {
2048            newURIPath = "/" + newURIPath;
2049        }
2050
2051        uri = f.toURI();
2052        assertEquals("Test 2A: Incorrect URI Returned.",
2053                f.getAbsoluteFile(), new File(uri));
2054        assertEquals("Test 2B: Incorrect URI Returned.",
2055                new URI("file", null, newURIPath, null, null), uri);
2056
2057        // Regression test for HARMONY-3207
2058        dir = new File(""); // current directory
2059        uri = dir.toURI();
2060        assertTrue("Test current dir: URI does not end with slash.", uri
2061                .toString().endsWith("/"));
2062    }
2063
2064    /**
2065     * java.io.File#toURL()
2066     */
2067    public void test_toURL() throws MalformedURLException {
2068        // Need a directory that exists
2069        File dir = tempDirectory;
2070
2071        // Test for toURL when the file is a directory.
2072        String newDirURL = dir.getAbsolutePath();
2073        newDirURL = newDirURL.replace(File.separatorChar, '/');
2074        if (newDirURL.startsWith("/")) {
2075            newDirURL = "file://" + newDirURL;
2076        } else {
2077            newDirURL = "file:///" + newDirURL;
2078        }
2079        if (!newDirURL.endsWith("/")) {
2080            newDirURL += '/';
2081        }
2082        assertEquals("Test 1: Incorrect URL Returned.",
2083                dir.toURL().toString(), newDirURL);
2084
2085        // Test for toURL with a file.
2086        File f = new File(dir, "test.tst");
2087        String newURL = f.getAbsolutePath();
2088        newURL = newURL.replace(File.separatorChar, '/');
2089        if (newURL.startsWith("/")) {
2090            newURL = "file://" + newURL;
2091        } else {
2092            newURL = "file:///" + newURL;
2093        }
2094        assertEquals("Test 2: Incorrect URL Returned.",
2095                f.toURL().toString(), newURL);
2096
2097        // Regression test for HARMONY-3207
2098        dir = new File(""); // current directory
2099        newDirURL = dir.toURL().toString();
2100        assertTrue("Test current dir: URL does not end with slash.", newDirURL
2101                .endsWith("/"));
2102    }
2103
2104    /**
2105     * java.io.File#toURI()
2106     */
2107    public void test_toURI2() throws URISyntaxException {
2108        File f = new File(tempDirectory, "a/b/c/../d/e/./f");
2109
2110        String path = f.getAbsolutePath();
2111        path = path.replace(File.separatorChar, '/');
2112        if (!path.startsWith("/")) {
2113            path = "/" + path;
2114        }
2115
2116        URI uri1 = new URI("file", null, path, null);
2117        URI uri2 = f.toURI();
2118        assertEquals("uris not equal", uri1, uri2);
2119    }
2120
2121    /**
2122     * java.io.File#toURL()
2123     */
2124    public void test_toURL2() throws MalformedURLException {
2125        File f = new File(tempDirectory, "a/b/c/../d/e/./f");
2126
2127        String path = f.getAbsolutePath();
2128        path = path.replace(File.separatorChar, '/');
2129        if (!path.startsWith("/")) {
2130            path = "/" + path;
2131        }
2132
2133        URL url1 = new URL("file", "", path);
2134        URL url2 = f.toURL();
2135        assertEquals("urls not equal", url1, url2);
2136    }
2137
2138    /**
2139     * serialization
2140     */
2141    public void test_objectStreamClass_getFields() throws Exception {
2142        // Regression for HARMONY-2674
2143        ObjectStreamClass objectStreamClass = ObjectStreamClass
2144                .lookup(File.class);
2145        ObjectStreamField[] objectStreamFields = objectStreamClass.getFields();
2146        assertEquals(1, objectStreamFields.length);
2147        ObjectStreamField objectStreamField = objectStreamFields[0];
2148        assertEquals("path", objectStreamField.getName());
2149        assertEquals(String.class, objectStreamField.getType());
2150    }
2151
2152    // Regression test for HARMONY-4493
2153    public void test_list_withUnicodeFileName() throws Exception {
2154        File rootDir = new File(System.getProperty("java.io.tmpdir")).getAbsoluteFile();
2155        String dirName = new String("src\u3400");
2156        File dir = new File(rootDir, dirName);
2157        if (!dir.exists()) {
2158            dir.mkdir();
2159            dir.deleteOnExit();
2160        }
2161        boolean exist = false;
2162        String[] fileNames = rootDir.list();
2163        for (String fileName : fileNames) {
2164            if (dirName.equals(fileName)) {
2165                exist = true;
2166                break;
2167            }
2168        }
2169        assertTrue(exist);
2170    }
2171
2172    /**
2173     * serialization/deserialization.
2174     */
2175    public void test_serialization_self() throws Exception {
2176        File testFile = new File("test.ser");
2177        SerializationTest.verifySelf(testFile);
2178    }
2179
2180    /**
2181     * serialization/deserialization compatibility with RI.
2182     */
2183    public void test_serialization_compatibility() throws Exception {
2184        File file = new File("FileTest.golden.ser");
2185        SerializationTest.verifyGolden(this, file);
2186    }
2187}
2188