Added LFS like test to FilterFixture

Author: J Wyman

LibGit2Sharp.Tests/FilterFixture.cs

@@ -176,6 +176,113 @@ public void WhenCheckingOutAFileFileSmudgeWritesCorrectFileToWorkingDirectory()
             GlobalSettings.DeregisterFilter(filterRegistration);
         }
 
+        [Fact]
+        public void CanFilterLargeFiles()
+        {
+            const int ContentLength = 128 * 1024 * 1024;
+            const char ContentValue = 'x';
+
+            char[] content = (new string(ContentValue, 1024)).ToCharArray();
+
+            string repoPath = InitNewRepository();
+
+            var filter = new FileExportFilter("exportFilter", attributes);
+            var filterRegistration = GlobalSettings.RegisterFilter(filter);
+
+            string filePath = Path.Combine(Directory.GetParent(repoPath).Parent.FullName, Guid.NewGuid().ToString() + ".blob");
+            FileInfo contentFile = new FileInfo(filePath);
+            using (var writer = new StreamWriter(contentFile.OpenWrite()) { AutoFlush = true })
+            {
+                for (int i = 0; i < ContentLength / content.Length; i++)
+                {
+                    writer.Write(content);
+                }
+            }
+
+            string attributesPath = Path.Combine(Directory.GetParent(repoPath).Parent.FullName, ".gitattributes");
+            FileInfo attributesFile = new FileInfo(attributesPath);
+
+            string configPath = CreateConfigurationWithDummyUser(Constants.Signature);
+            var repositoryOptions = new RepositoryOptions { GlobalConfigurationLocation = configPath };
+
+            using (Repository repo = new Repository(repoPath, repositoryOptions))
+            {
+                File.WriteAllText(attributesPath, "*.blob filter=test");
+                repo.Stage(attributesFile.Name);
+                repo.Stage(contentFile.Name);
+                repo.Commit("test");
+                contentFile.Delete();
+                repo.Checkout("HEAD", new CheckoutOptions() { CheckoutModifiers = CheckoutModifiers.Force });
+            }
+
+            contentFile = new FileInfo(filePath);
+            Assert.True(contentFile.Exists, "Contents not restored correctly by forced checkout.");
+            using (StreamReader reader = contentFile.OpenText())
+            {
+                int totalRead = 0;
+                char[] block = new char[1024];
+                int read;
+                while ((read = reader.Read(block, 0, block.Length)) > 0)
+                {
+                    Assert.True(CharArrayAreEqual(block, content, read));
+                    totalRead += read;
+                }
+
+                Assert.Equal(ContentLength, totalRead);
+            }
+
+            contentFile.Delete();
+
+            GlobalSettings.DeregisterFilter(filterRegistration);
+        }
+
+        private unsafe bool CharArrayAreEqual(char[] array1, char[] array2, int count)
+        {
+            if (Object.ReferenceEquals(array1, array2))
+            {
+                return true;
+            }
+            if (Object.ReferenceEquals(array1, null) || Object.ReferenceEquals(null, array2))
+            {
+                return false;
+            }
+            if (array1.Length < count || array2.Length < count)
+            {
+                return false;
+            }
+
+            int len = count * sizeof(char);
+            int cnt = len / sizeof(long);
+
+            fixed (char* c1 = array1, c2 = array2)
+            {
+                long* p1 = (long*)c1,
+                      p2 = (long*)c2;
+
+                for (int i = 0; i < cnt; i++)
+                {
+                    if (p1[i] != p2[i])
+                    {
+                        return false;
+                    }
+                }
+
+                byte* b1 = (byte*)c1,
+                      b2 = (byte*)c2;
+
+                for (int i = len * sizeof(long); i < len; i++)
+                {
+                    if (b1[i] != b2[i])
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+
         private FileInfo CheckoutFileForSmudge(string repoPath, string branchName, string content)
         {
             FileInfo expectedPath;

LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj

@@ -23,6 +23,7 @@
     <DefineConstants>TRACE;DEBUG;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -31,6 +32,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Moq, Version=4.2.1409.1722, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
@@ -118,6 +120,7 @@
     <Compile Include="RepositoryFixture.cs" />
     <Compile Include="TagFixture.cs" />
     <Compile Include="TestHelpers\DateTimeOffsetExtensions.cs" />
+    <Compile Include="TestHelpers\FileExportFilter.cs" />
     <Compile Include="TestHelpers\OdbHelper.cs" />
     <Compile Include="TestHelpers\DirectoryHelper.cs" />
     <Compile Include="TestHelpers\ExpectedFetchState.cs" />

LibGit2Sharp.Tests/TestHelpers/FileExportFilter.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace LibGit2Sharp.Tests.TestHelpers
+{
+    class FileExportFilter : Filter
+    {
+        public int CleanCalledCount = 0;
+        public int CompleteCalledCount = 0;
+        public int SmudgeCalledCount = 0;
+        public readonly HashSet<string> FilesFiltered;
+
+        private bool clean;
+
+        public FileExportFilter(string name, IEnumerable<FilterAttributeEntry> attributes)
+            : base(name, attributes)
+        {
+            FilesFiltered = new HashSet<string>();
+        }
+
+        protected override void Clean(string path, string root, Stream input, Stream output)
+        {
+            CleanCalledCount++;
+
+            string filename = Path.GetFileName(path);
+            string cachePath = Path.Combine(root, ".git", filename);
+
+            using (var file = File.Exists(cachePath) ? File.Open(cachePath, FileMode.Append, FileAccess.Write, FileShare.None) : File.Create(cachePath))
+            {
+                input.CopyTo(file);
+            }
+
+            clean = true;
+        }
+
+        protected override void Complete(string path, string root, Stream output)
+        {
+            CompleteCalledCount++;
+
+            string filename = Path.GetFileName(path);
+            string cachePath = Path.Combine(root, ".git", filename);
+
+            if (clean)
+            {
+                byte[] bytes = Encoding.UTF8.GetBytes(path);
+                output.Write(bytes, 0, bytes.Length);
+                FilesFiltered.Add(path);
+            }
+            else
+            {
+                if (File.Exists(cachePath))
+                {
+                    using (var file = File.Open(cachePath, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None))
+                    {
+                        file.CopyTo(output);
+                    }
+                }
+            }
+        }
+
+        protected override void Smudge(string path, string root, Stream input, Stream output)
+        {
+            SmudgeCalledCount++;
+
+            string filename = Path.GetFileName(path);
+            StringBuilder text = new StringBuilder();
+
+            byte[] buffer = new byte[64 * 1024];
+            int read;
+            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
+            {
+                string decoded = Encoding.UTF8.GetString(buffer, 0, read);
+                text.Append(decoded);
+            }
+
+            if (!FilesFiltered.Contains(text.ToString()))
+                throw new FileNotFoundException();
+
+            clean = false;
+        }
+    }
+}