/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.vfs2.filter;
  
  import java.io.File;
  import java.io.IOException;
  import java.nio.file.Files;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.vfs2.FileFilter;
  import org.apache.commons.vfs2.FileFilterSelector;
  import org.apache.commons.vfs2.FileObject;
  import org.apache.commons.vfs2.FileSelectInfo;
  import org.apache.commons.vfs2.FileSystemException;
  import org.junit.AfterClass;
  import org.junit.Assert;
  import org.junit.Assume;
  import org.junit.BeforeClass;
  import org.junit.Test;
  
  /**
   * Test for {@link SymbolicLinkFileFilter}.
   * <p>
   * On Windows, in order for this test to pass, you MUST run the VM with admin rights.
   * </p>
   * <p>
   * To enable this test set the system property "SymbolicLinkFileFilterTest.Enable" to "true".
   *
   * <p>
   * To run only this test with Maven:
   * </p>
   *
   * <pre>
   * mvn test -Dtest=SymbolicLinkFileFilterTest -pl commons-vfs2 -DSymbolicLinkFileFilterTest.Enable=true
   * </pre>
   */
  // CHECKSTYLE:OFF Test code
  public class SymbolicLinkFileFilterTest extends BaseFilterTest {
  
      private static File testDir;
  
      private static File targetFile;
  
      private static FileSelectInfo targetFileInfo;
  
      private static File linkFile;
  
      private static FileSelectInfo linkFileInfo;
  
      private static File notExistingFile;
  
      private static FileSelectInfo notExistingFileInfo;
  
      private static File zipFile;
  
      private static FileObject zipFileObject;
  
      @AfterClass
      public static void afterClass() throws IOException {
          targetFile = null;
          targetFileInfo = null;
          linkFile = null;
          linkFileInfo = null;
          notExistingFile = null;
          notExistingFileInfo = null;
          if (zipFileObject != null) {
              zipFileObject.close();
          }
          if (zipFile != null) {
              FileUtils.deleteQuietly(zipFile);
              zipFile = null;
          }
          if (testDir != null) {
              FileUtils.deleteDirectory(testDir);
              testDir = null;
          }
      }
  
      @BeforeClass
      public static void beforeClass() throws IOException {
          Assume.assumeTrue(Boolean.getBoolean(SymbolicLinkFileFilterTest.class.getSimpleName() + ".Enable"));
  
          testDir = getTestDir(SymbolicLinkFileFilterTest.class.getName());
          testDir.mkdir();
  
         linkFile = new File(testDir, "visible.txt");
         linkFileInfo = createFileSelectInfo(linkFile);
 
         targetFile = new File(testDir, "symbolic.txt");
         Files.deleteIfExists(targetFile.toPath());
         FileUtils.touch(targetFile);
         Files.createSymbolicLink(linkFile.toPath(), targetFile.toPath());
         targetFileInfo = createFileSelectInfo(targetFile);
 
         notExistingFile = new File(testDir, "not-existing-file.txt");
         notExistingFileInfo = createFileSelectInfo(notExistingFile);
 
         // Zip the test directory
         zipFile = new File(getTempDir(), SymbolicLinkFileFilterTest.class.getName() + ".zip");
         zipDir(testDir, "", zipFile);
         zipFileObject = getZipFileObject(zipFile);
     }
 
     @Test
     public void testAcceptActual() throws FileSystemException {
         final FileFilter testee = SymbolicLinkFileFilter.ACTUAL;
         Assert.assertTrue(targetFileInfo.getBaseFolder().exists());
         Assert.assertTrue(targetFileInfo.getFile().exists());
         Assert.assertTrue(targetFileInfo.toString(), testee.accept(targetFileInfo));
         Assert.assertTrue(notExistingFileInfo.toString(), testee.accept(notExistingFileInfo));
     }
 
     @Test
     public void testAcceptSymbolic() throws FileSystemException {
         final FileFilter testee = SymbolicLinkFileFilter.SYMBOLIC;
         Assert.assertTrue(linkFileInfo.toString(), testee.accept(linkFileInfo));
         Assert.assertFalse(notExistingFileInfo.toString(), testee.accept(notExistingFileInfo));
     }
 
     @Test
     public void testZipFile() throws FileSystemException {
         final FileObject[] files = zipFileObject.findFiles(new FileFilterSelector(SymbolicLinkFileFilter.SYMBOLIC));
         Assert.assertEquals(0, files.length);
     }
 
 }
 // CHECKSTYLE:ON