test/com/google/enterprise/adaptor/fs/WindowsFileDelegateTest.java - plexi/fs - Git at Google

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed 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 com.google.enterprise.adaptor.fs;

 import static com.google.enterprise.adaptor.fs.AclView.user;
 import static com.google.enterprise.adaptor.fs.AclView.group;
 import static com.google.enterprise.adaptor.fs.AclView.GenericPermission.*;

 import static org.junit.Assert.*;
 import static org.junit.Assume.*;

 import static java.nio.file.attribute.AclEntryFlag.*;
 import static java.nio.file.attribute.AclEntryPermission.*;
 import static java.nio.file.attribute.AclEntryType.*;

 import com.google.common.base.Charsets;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Sets;
 import com.google.common.io.CharStreams;
 import com.google.enterprise.adaptor.Acl;
 import com.google.enterprise.adaptor.DocIdPusher;
 import com.google.enterprise.adaptor.fs.WinApi.Netapi32Ex;

 import org.junit.*;
 import org.junit.rules.ExpectedException;

 import com.sun.jna.Memory;
 import com.sun.jna.Native;
 import com.sun.jna.Pointer;
 import com.sun.jna.WString;
 import com.sun.jna.platform.win32.LMErr;
 import com.sun.jna.platform.win32.Win32Exception;
 import com.sun.jna.platform.win32.WinError;
 import com.sun.jna.platform.win32.WinNT;
 import com.sun.jna.platform.win32.WinDef.DWORD;
 import com.sun.jna.platform.win32.WinDef.ULONG;
 import com.sun.jna.ptr.IntByReference;
 import com.sun.jna.ptr.PointerByReference;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
 import java.nio.file.attribute.AclFileAttributeView;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.nio.file.attribute.FileTime;
 import java.util.Collections;
 import java.util.Set;

 /** Tests for {@link WindowsFileDelegate} */
 public class WindowsFileDelegateTest extends TestWindowsAclViews {

   @BeforeClass
   public static void checkIfRunningOnWindows() {
     TestHelper.assumeOsIsWindows();
   }

   private FileDelegate delegate = new WindowsFileDelegate();
   private AccumulatingAsyncDocIdPusher pusher =
       new AccumulatingAsyncDocIdPusher();
   private Path tempRoot;

   @Rule
   public ExpectedException thrown = ExpectedException.none();

   @Before
   public void setUp() throws Exception {
     tempRoot = getTempRoot();
   }

   @After
   public void tearDown() {
     delegate.destroy();
   }

   @Test
   public void testGetDfsShareAclView() throws Exception {
     // The *_OBJECT_ACE_TYPEs will get filtered out by newAclEntry().
     AclFileAttributeView expectedAcl = new AclView(
         group("AccessAllowedAce").type(ALLOW).perms(GENERIC_READ)
         .flags(FILE_INHERIT, DIRECTORY_INHERIT),
         user("AccessDeniedAce").type(DENY).perms(GENERIC_READ)
         .flags(FILE_INHERIT, DIRECTORY_INHERIT));

     AclFileAttributeView aclView = getDfsShareAclView(
         new AceBuilder()
         .setSid(AccountSid.group("AccessAllowedAce", null))
         .setType(WinNT.ACCESS_ALLOWED_ACE_TYPE)
         .setPerms(WinNT.GENERIC_READ)
         .setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
         .build(),
         new AceBuilder()
         .setSid(AccountSid.user("AccessAllowedObjectAce", null))
         .setType(WinNT.ACCESS_ALLOWED_OBJECT_ACE_TYPE)
         .setPerms(WinNT.GENERIC_ALL)
         .setFlags(WinNT.OBJECT_INHERIT_ACE)
         .build(),
         new AceBuilder()
         .setSid(AccountSid.user("AccessDeniedAce", null))
         .setType(WinNT.ACCESS_DENIED_ACE_TYPE)
         .setPerms(WinNT.GENERIC_READ)
         .setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
         .build(),
         new AceBuilder()
         .setSid(AccountSid.group("AccessDeniedObjectAce", null))
         .setType(WinNT.ACCESS_DENIED_OBJECT_ACE_TYPE)
         .setPerms(WinNT.GENERIC_ALL)
         .setFlags(WinNT.OBJECT_INHERIT_ACE)
         .build());

     assertNotNull(aclView);
     assertEquals(expectedAcl.getAcl(), aclView.getAcl());
   }

   @Test
   public void testGetDfsShareAclViewUnsupportedAceType() throws Exception {
     thrown.expect(IllegalArgumentException.class);
     AclFileAttributeView aclView = getDfsShareAclView(
         new AceBuilder()
         .setSid(AccountSid.group("SystemAuditAce", null))
         .setType(WinNT.SYSTEM_AUDIT_ACE_TYPE)
         .setPerms(WinNT.GENERIC_ALL)
         .setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
         .build());
   }

   private static AclFileAttributeView getDfsShareAclView(
       WinNT.ACCESS_ACEStructure... aces) throws Exception {
     byte[] dacl = buildDaclMemory(aces);
     final Memory memory = new Memory(dacl.length);
     memory.write(0, dacl, 0, dacl.length);

     Netapi32Ex netapi = new UnsupportedNetapi32() {
         @Override
         public int NetDfsGetSecurity(String dfsPath, int securityInfo,
             PointerByReference bufptr, IntByReference bufsz) {
           bufptr.setValue(memory);
           bufsz.setValue((int)(memory.size()));
           return WinError.ERROR_SUCCESS;
         }
         @Override
         public int NetApiBufferFree(Pointer buf) {
           return WinError.ERROR_SUCCESS;
         }
       };

     WindowsAclFileAttributeViews wafav =
         new TestAclFileAttributeViews(null, null, null, netapi, null);
     WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, wafav);

     return delegate.getDfsShareAclView(Paths.get("\\\\host\\share"));
   }

   @Test
   public void testGetDfsShareAclViewError() throws Exception {
     Netapi32Ex netapi = new UnsupportedNetapi32() {
         @Override
         public int NetDfsGetSecurity(String dfsPath, int securityInfo,
             PointerByReference bufptr, IntByReference bufsz) {
           return WinError.ERROR_ACCESS_DENIED;
         }
         @Override
         public int NetApiBufferFree(Pointer buf) {
           return WinError.ERROR_SUCCESS;
         }
       };

     WindowsAclFileAttributeViews wafav =
         new TestAclFileAttributeViews(null, null, null, netapi, null);
     WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, wafav);

     thrown.expect(Win32Exception.class);
     delegate.getDfsShareAclView(Paths.get("\\\\host\\share"));
   }

   @Test
   public void testGetDfsUncActiveStorageUncError() throws Exception {
     Netapi32Ex netapi = new UnsupportedNetapi32() {
         @Override
         public int NetDfsGetInfo(String dfsPath, String server, String share,
             int level, PointerByReference bufptr) {
           return WinError.ERROR_ACCESS_DENIED;
         }
       };
     assertNull(getDfsUncActiveStorageUnc(netapi));
   }

   @Test
   public void testGetDfsUncActiveStorageUncNoStorage() throws Exception {
     final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3();

     assertEquals(0, info.NumberOfStorages.intValue());
     thrown.expect(IOException.class);
     getDfsUncActiveStorageUnc(info);
   }

   @Test
   public void testGetDfsUncActiveStorageUncSingleActiveStorage()
       throws Exception {
     final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
         new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "server", "share"));

     assertEquals(1, info.NumberOfStorages.intValue());
     assertEquals(Paths.get("\\\\server\\share"),
                  getDfsUncActiveStorageUnc(info));
   }

   @Test
   public void testGetDfsUncActiveStorageUncNoActiveStorage() throws Exception {
     final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
         new Storage(0, "server", "share"));

     assertEquals(1, info.NumberOfStorages.intValue());
     thrown.expect(IOException.class);
     getDfsUncActiveStorageUnc(info);
   }

   @Test
   public void testGetDfsUncActiveStorageUncSomeActiveStorage()
       throws Exception {
     final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
         new Storage(0, "inactive", "inactive"),
         new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "server", "share"),
         new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "active", "active"));

     assertEquals(3, info.NumberOfStorages.intValue());
     assertEquals(Paths.get("\\\\server\\share"),
                  getDfsUncActiveStorageUnc(info));
   }

   private static Path getDfsUncActiveStorageUnc(
       final Netapi32Ex.DFS_INFO_3 info) throws Exception {
     Netapi32Ex netapi = new UnsupportedNetapi32() {
         @Override
         public int NetDfsGetInfo(String dfsPath, String server, String share,
             int level, PointerByReference bufptr) {
           bufptr.setValue(info.getPointer());
           return LMErr.NERR_Success;
         }
         @Override
         public int NetApiBufferFree(Pointer buf) {
           return WinError.ERROR_SUCCESS;
         }
       };

     return getDfsUncActiveStorageUnc(netapi);
   }

   private static Path getDfsUncActiveStorageUnc(Netapi32Ex netapi)
       throws Exception {
     WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, null);
     Path dfsPath = Paths.get("\\\\host\\share");
     return delegate.getDfsUncActiveStorageUnc(dfsPath);
   }

   @Test
   public void testNewDocIdLocalFiles() throws Exception {
     Path dir = newTempDir("testDir");
     Path file = newTempFile(dir, "test");

     String id = delegate.newDocId(tempRoot).getUniqueId();
     assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
     assertTrue(id.endsWith("/"));

     id = delegate.newDocId(dir).getUniqueId();
     assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
     assertTrue(id.startsWith(dir.toString().replace('\\', '/')));
     assertTrue(id.endsWith("/"));

     id = delegate.newDocId(file).getUniqueId();
     assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
     assertTrue(id.startsWith(dir.toString().replace('\\', '/')));
     assertTrue(id.equals(file.toString().replace('\\', '/')));
     assertFalse(id.endsWith("/"));
   }

   @Test
   public void testNewDocIdVirtualUncPaths() throws Exception {
     assertEquals("\\\\host/share",
         delegate.newDocId(Paths.get("\\\\host\\share")).getUniqueId());
     assertEquals("\\\\host/share",
         delegate.newDocId(Paths.get("\\\\host\\share\\")).getUniqueId());
     assertEquals("\\\\host/share/foo/bar",
         delegate.newDocId(Paths.get("\\\\host\\share\\foo\\bar"))
         .getUniqueId());
   }

   @Test
   public void testNewDocIdLocalUncPaths() throws Exception {
     String uncTempRoot = getTempRootAsUncPath();
     assumeNotNull(uncTempRoot);
     Path tempRoot = Paths.get(uncTempRoot);
     String expectedTempRootId = "\\\\" + uncTempRoot.substring(2)
         .replace('\\', '/') + "/";

     assertEquals(expectedTempRootId,
         delegate.newDocId(tempRoot).getUniqueId());

     newTempDir("testDir");
     assertEquals(expectedTempRootId + "testDir/",
         delegate.newDocId(tempRoot.resolve("testDir")).getUniqueId());

     newTempFile("test");
     assertEquals(expectedTempRootId + "test",
         delegate.newDocId(tempRoot.resolve("test")).getUniqueId());
   }

   private String getTempRootAsUncPath() throws IOException {
     String tempPath = temp.getRoot().getCanonicalPath();
     if (tempPath.length() > 2 && tempPath.charAt(1) == ':') {
       String uncPath = "\\\\localhost\\" + tempPath.substring(0, 1) + "$"
           + tempPath.substring(2);
       try {
         // Now verify we have access to the local administrative share.
         if (new File(uncPath).list() != null) {
           return uncPath;
         }
       } catch (SecurityException e) {
         // Cannot access local administrative share.
       }
     }
     return null;
   }

   @Test
   public void testStartMonitorBadPath() throws Exception {
     Path file = newTempFile("test.txt");
     thrown.expect(IOException.class);
     delegate.startMonitorPath(file, pusher);
   }

   @Test
   public void testStartStopMonitor() throws Exception {
     delegate.startMonitorPath(tempRoot, pusher);
     delegate.stopMonitorPath();
   }

   @Test
   public void testMonitorAddFile() throws Exception {
     // These shouldn't show up as new or modified.
     newTempDir("existingDir");
     newTempFile("existingFile");
     delegate.startMonitorPath(tempRoot, pusher);
     Path file = newTempFile("test.txt");
     // Adding a file shows up as a change to its parent.
     checkForChanges(Collections.singleton(newRecord(tempRoot)));
   }

   @Test
   public void testMonitorDeleteFile() throws Exception {
     Path file = newTempFile("test.txt");
     delegate.startMonitorPath(tempRoot, pusher);
     Files.delete(file);
     // Deleting a file shows up as a change to itself and its parent.
     checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(file)));
   }

   @Test
   public void testMonitorRenameFile() throws Exception {
     Path file = newTempFile("test.txt");
     Path newFile = file.resolveSibling("newName.txt");
     delegate.startMonitorPath(tempRoot, pusher);
     Files.move(file, newFile, StandardCopyOption.ATOMIC_MOVE);
     // Renaming a file shows up as a change to its old name, its new name,
     // and its parent.
     checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(file),
         newRecord(newFile)));
   }

   @Test
   public void testMonitorMoveAccrossDirs() throws Exception {
     Path dir1 = newTempDir("dir1");
     Path dir2 = newTempDir("dir2");
     Path file1 = newTempFile(dir1, "test.txt");
     Path file2 = dir2.resolve(file1.getFileName());
     delegate.startMonitorPath(tempRoot, pusher);
     Files.move(file1, file2);
     // Moving a file shows up as a change to its old name, its new name,
     // its old parent, and its new parent.
     checkForChanges(Sets.newHashSet(newRecord(file1), newRecord(file2),
         newRecord(dir1), newRecord(dir2)));
   }

   @Test
   public void testMonitorModifyFile() throws Exception {
     Path file = newTempFile("test.txt");
     delegate.startMonitorPath(tempRoot, pusher);
     Files.write(file, "Hello World".getBytes("UTF-8"));
     // Modifying a file shows up as a change to that file.
     checkForChanges(Collections.singleton(newRecord(file)));
   }

   @Test
   public void testMonitorModifyFileAttributes() throws Exception {
     Path file = newTempFile("test.txt");
     FileTime lastModified = Files.getLastModifiedTime(file);
     delegate.startMonitorPath(tempRoot, pusher);
     Files.setLastModifiedTime(file,
         FileTime.fromMillis(lastModified.toMillis() + 10000L));
     // Modifying a file shows up as a change to that file.
     checkForChanges(Collections.singleton(newRecord(file)));
   }

   @Test
   public void testMonitorRenameDir() throws Exception {
     Path dir = newTempDir("dir1");
     Path newDir = dir.resolveSibling("newName.dir");
     delegate.startMonitorPath(tempRoot, pusher);
     Files.move(dir, newDir, StandardCopyOption.ATOMIC_MOVE);
     // Renaming a directory shows up as a change to its old name, its new name,
     // and its parent.
     checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(dir)));
   }

   @Test
   public void testMonitorMoveDir() throws Exception {
     Path dir1 = newTempDir("dir1");
     Path dir2 = newTempDir("dir2");
     Path dir1dir2 = dir1.resolve(dir2.getFileName());
     delegate.startMonitorPath(tempRoot, pusher);
     Files.move(dir2, dir1dir2);
     // Moving a file shows up as a change to its old name, its new name,
     // its old parent, and its new parent.
     checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(dir1),
         newRecord(dir2)));
   }

   @Test
   public void testMonitorChangesInSubDirs() throws Exception {
     Path dir = newTempDir("testDir");
     Path file = newTempFile(dir, "test.txt");
     delegate.startMonitorPath(tempRoot, pusher);
     Files.write(file, "Hello World".getBytes("UTF-8"));
     // Modifying a file shows up as a change to that file.
     checkForChanges(Sets.newHashSet(newRecord(file), newRecord(dir)));
   }

   private void checkForChanges(Set<DocIdPusher.Record> expected)
       throws Exception {
     // Collect up the changes.
     Set<DocIdPusher.Record> changes = Sets.newHashSet();
     final long maxLatencyMillis = 10000;
     long latencyMillis = maxLatencyMillis;
     long batchLatencyMillis = 500;
     boolean inFollowup = false;

     while (latencyMillis > 0) {
       Thread.sleep(batchLatencyMillis);
       latencyMillis -= batchLatencyMillis;

       changes.addAll(pusher.getRecords());
       pusher.reset();
       if (changes.size() == expected.size()) {
         // If the changes size is equal to the expected size then
         // keep listening for changes for the same period of time
         // that it took to get the current notifications to see if
         // we find any additional changes.
         if (!inFollowup) {
           latencyMillis = maxLatencyMillis - latencyMillis;
           inFollowup = true;
         }
       }
       if (changes.size() > expected.size()) {
         // We've found more changes than are expected. Just stop
         // listening, we'll fail below.
         break;
       }
     }

     // Now verify that the changes we got were the ones that were expected.
     assertEquals(expected, changes);
   }

   private DocIdPusher.Record newRecord(Path path) throws Exception {
     return new DocIdPusher.Record.Builder(delegate.newDocId(path))
         .setCrawlImmediately(true).build();
   }

   private static Netapi32Ex.DFS_INFO_3 newDfsInfo3(Storage... storages) {
     final int sizeOfInfo = new Netapi32Ex.DFS_STORAGE_INFO().size();
     final int numberOfStorages = storages.length;

     // Cannot supply length of 0 so always allocate 1 more byte than needed.
     Memory storagesMem = new Memory(1 + numberOfStorages * sizeOfInfo);
     int offset = 0;
     for (Storage storage : storages) {
       storagesMem.setLong(offset, storage.state);
       offset += Native.LONG_SIZE;
       writeWString(storagesMem, offset, storage.serverName);
       offset += Pointer.SIZE;
       writeWString(storagesMem, offset, storage.shareName);
       offset += Pointer.SIZE;
     }

     Memory ptr = new Memory(40);
     writeWString(ptr, 0, new WString(""));
     writeWString(ptr, Pointer.SIZE, new WString(""));
     ptr.setLong(2 * Pointer.SIZE, 0);
     ptr.setLong(2 * Pointer.SIZE + Native.LONG_SIZE, numberOfStorages);
     ptr.setPointer(2 * Pointer.SIZE + 2 * Native.LONG_SIZE, storagesMem);
     return new Netapi32Ex.DFS_INFO_3(ptr);
   }

   private static void writeWString(Memory m, int offset, WString str) {
     int len = (str.length() + 1) * Native.WCHAR_SIZE;
     Memory ptr = new Memory(len);
     ptr.setString(0, str);
     m.setPointer(offset, ptr);
   }

   static class Storage {
     protected final int state;
     protected final WString serverName;
     protected final WString shareName;

     public Storage(int state, String serverName, String shareName) {
       this.state = state;
       this.serverName = new WString(serverName);
       this.shareName = new WString(shareName);
     }
   }
 }
	// Copyright 2014 Google Inc. All Rights Reserved.
	//
	// Licensed 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 com.google.enterprise.adaptor.fs;

	import static com.google.enterprise.adaptor.fs.AclView.user;
	import static com.google.enterprise.adaptor.fs.AclView.group;
	import static com.google.enterprise.adaptor.fs.AclView.GenericPermission.*;

	import static org.junit.Assert.*;
	import static org.junit.Assume.*;

	import static java.nio.file.attribute.AclEntryFlag.*;
	import static java.nio.file.attribute.AclEntryPermission.*;
	import static java.nio.file.attribute.AclEntryType.*;

	import com.google.common.base.Charsets;
	import com.google.common.base.Preconditions;
	import com.google.common.collect.Sets;
	import com.google.common.io.CharStreams;
	import com.google.enterprise.adaptor.Acl;
	import com.google.enterprise.adaptor.DocIdPusher;
	import com.google.enterprise.adaptor.fs.WinApi.Netapi32Ex;

	import org.junit.*;
	import org.junit.rules.ExpectedException;

	import com.sun.jna.Memory;
	import com.sun.jna.Native;
	import com.sun.jna.Pointer;
	import com.sun.jna.WString;
	import com.sun.jna.platform.win32.LMErr;
	import com.sun.jna.platform.win32.Win32Exception;
	import com.sun.jna.platform.win32.WinError;
	import com.sun.jna.platform.win32.WinNT;
	import com.sun.jna.platform.win32.WinDef.DWORD;
	import com.sun.jna.platform.win32.WinDef.ULONG;
	import com.sun.jna.ptr.IntByReference;
	import com.sun.jna.ptr.PointerByReference;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.nio.file.DirectoryStream;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.StandardCopyOption;
	import java.nio.file.attribute.AclFileAttributeView;
	import java.nio.file.attribute.BasicFileAttributes;
	import java.nio.file.attribute.FileTime;
	import java.util.Collections;
	import java.util.Set;

	/** Tests for {@link WindowsFileDelegate} */
	public class WindowsFileDelegateTest extends TestWindowsAclViews {

	@BeforeClass
	public static void checkIfRunningOnWindows() {
	TestHelper.assumeOsIsWindows();
	}

	private FileDelegate delegate = new WindowsFileDelegate();
	private AccumulatingAsyncDocIdPusher pusher =
	new AccumulatingAsyncDocIdPusher();
	private Path tempRoot;

	@Rule
	public ExpectedException thrown = ExpectedException.none();

	@Before
	public void setUp() throws Exception {
	tempRoot = getTempRoot();
	}

	@After
	public void tearDown() {
	delegate.destroy();
	}

	@Test
	public void testGetDfsShareAclView() throws Exception {
	// The *_OBJECT_ACE_TYPEs will get filtered out by newAclEntry().
	AclFileAttributeView expectedAcl = new AclView(
	group("AccessAllowedAce").type(ALLOW).perms(GENERIC_READ)
	.flags(FILE_INHERIT, DIRECTORY_INHERIT),
	user("AccessDeniedAce").type(DENY).perms(GENERIC_READ)
	.flags(FILE_INHERIT, DIRECTORY_INHERIT));

	AclFileAttributeView aclView = getDfsShareAclView(
	new AceBuilder()
	.setSid(AccountSid.group("AccessAllowedAce", null))
	.setType(WinNT.ACCESS_ALLOWED_ACE_TYPE)
	.setPerms(WinNT.GENERIC_READ)
	.setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
	.build(),
	new AceBuilder()
	.setSid(AccountSid.user("AccessAllowedObjectAce", null))
	.setType(WinNT.ACCESS_ALLOWED_OBJECT_ACE_TYPE)
	.setPerms(WinNT.GENERIC_ALL)
	.setFlags(WinNT.OBJECT_INHERIT_ACE)
	.build(),
	new AceBuilder()
	.setSid(AccountSid.user("AccessDeniedAce", null))
	.setType(WinNT.ACCESS_DENIED_ACE_TYPE)
	.setPerms(WinNT.GENERIC_READ)
	.setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
	.build(),
	new AceBuilder()
	.setSid(AccountSid.group("AccessDeniedObjectAce", null))
	.setType(WinNT.ACCESS_DENIED_OBJECT_ACE_TYPE)
	.setPerms(WinNT.GENERIC_ALL)
	.setFlags(WinNT.OBJECT_INHERIT_ACE)
	.build());

	assertNotNull(aclView);
	assertEquals(expectedAcl.getAcl(), aclView.getAcl());
	}

	@Test
	public void testGetDfsShareAclViewUnsupportedAceType() throws Exception {
	thrown.expect(IllegalArgumentException.class);
	AclFileAttributeView aclView = getDfsShareAclView(
	new AceBuilder()
	.setSid(AccountSid.group("SystemAuditAce", null))
	.setType(WinNT.SYSTEM_AUDIT_ACE_TYPE)
	.setPerms(WinNT.GENERIC_ALL)
	.setFlags(WinNT.OBJECT_INHERIT_ACE, WinNT.CONTAINER_INHERIT_ACE)
	.build());
	}

	private static AclFileAttributeView getDfsShareAclView(
	WinNT.ACCESS_ACEStructure... aces) throws Exception {
	byte[] dacl = buildDaclMemory(aces);
	final Memory memory = new Memory(dacl.length);
	memory.write(0, dacl, 0, dacl.length);

	Netapi32Ex netapi = new UnsupportedNetapi32() {
	@Override
	public int NetDfsGetSecurity(String dfsPath, int securityInfo,
	PointerByReference bufptr, IntByReference bufsz) {
	bufptr.setValue(memory);
	bufsz.setValue((int)(memory.size()));
	return WinError.ERROR_SUCCESS;
	}
	@Override
	public int NetApiBufferFree(Pointer buf) {
	return WinError.ERROR_SUCCESS;
	}
	};

	WindowsAclFileAttributeViews wafav =
	new TestAclFileAttributeViews(null, null, null, netapi, null);
	WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, wafav);

	return delegate.getDfsShareAclView(Paths.get("\\\\host\\share"));
	}

	@Test
	public void testGetDfsShareAclViewError() throws Exception {
	Netapi32Ex netapi = new UnsupportedNetapi32() {
	@Override
	public int NetDfsGetSecurity(String dfsPath, int securityInfo,
	PointerByReference bufptr, IntByReference bufsz) {
	return WinError.ERROR_ACCESS_DENIED;
	}
	@Override
	public int NetApiBufferFree(Pointer buf) {
	return WinError.ERROR_SUCCESS;
	}
	};

	WindowsAclFileAttributeViews wafav =
	new TestAclFileAttributeViews(null, null, null, netapi, null);
	WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, wafav);

	thrown.expect(Win32Exception.class);
	delegate.getDfsShareAclView(Paths.get("\\\\host\\share"));
	}

	@Test
	public void testGetDfsUncActiveStorageUncError() throws Exception {
	Netapi32Ex netapi = new UnsupportedNetapi32() {
	@Override
	public int NetDfsGetInfo(String dfsPath, String server, String share,
	int level, PointerByReference bufptr) {
	return WinError.ERROR_ACCESS_DENIED;
	}
	};
	assertNull(getDfsUncActiveStorageUnc(netapi));
	}

	@Test
	public void testGetDfsUncActiveStorageUncNoStorage() throws Exception {
	final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3();

	assertEquals(0, info.NumberOfStorages.intValue());
	thrown.expect(IOException.class);
	getDfsUncActiveStorageUnc(info);
	}

	@Test
	public void testGetDfsUncActiveStorageUncSingleActiveStorage()
	throws Exception {
	final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
	new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "server", "share"));

	assertEquals(1, info.NumberOfStorages.intValue());
	assertEquals(Paths.get("\\\\server\\share"),
	getDfsUncActiveStorageUnc(info));
	}

	@Test
	public void testGetDfsUncActiveStorageUncNoActiveStorage() throws Exception {
	final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
	new Storage(0, "server", "share"));

	assertEquals(1, info.NumberOfStorages.intValue());
	thrown.expect(IOException.class);
	getDfsUncActiveStorageUnc(info);
	}

	@Test
	public void testGetDfsUncActiveStorageUncSomeActiveStorage()
	throws Exception {
	final Netapi32Ex.DFS_INFO_3 info = newDfsInfo3(
	new Storage(0, "inactive", "inactive"),
	new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "server", "share"),
	new Storage(Netapi32Ex.DFS_STORAGE_STATE_ONLINE, "active", "active"));

	assertEquals(3, info.NumberOfStorages.intValue());
	assertEquals(Paths.get("\\\\server\\share"),
	getDfsUncActiveStorageUnc(info));
	}

	private static Path getDfsUncActiveStorageUnc(
	final Netapi32Ex.DFS_INFO_3 info) throws Exception {
	Netapi32Ex netapi = new UnsupportedNetapi32() {
	@Override
	public int NetDfsGetInfo(String dfsPath, String server, String share,
	int level, PointerByReference bufptr) {
	bufptr.setValue(info.getPointer());
	return LMErr.NERR_Success;
	}
	@Override
	public int NetApiBufferFree(Pointer buf) {
	return WinError.ERROR_SUCCESS;
	}
	};

	return getDfsUncActiveStorageUnc(netapi);
	}

	private static Path getDfsUncActiveStorageUnc(Netapi32Ex netapi)
	throws Exception {
	WindowsFileDelegate delegate = new WindowsFileDelegate(null, netapi, null);
	Path dfsPath = Paths.get("\\\\host\\share");
	return delegate.getDfsUncActiveStorageUnc(dfsPath);
	}

	@Test
	public void testNewDocIdLocalFiles() throws Exception {
	Path dir = newTempDir("testDir");
	Path file = newTempFile(dir, "test");

	String id = delegate.newDocId(tempRoot).getUniqueId();
	assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
	assertTrue(id.endsWith("/"));

	id = delegate.newDocId(dir).getUniqueId();
	assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
	assertTrue(id.startsWith(dir.toString().replace('\\', '/')));
	assertTrue(id.endsWith("/"));

	id = delegate.newDocId(file).getUniqueId();
	assertTrue(id.startsWith(tempRoot.toString().replace('\\', '/')));
	assertTrue(id.startsWith(dir.toString().replace('\\', '/')));
	assertTrue(id.equals(file.toString().replace('\\', '/')));
	assertFalse(id.endsWith("/"));
	}

	@Test
	public void testNewDocIdVirtualUncPaths() throws Exception {
	assertEquals("\\\\host/share",
	delegate.newDocId(Paths.get("\\\\host\\share")).getUniqueId());
	assertEquals("\\\\host/share",
	delegate.newDocId(Paths.get("\\\\host\\share\\")).getUniqueId());
	assertEquals("\\\\host/share/foo/bar",
	delegate.newDocId(Paths.get("\\\\host\\share\\foo\\bar"))
	.getUniqueId());
	}

	@Test
	public void testNewDocIdLocalUncPaths() throws Exception {
	String uncTempRoot = getTempRootAsUncPath();
	assumeNotNull(uncTempRoot);
	Path tempRoot = Paths.get(uncTempRoot);
	String expectedTempRootId = "\\\\" + uncTempRoot.substring(2)
	.replace('\\', '/') + "/";

	assertEquals(expectedTempRootId,
	delegate.newDocId(tempRoot).getUniqueId());

	newTempDir("testDir");
	assertEquals(expectedTempRootId + "testDir/",
	delegate.newDocId(tempRoot.resolve("testDir")).getUniqueId());

	newTempFile("test");
	assertEquals(expectedTempRootId + "test",
	delegate.newDocId(tempRoot.resolve("test")).getUniqueId());
	}

	private String getTempRootAsUncPath() throws IOException {
	String tempPath = temp.getRoot().getCanonicalPath();
	if (tempPath.length() > 2 && tempPath.charAt(1) == ':') {
	String uncPath = "\\\\localhost\\" + tempPath.substring(0, 1) + "$"
	+ tempPath.substring(2);
	try {
	// Now verify we have access to the local administrative share.
	if (new File(uncPath).list() != null) {
	return uncPath;
	}
	} catch (SecurityException e) {
	// Cannot access local administrative share.
	}
	}
	return null;
	}

	@Test
	public void testStartMonitorBadPath() throws Exception {
	Path file = newTempFile("test.txt");
	thrown.expect(IOException.class);
	delegate.startMonitorPath(file, pusher);
	}

	@Test
	public void testStartStopMonitor() throws Exception {
	delegate.startMonitorPath(tempRoot, pusher);
	delegate.stopMonitorPath();
	}

	@Test
	public void testMonitorAddFile() throws Exception {
	// These shouldn't show up as new or modified.
	newTempDir("existingDir");
	newTempFile("existingFile");
	delegate.startMonitorPath(tempRoot, pusher);
	Path file = newTempFile("test.txt");
	// Adding a file shows up as a change to its parent.
	checkForChanges(Collections.singleton(newRecord(tempRoot)));
	}

	@Test
	public void testMonitorDeleteFile() throws Exception {
	Path file = newTempFile("test.txt");
	delegate.startMonitorPath(tempRoot, pusher);
	Files.delete(file);
	// Deleting a file shows up as a change to itself and its parent.
	checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(file)));
	}

	@Test
	public void testMonitorRenameFile() throws Exception {
	Path file = newTempFile("test.txt");
	Path newFile = file.resolveSibling("newName.txt");
	delegate.startMonitorPath(tempRoot, pusher);
	Files.move(file, newFile, StandardCopyOption.ATOMIC_MOVE);
	// Renaming a file shows up as a change to its old name, its new name,
	// and its parent.
	checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(file),
	newRecord(newFile)));
	}

	@Test
	public void testMonitorMoveAccrossDirs() throws Exception {
	Path dir1 = newTempDir("dir1");
	Path dir2 = newTempDir("dir2");
	Path file1 = newTempFile(dir1, "test.txt");
	Path file2 = dir2.resolve(file1.getFileName());
	delegate.startMonitorPath(tempRoot, pusher);
	Files.move(file1, file2);
	// Moving a file shows up as a change to its old name, its new name,
	// its old parent, and its new parent.
	checkForChanges(Sets.newHashSet(newRecord(file1), newRecord(file2),
	newRecord(dir1), newRecord(dir2)));
	}

	@Test
	public void testMonitorModifyFile() throws Exception {
	Path file = newTempFile("test.txt");
	delegate.startMonitorPath(tempRoot, pusher);
	Files.write(file, "Hello World".getBytes("UTF-8"));
	// Modifying a file shows up as a change to that file.
	checkForChanges(Collections.singleton(newRecord(file)));
	}

	@Test
	public void testMonitorModifyFileAttributes() throws Exception {
	Path file = newTempFile("test.txt");
	FileTime lastModified = Files.getLastModifiedTime(file);
	delegate.startMonitorPath(tempRoot, pusher);
	Files.setLastModifiedTime(file,
	FileTime.fromMillis(lastModified.toMillis() + 10000L));
	// Modifying a file shows up as a change to that file.
	checkForChanges(Collections.singleton(newRecord(file)));
	}

	@Test
	public void testMonitorRenameDir() throws Exception {
	Path dir = newTempDir("dir1");
	Path newDir = dir.resolveSibling("newName.dir");
	delegate.startMonitorPath(tempRoot, pusher);
	Files.move(dir, newDir, StandardCopyOption.ATOMIC_MOVE);
	// Renaming a directory shows up as a change to its old name, its new name,
	// and its parent.
	checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(dir)));
	}

	@Test
	public void testMonitorMoveDir() throws Exception {
	Path dir1 = newTempDir("dir1");
	Path dir2 = newTempDir("dir2");
	Path dir1dir2 = dir1.resolve(dir2.getFileName());
	delegate.startMonitorPath(tempRoot, pusher);
	Files.move(dir2, dir1dir2);
	// Moving a file shows up as a change to its old name, its new name,
	// its old parent, and its new parent.
	checkForChanges(Sets.newHashSet(newRecord(tempRoot), newRecord(dir1),
	newRecord(dir2)));
	}

	@Test
	public void testMonitorChangesInSubDirs() throws Exception {
	Path dir = newTempDir("testDir");
	Path file = newTempFile(dir, "test.txt");
	delegate.startMonitorPath(tempRoot, pusher);
	Files.write(file, "Hello World".getBytes("UTF-8"));
	// Modifying a file shows up as a change to that file.
	checkForChanges(Sets.newHashSet(newRecord(file), newRecord(dir)));
	}

	private void checkForChanges(Set<DocIdPusher.Record> expected)
	throws Exception {
	// Collect up the changes.
	Set<DocIdPusher.Record> changes = Sets.newHashSet();
	final long maxLatencyMillis = 10000;
	long latencyMillis = maxLatencyMillis;
	long batchLatencyMillis = 500;
	boolean inFollowup = false;

	while (latencyMillis > 0) {
	Thread.sleep(batchLatencyMillis);
	latencyMillis -= batchLatencyMillis;

	changes.addAll(pusher.getRecords());
	pusher.reset();
	if (changes.size() == expected.size()) {
	// If the changes size is equal to the expected size then
	// keep listening for changes for the same period of time
	// that it took to get the current notifications to see if
	// we find any additional changes.
	if (!inFollowup) {
	latencyMillis = maxLatencyMillis - latencyMillis;
	inFollowup = true;
	}
	}
	if (changes.size() > expected.size()) {
	// We've found more changes than are expected. Just stop
	// listening, we'll fail below.
	break;
	}
	}

	// Now verify that the changes we got were the ones that were expected.
	assertEquals(expected, changes);
	}

	private DocIdPusher.Record newRecord(Path path) throws Exception {
	return new DocIdPusher.Record.Builder(delegate.newDocId(path))
	.setCrawlImmediately(true).build();
	}

	private static Netapi32Ex.DFS_INFO_3 newDfsInfo3(Storage... storages) {
	final int sizeOfInfo = new Netapi32Ex.DFS_STORAGE_INFO().size();
	final int numberOfStorages = storages.length;

	// Cannot supply length of 0 so always allocate 1 more byte than needed.
	Memory storagesMem = new Memory(1 + numberOfStorages * sizeOfInfo);
	int offset = 0;
	for (Storage storage : storages) {
	storagesMem.setLong(offset, storage.state);
	offset += Native.LONG_SIZE;
	writeWString(storagesMem, offset, storage.serverName);
	offset += Pointer.SIZE;
	writeWString(storagesMem, offset, storage.shareName);
	offset += Pointer.SIZE;
	}

	Memory ptr = new Memory(40);
	writeWString(ptr, 0, new WString(""));
	writeWString(ptr, Pointer.SIZE, new WString(""));
	ptr.setLong(2 * Pointer.SIZE, 0);
	ptr.setLong(2 * Pointer.SIZE + Native.LONG_SIZE, numberOfStorages);
	ptr.setPointer(2 * Pointer.SIZE + 2 * Native.LONG_SIZE, storagesMem);
	return new Netapi32Ex.DFS_INFO_3(ptr);
	}

	private static void writeWString(Memory m, int offset, WString str) {
	int len = (str.length() + 1) * Native.WCHAR_SIZE;
	Memory ptr = new Memory(len);
	ptr.setString(0, str);
	m.setPointer(offset, ptr);
	}

	static class Storage {
	protected final int state;
	protected final WString serverName;
	protected final WString shareName;

	public Storage(int state, String serverName, String shareName) {
	this.state = state;
	this.serverName = new WString(serverName);
	this.shareName = new WString(shareName);
	}
	}
	}