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 18 package org.apache.harmony.luni.tests.java.io; 19 20 import java.io.BufferedReader; 21 import java.io.File; 22 import java.io.FileInputStream; 23 import java.io.IOException; 24 import java.io.InputStream; 25 import java.io.InputStreamReader; 26 import java.util.concurrent.Callable; 27 28 import tests.support.resource.Support_Resources; 29 30 import junit.framework.AssertionFailedError; 31 import junit.framework.TestCase; 32 33 import libcore.io.Libcore; 34 import android.system.StructStatVfs; 35 36 37 /** 38 * Please note that this case can only be passed on Linux due to some file 39 * system dependent reason. 40 */ 41 public class UnixFileTest extends TestCase { 42 private boolean root = false; 43 44 private File testFile; 45 46 private File testDir; 47 48 private static final int TOTAL_SPACE_NUM = 0; 49 50 private static final int FREE_SPACE_NUM = 1; 51 52 private static final int USABLE_SPACE_NUM = 2; 53 54 private static class ConsoleResulter extends Thread { 55 Process proc; 56 57 InputStream is; 58 59 String resStr; 60 ConsoleResulter(Process p, InputStream in)61 ConsoleResulter(Process p, InputStream in) { 62 proc = p; 63 is = in; 64 } 65 66 @Override run()67 public void run() { 68 StringBuffer result = new StringBuffer(); 69 synchronized (result) { 70 try { 71 BufferedReader br = new BufferedReader( 72 new InputStreamReader(is)); 73 String line; 74 while ((line = br.readLine()) != null) { 75 result.append(line); 76 } 77 if (result.length() != 0) { 78 resStr = result.toString(); 79 } 80 81 br.close(); 82 } catch (IOException ioe) { 83 result = null; 84 } 85 synchronized (proc) { 86 proc.notifyAll(); 87 } 88 } 89 } 90 } 91 getLinuxSpace(int index, File file)92 private static long getLinuxSpace(int index, File file) throws Exception { 93 StructStatVfs stat = Libcore.os.statvfs(file.getAbsolutePath()); 94 switch (index) { 95 case TOTAL_SPACE_NUM: 96 return stat.f_frsize * stat.f_blocks; 97 case FREE_SPACE_NUM: 98 return stat.f_frsize * stat.f_bfree; 99 case USABLE_SPACE_NUM: 100 return stat.f_frsize * stat.f_bavail; 101 } 102 throw new IllegalArgumentException("Unknown index: " + index); 103 } 104 105 /** 106 * Asserts that {@code fn} completes without {@link AssertionFailedError failing} 107 * at least once when run up to {@code retries} times. 108 */ assertAtLeastOnce(int retries, Callable<Void> fn)109 private static void assertAtLeastOnce(int retries, Callable<Void> fn) throws Exception { 110 assertTrue(retries > 0); 111 for (int i = 0; i < retries; i++) { 112 try { 113 fn.call(); 114 break; 115 } catch (AssertionFailedError e) { 116 if (i == retries - 1) { 117 throw e; 118 } 119 } 120 } 121 } 122 123 /** 124 * @tests java.io.File#canExecute() 125 * @since 1.6 126 */ test_canExecute()127 public void test_canExecute() { 128 assertFalse(testFile.canExecute()); 129 assertTrue(testFile.setExecutable(true, false)); 130 assertTrue(testFile.canExecute()); 131 assertTrue(testFile.setExecutable(true, true)); 132 assertTrue(testFile.canExecute()); 133 134 assertTrue(testFile.setExecutable(false, false)); 135 assertFalse(testFile.canExecute()); 136 assertTrue(testFile.setExecutable(false, true)); 137 assertFalse(testFile.canExecute()); 138 139 assertTrue(testFile.setExecutable(true, false)); 140 assertTrue(testFile.canExecute()); 141 142 // tests directory 143 assertTrue(testDir.canExecute()); 144 assertTrue(testDir.setExecutable(false, true)); 145 if (root) { 146 assertTrue(testDir.canExecute()); 147 } else { 148 assertFalse(testDir.canExecute()); 149 } 150 assertTrue(testDir.setExecutable(true, false)); 151 assertTrue(testDir.canExecute()); 152 } 153 154 /** 155 * @tests java.io.File#getFreeSpace() 156 * @since 1.6 157 */ test_getFreeSpace()158 public void test_getFreeSpace() throws Exception { 159 assertAtLeastOnce(3, () -> { 160 long fileSpace = getLinuxSpace(FREE_SPACE_NUM, testFile); 161 // in case we cannot fetch the value from command line 162 if (fileSpace > 0) { 163 assertEquals(fileSpace, testFile.getFreeSpace()); 164 } 165 return null; 166 }); 167 168 assertAtLeastOnce(3, () -> { 169 long dirSpace = getLinuxSpace(FREE_SPACE_NUM, testDir); 170 // in case we cannot fetch the value from command line 171 if (dirSpace > 0) { 172 assertEquals(dirSpace, testDir.getFreeSpace()); 173 } 174 return null; 175 }); 176 } 177 178 /** 179 * @tests java.io.File#getTotalSpace() 180 * @since 1.6 181 */ test_getTotalSpace()182 public void test_getTotalSpace() throws Exception { 183 long fileSpace = getLinuxSpace(TOTAL_SPACE_NUM, testFile); 184 long dirSpace = getLinuxSpace(TOTAL_SPACE_NUM, testDir); 185 if (fileSpace > 0) { 186 assertEquals(fileSpace, testFile.getTotalSpace()); 187 } 188 if (dirSpace > 0) { 189 assertEquals(dirSpace, testDir.getTotalSpace()); 190 } 191 } 192 193 /** 194 * @tests java.io.File#getUsableSpace() 195 * @since 1.6 196 */ test_getUsableSpace()197 public void test_getUsableSpace() throws Exception { 198 assertAtLeastOnce(3, () -> { 199 long fileSpace = getLinuxSpace(USABLE_SPACE_NUM, testFile); 200 if (fileSpace > 0) { 201 assertEquals(fileSpace, testFile.getUsableSpace()); 202 } 203 return null; 204 }); 205 206 assertAtLeastOnce(3, () -> { 207 long dirSpace = getLinuxSpace(USABLE_SPACE_NUM, testDir); 208 if (dirSpace > 0) { 209 assertEquals(dirSpace, testDir.getUsableSpace()); 210 } 211 return null; 212 }); 213 } 214 215 /** 216 * @tests java.io.File#setExecutable(boolean, boolean) 217 * @since 1.6 218 */ test_setExecutableZZ()219 public void test_setExecutableZZ() { 220 // setExecutable(true, true/false) 221 assertFalse(testFile.canExecute()); 222 assertTrue(testFile.setExecutable(true, false)); 223 assertTrue(testFile.canExecute()); 224 assertTrue(testFile.setExecutable(true, true)); 225 assertTrue(testFile.canExecute()); 226 227 // setExecutable(false, true/false) 228 assertTrue(testFile.setExecutable(false, true)); 229 if (root) { 230 assertTrue(testFile.canExecute()); 231 } else { 232 assertFalse(testFile.canExecute()); 233 } 234 assertTrue(testFile.setExecutable(false, false)); 235 assertFalse(testFile.canExecute()); 236 237 // tests directory 238 assertTrue(testDir.canExecute()); 239 assertTrue(testDir.setExecutable(false, true)); 240 if (root) { 241 assertTrue(testDir.canExecute()); 242 } else { 243 assertFalse(testDir.canExecute()); 244 } 245 assertTrue(testDir.setExecutable(false, false)); 246 if (root) { 247 assertTrue(testDir.canExecute()); 248 } else { 249 assertFalse(testDir.canExecute()); 250 } 251 252 assertTrue(testDir.setExecutable(true, true)); 253 assertTrue(testDir.canExecute()); 254 assertTrue(testDir.setExecutable(true, false)); 255 assertTrue(testDir.canExecute()); 256 } 257 258 /** 259 * @tests java.io.File#setExecutable(boolean) 260 * @since 1.6 261 */ test_setExecutableZ()262 public void test_setExecutableZ() { 263 // So far this method only deals with the situation that the user is the 264 // owner of the file 265 assertTrue(testFile.setExecutable(true)); 266 assertTrue(testFile.canExecute()); 267 assertTrue(testFile.setExecutable(false)); 268 assertFalse(testFile.canExecute()); 269 assertTrue(testFile.setExecutable(true)); 270 271 // tests directory 272 assertTrue(testDir.canExecute()); 273 assertTrue(testDir.setExecutable(false)); 274 if (root) { 275 assertTrue(testDir.canExecute()); 276 } else { 277 assertFalse(testDir.canExecute()); 278 } 279 assertTrue(testDir.setExecutable(true)); 280 assertTrue(testDir.canExecute()); 281 } 282 283 /** 284 * @tests java.io.File#setReadable(boolean, boolean) 285 * @since 1.6 286 */ test_setReadableZZ()287 public void test_setReadableZZ() throws Exception { 288 // setReadable(false, false/true) succeeds on Linux 289 // However, canRead() always returns true when the user is 'root'. 290 assertTrue(testFile.canRead()); 291 assertTrue(testFile.setReadable(false, false)); 292 if (root) { 293 assertTrue(testFile.canRead()); 294 } else { 295 assertFalse(testFile.canRead()); 296 } 297 assertTrue(testFile.setReadable(false, true)); 298 if (root) { 299 assertTrue(testFile.canRead()); 300 } else { 301 assertFalse(testFile.canRead()); 302 } 303 304 // tests directory, setReadable(false, true/false) 305 assertTrue(testDir.canRead()); 306 assertTrue(testDir.setReadable(false, true)); 307 if (root) { 308 assertTrue(testDir.canRead()); 309 } else { 310 assertFalse(testDir.canRead()); 311 } 312 assertTrue(testDir.setReadable(false, false)); 313 if (root) { 314 assertTrue(testDir.canRead()); 315 } else { 316 assertFalse(testDir.canRead()); 317 } 318 319 // setReadable(true, false/true) and set them in turn 320 assertTrue(testFile.setReadable(true, false)); 321 assertTrue(testFile.canRead()); 322 assertTrue(testFile.setReadable(false, true)); 323 if (root) { 324 assertTrue(testFile.canRead()); 325 } else { 326 assertFalse(testFile.canRead()); 327 } 328 assertTrue(testFile.setReadable(true, true)); 329 assertTrue(testFile.canRead()); 330 assertTrue(testFile.setReadable(false, true)); 331 if (root) { 332 assertTrue(testFile.canRead()); 333 } else { 334 assertFalse(testFile.canRead()); 335 } 336 337 // tests directory, setReadable(true, true/false) 338 assertTrue(testDir.setReadable(true, false)); 339 assertTrue(testDir.canRead()); 340 assertTrue(testDir.setReadable(true, true)); 341 assertTrue(testDir.canRead()); 342 } 343 344 /** 345 * @tests java.io.File#setReadable(boolean) 346 * @since 1.6 347 */ test_setReadableZ()348 public void test_setReadableZ() { 349 // So far this method only deals with the situation that the user is the 350 // owner of the file. setReadable(false) succeeds on Linux 351 // However, canRead() always returns true when the user is 'root'. 352 assertTrue(testFile.canRead()); 353 assertTrue(testFile.setReadable(false)); 354 if (root) { 355 assertTrue(testFile.canRead()); 356 } else { 357 assertFalse(testFile.canRead()); 358 } 359 assertTrue(testFile.setReadable(true)); 360 assertTrue(testFile.canRead()); 361 362 assertTrue(testDir.canRead()); 363 assertTrue(testDir.setReadable(false)); 364 if (root) { 365 assertTrue(testDir.canRead()); 366 } else { 367 assertFalse(testDir.canRead()); 368 } 369 } 370 371 @Override setUp()372 protected void setUp() throws Exception { 373 super.setUp(); 374 testFile = File.createTempFile("testfile", null); 375 testDir = new File(System.getProperty("java.io.tmpdir") + "/temp"); 376 if (!testDir.exists()) { 377 testDir.mkdir(); 378 } 379 root = false; //System.getProperty("user.name").equals("root"); 380 } 381 382 @Override tearDown()383 protected void tearDown() throws Exception { 384 testFile.delete(); 385 testDir.delete(); 386 testFile = null; 387 testDir = null; 388 root = false; 389 super.tearDown(); 390 } 391 test_getCanonicalPath()392 public void test_getCanonicalPath() throws Exception { 393 394 File tempFolder = Support_Resources.createTempFolder(); 395 File tmpFolder1 = new File(tempFolder, "folder1"); 396 tmpFolder1.deleteOnExit(); 397 398 File tmpFolder2 = new File(tmpFolder1.toString() + "/folder2"); 399 tmpFolder2.mkdirs(); 400 tmpFolder2.deleteOnExit(); 401 402 File tmpFolder3 = new File(tmpFolder2.toString() + "/folder3"); 403 tmpFolder3.mkdirs(); 404 tmpFolder3.deleteOnExit(); 405 406 File tmpFolder4 = new File(tmpFolder3.toString() + "/folder4"); 407 tmpFolder4.mkdirs(); 408 tmpFolder4.deleteOnExit(); 409 410 // make a link to folder1/folder2 411 String tempFolderAbsolutePath = tempFolder.getAbsolutePath(); 412 String target = tempFolderAbsolutePath + "/folder1/folder2"; 413 String linkName = tempFolderAbsolutePath + "/folder2"; 414 Libcore.os.symlink(target, linkName); 415 File linkFile = new File(tempFolder, "folder2"); 416 linkFile.deleteOnExit(); 417 418 File file = new File(tempFolder, "folder2"); 419 assertEquals(tmpFolder2.getCanonicalPath(), file.getCanonicalPath()); 420 421 file = new File(tempFolder, "folder1/folder2"); 422 assertEquals(tmpFolder2.getCanonicalPath(), file.getCanonicalPath()); 423 424 file = new File(tempFolder, "folder2/folder3"); 425 assertEquals(tmpFolder3.getCanonicalPath(), file.getCanonicalPath()); 426 427 file = new File(tempFolder, "folder2/folder3/folder4"); 428 assertEquals(tmpFolder4.getCanonicalPath(), file.getCanonicalPath()); 429 430 file = new File(tempFolder, "folder1/folder2/folder3"); 431 assertEquals(tmpFolder3.getCanonicalPath(), file.getCanonicalPath()); 432 433 file = new File(tempFolder, "folder1/folder2/folder3/folder4"); 434 assertEquals(tmpFolder4.getCanonicalPath(), file.getCanonicalPath()); 435 } 436 } 437