Merge pull request SixLabors#904 from SixLabors/af/non-generic-image-baseclass

antonfirsov · web-flow · commit ba2de681e133 · 2019-05-10T20:50:04.000+02:00
Introduce a non-generic Image base class
diff --git a/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj b/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj
@@ -10,7 +10,9 @@
 
     <VersionPrefix Condition="$(packageversion) != ''">$(packageversion)</VersionPrefix>
     <VersionPrefix Condition="$(packageversion) == ''">0.0.1</VersionPrefix>
+
     <TargetFrameworks>netcoreapp2.1;netstandard1.3;netstandard2.0</TargetFrameworks>
+    
     <LangVersion>7.3</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/tests/ImageSharp.Tests/BaseImageOperationsExtensionTest.cs b/tests/ImageSharp.Tests/BaseImageOperationsExtensionTest.cs
@@ -3,6 +3,7 @@
 
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors;
 using SixLabors.Primitives;
 using Xunit;
 
@@ -33,7 +34,12 @@ public T Verify<T>(int index = 0)
 
             FakeImageOperationsProvider.FakeImageOperations<Rgba32>.AppliedOperation operation = this.internalOperations.Applied[index];
 
-            return Assert.IsType<T>(operation.Processor);
+            if (operation.NonGenericProcessor != null)
+            {
+                return Assert.IsType<T>(operation.NonGenericProcessor);
+            }
+            
+            return Assert.IsType<T>(operation.GenericProcessor);
         }
 
         public T Verify<T>(Rectangle rect, int index = 0)
@@ -43,7 +49,13 @@ public T Verify<T>(Rectangle rect, int index = 0)
             FakeImageOperationsProvider.FakeImageOperations<Rgba32>.AppliedOperation operation = this.internalOperations.Applied[index];
 
             Assert.Equal(rect, operation.Rectangle);
-            return Assert.IsType<T>(operation.Processor);
+            
+            if (operation.NonGenericProcessor != null)
+            {
+                return Assert.IsType<T>(operation.NonGenericProcessor);
+            }
+            
+            return Assert.IsType<T>(operation.GenericProcessor);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/Drawing/DrawImageTest.cs b/tests/ImageSharp.Tests/Drawing/DrawImageTest.cs
@@ -79,7 +79,8 @@ public void ImageShouldDrawTransformedImage<TPixel>(TestImageProvider<TPixel> pr
                     .AppendTranslation(new PointF(10, 10));
 
                 // Apply a background color so we can see the translation.
-                blend.Mutate(x => x.Transform(builder).BackgroundColor(NamedColors<TPixel>.HotPink));
+                blend.Mutate(x => x.Transform(builder));
+                blend.Mutate(x => x.BackgroundColor(NamedColors<TPixel>.HotPink));
 
                 // Lets center the matrix so we can tell whether any cut-off issues we may have belong to the drawing processor
                 var position = new Point((image.Width - blend.Width) / 2, (image.Height - blend.Height) / 2);
diff --git a/tests/ImageSharp.Tests/Drawing/RecolorImageTest.cs b/tests/ImageSharp.Tests/Drawing/RecolorImageTest.cs
@@ -19,7 +19,7 @@ public void ImageShouldRecolorYellowToHotPink()
 
             foreach (TestFile file in Files)
             {
-                using (Image<Rgba32> image = file.CreateImage())
+                using (Image<Rgba32> image = file.CreateRgba32Image())
                 {
                     image.Mutate(x => x.Fill(brush));
                     image.Save($"{path}/{file.FileName}");
@@ -36,7 +36,7 @@ public void ImageShouldRecolorYellowToHotPinkInARectangle()
 
             foreach (TestFile file in Files)
             {
-                using (Image<Rgba32> image = file.CreateImage())
+                using (Image<Rgba32> image = file.CreateRgba32Image())
                 {
                     int imageHeight = image.Height;
                     image.Mutate(x => x.Fill(brush, new Rectangle(0, imageHeight / 2 - imageHeight / 4, image.Width, imageHeight / 2)));
diff --git a/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs b/tests/ImageSharp.Tests/Drawing/SolidPolygonTests.cs
@@ -96,7 +96,7 @@ public void ImageShouldBeOverlayedByFilledPolygonImage()
                             new Vector2(50, 300)
             };
 
-            using (Image<Rgba32> brushImage = TestFile.Create(TestImages.Bmp.Car).CreateImage())
+            using (Image<Rgba32> brushImage = TestFile.Create(TestImages.Bmp.Car).CreateRgba32Image())
             using (var image = new Image<Rgba32>(500, 500))
             {
                 var brush = new ImageBrush<Rgba32>(brushImage);
diff --git a/tests/ImageSharp.Tests/FakeImageOperationsProvider.cs b/tests/ImageSharp.Tests/FakeImageOperationsProvider.cs
@@ -67,11 +67,30 @@ public Size GetCurrentSize()
                 return this.Source.Size();
             }
 
+            public IImageProcessingContext ApplyProcessor(IImageProcessor processor, Rectangle rectangle)
+            {
+                this.Applied.Add(new AppliedOperation()
+                                     {
+                                         Rectangle = rectangle,
+                                         NonGenericProcessor = processor
+                                     });
+                return this;
+            }
+
+            public IImageProcessingContext ApplyProcessor(IImageProcessor processor)
+            {
+                this.Applied.Add(new AppliedOperation()
+                                     {
+                                         NonGenericProcessor = processor
+                                     });
+                return this;
+            }
+
             public IImageProcessingContext<TPixel> ApplyProcessor(IImageProcessor<TPixel> processor, Rectangle rectangle)
             {
                 this.Applied.Add(new AppliedOperation
                 {
-                    Processor = processor,
+                    GenericProcessor = processor,
                     Rectangle = rectangle
                 });
                 return this;
@@ -81,15 +100,17 @@ public IImageProcessingContext<TPixel> ApplyProcessor(IImageProcessor<TPixel> pr
             {
                 this.Applied.Add(new AppliedOperation
                 {
-                    Processor = processor
+                    GenericProcessor = processor
                 });
                 return this;
             }
 
             public struct AppliedOperation
             {
                 public Rectangle? Rectangle { get; set; }
-                public IImageProcessor<TPixel> Processor { get; set; }
+                public IImageProcessor<TPixel> GenericProcessor { get; set; }
+                
+                public IImageProcessor NonGenericProcessor { get; set; }
             }
         }
     }
diff --git a/tests/ImageSharp.Tests/ImageOperationTests.cs b/tests/ImageSharp.Tests/ImageOperationTests.cs
@@ -41,7 +41,7 @@ public void MutateCallsImageOperationsProvider_Func_OriginalImage()
             this.image.Mutate(x => x.ApplyProcessor(this.processor));
 
             Assert.True(this.provider.HasCreated(this.image));
-            Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));
+            Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));
         }
 
         [Fact]
@@ -50,7 +50,7 @@ public void MutateCallsImageOperationsProvider_ListOfProcessors_OriginalImage()
             this.image.Mutate(this.processor);
 
             Assert.True(this.provider.HasCreated(this.image));
-            Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));
+            Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));
         }
 
         [Fact]
@@ -59,7 +59,7 @@ public void CloneCallsImageOperationsProvider_Func_WithDuplicateImage()
             Image<Rgba32> returned = this.image.Clone(x => x.ApplyProcessor(this.processor));
 
             Assert.True(this.provider.HasCreated(returned));
-            Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.Processor));
+            Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.GenericProcessor));
         }
 
         [Fact]
@@ -68,31 +68,31 @@ public void CloneCallsImageOperationsProvider_ListOfProcessors_WithDuplicateImag
             Image<Rgba32> returned = this.image.Clone(this.processor);
 
             Assert.True(this.provider.HasCreated(returned));
-            Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.Processor));
+            Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.GenericProcessor));
         }
 
         [Fact]
         public void CloneCallsImageOperationsProvider_Func_NotOnOrigional()
         {
             Image<Rgba32> returned = this.image.Clone(x => x.ApplyProcessor(this.processor));
             Assert.False(this.provider.HasCreated(this.image));
-            Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));
+            Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));
         }
 
         [Fact]
         public void CloneCallsImageOperationsProvider_ListOfProcessors_NotOnOrigional()
         {
             Image<Rgba32> returned = this.image.Clone(this.processor);
             Assert.False(this.provider.HasCreated(this.image));
-            Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));
+            Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));
         }
 
         [Fact]
         public void ApplyProcessors_ListOfProcessors_AppliesAllProcessorsToOperation()
         {
             var operations = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(null, false);
             operations.ApplyProcessors(this.processor);
-            Assert.Contains(this.processor, operations.Applied.Select(x => x.Processor));
+            Assert.Contains(this.processor, operations.Applied.Select(x => x.GenericProcessor));
         }
 
         public void Dispose() => this.image.Dispose();
diff --git a/tests/ImageSharp.Tests/TestFile.cs b/tests/ImageSharp.Tests/TestFile.cs
@@ -134,7 +134,7 @@ public string GetFileNameWithoutExtension(object value)
         /// <returns>
         /// The <see cref="ImageSharp.Image"/>.
         /// </returns>
-        public Image<Rgba32> CreateImage()
+        public Image<Rgba32> CreateRgba32Image()
         {
             return this.Image.Clone();
         }
@@ -145,9 +145,9 @@ public Image<Rgba32> CreateImage()
         /// <returns>
         /// The <see cref="ImageSharp.Image"/>.
         /// </returns>
-        public Image<Rgba32> CreateImage(IImageDecoder decoder)
+        public Image<Rgba32> CreateRgba32Image(IImageDecoder decoder)
         {
-            return ImageSharp.Image.Load(this.Image.GetConfiguration(), this.Bytes, decoder);
+            return ImageSharp.Image.Load<Rgba32>(this.Image.GetConfiguration(), this.Bytes, decoder);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/TestFileSystem.cs b/tests/ImageSharp.Tests/TestFileSystem.cs
@@ -12,29 +12,24 @@ namespace SixLabors.ImageSharp.Tests
     /// </summary>
     public class TestFileSystem : ImageSharp.IO.IFileSystem
     {
-
-        public static TestFileSystem Global { get; } = new TestFileSystem();
-
-        public static void RegisterGlobalTestFormat()
-        {
-            Configuration.Default.FileSystem = Global;
-        }
-
-        Dictionary<string, Stream> fileSystem = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, Stream> fileSystem = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);
 
         public void AddFile(string path, Stream data)
         {
-            fileSystem.Add(path, data);
+            lock (this.fileSystem)
+            {
+                this.fileSystem.Add(path, data);
+            }
         }
 
         public Stream Create(string path)
         {
             // if we have injected a fake file use it instead
-            lock (fileSystem)
+            lock (this.fileSystem)
             {
-                if (fileSystem.ContainsKey(path))
+                if (this.fileSystem.ContainsKey(path))
                 {
-                    Stream stream = fileSystem[path];
+                    Stream stream = this.fileSystem[path];
                     stream.Position = 0;
                     return stream;
                 }
@@ -43,15 +38,14 @@ public Stream Create(string path)
             return File.Create(path);
         }
 
-
         public Stream OpenRead(string path)
         {
             // if we have injected a fake file use it instead
-            lock (fileSystem)
+            lock (this.fileSystem)
             {
-                if (fileSystem.ContainsKey(path))
+                if (this.fileSystem.ContainsKey(path))
                 {
-                    Stream stream = fileSystem[path];
+                    Stream stream = this.fileSystem[path];
                     stream.Position = 0;
                     return stream;
                 }
@@ -60,5 +54,4 @@ public Stream OpenRead(string path)
             return File.OpenRead(path);
         }
     }
-}
-
+}
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void ImageShouldRecolorYellowToHotPink()`
`19`	`19`
`20`	`20`	`foreach (TestFile file in Files)`
`21`	`21`	`{`
`22`		`- using (Image<Rgba32> image = file.CreateImage())`
	`22`	`+ using (Image<Rgba32> image = file.CreateRgba32Image())`
`23`	`23`	`{`
`24`	`24`	`image.Mutate(x => x.Fill(brush));`
`25`	`25`	`image.Save($"{path}/{file.FileName}");`
`@@ -36,7 +36,7 @@ public void ImageShouldRecolorYellowToHotPinkInARectangle()`
`36`	`36`
`37`	`37`	`foreach (TestFile file in Files)`
`38`	`38`	`{`
`39`		`- using (Image<Rgba32> image = file.CreateImage())`
	`39`	`+ using (Image<Rgba32> image = file.CreateRgba32Image())`
`40`	`40`	`{`
`41`	`41`	`int imageHeight = image.Height;`
`42`	`42`	`image.Mutate(x => x.Fill(brush, new Rectangle(0, imageHeight / 2 - imageHeight / 4, image.Width, imageHeight / 2)));`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ public void ImageShouldBeOverlayedByFilledPolygonImage()`
`96`	`96`	`new Vector2(50, 300)`
`97`	`97`	`};`
`98`	`98`
`99`		`- using (Image<Rgba32> brushImage = TestFile.Create(TestImages.Bmp.Car).CreateImage())`
	`99`	`+ using (Image<Rgba32> brushImage = TestFile.Create(TestImages.Bmp.Car).CreateRgba32Image())`
`100`	`100`	`using (var image = new Image<Rgba32>(500, 500))`
`101`	`101`	`{`
`102`	`102`	`var brush = new ImageBrush<Rgba32>(brushImage);`
Original file line number	Diff line number	Diff line change
`@@ -67,11 +67,30 @@ public Size GetCurrentSize()`
`67`	`67`	`return this.Source.Size();`
`68`	`68`	`}`
`69`	`69`
	`70`	`+ public IImageProcessingContext ApplyProcessor(IImageProcessor processor, Rectangle rectangle)`
	`71`	`+ {`
	`72`	`+ this.Applied.Add(new AppliedOperation()`
	`73`	`+ {`
	`74`	`+ Rectangle = rectangle,`
	`75`	`+ NonGenericProcessor = processor`
	`76`	`+ });`
	`77`	`+ return this;`
	`78`	`+ }`
	`79`	`+`
	`80`	`+ public IImageProcessingContext ApplyProcessor(IImageProcessor processor)`
	`81`	`+ {`
	`82`	`+ this.Applied.Add(new AppliedOperation()`
	`83`	`+ {`
	`84`	`+ NonGenericProcessor = processor`
	`85`	`+ });`
	`86`	`+ return this;`
	`87`	`+ }`
	`88`	`+`
`70`	`89`	`public IImageProcessingContext<TPixel> ApplyProcessor(IImageProcessor<TPixel> processor, Rectangle rectangle)`
`71`	`90`	`{`
`72`	`91`	`this.Applied.Add(new AppliedOperation`
`73`	`92`	`{`
`74`		`- Processor = processor,`
	`93`	`+ GenericProcessor = processor,`
`75`	`94`	`Rectangle = rectangle`
`76`	`95`	`});`
`77`	`96`	`return this;`
`@@ -81,15 +100,17 @@ public IImageProcessingContext<TPixel> ApplyProcessor(IImageProcessor<TPixel> pr`
`81`	`100`	`{`
`82`	`101`	`this.Applied.Add(new AppliedOperation`
`83`	`102`	`{`
`84`		`- Processor = processor`
	`103`	`+ GenericProcessor = processor`
`85`	`104`	`});`
`86`	`105`	`return this;`
`87`	`106`	`}`
`88`	`107`
`89`	`108`	`public struct AppliedOperation`
`90`	`109`	`{`
`91`	`110`	`public Rectangle? Rectangle { get; set; }`
`92`		`- public IImageProcessor<TPixel> Processor { get; set; }`
	`111`	`+ public IImageProcessor<TPixel> GenericProcessor { get; set; }`
	`112`	`+`
	`113`	`+ public IImageProcessor NonGenericProcessor { get; set; }`
`93`	`114`	`}`
`94`	`115`	`}`
`95`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public void MutateCallsImageOperationsProvider_Func_OriginalImage()`
`41`	`41`	`this.image.Mutate(x => x.ApplyProcessor(this.processor));`
`42`	`42`
`43`	`43`	`Assert.True(this.provider.HasCreated(this.image));`
`44`		`- Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));`
	`44`	`+ Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`[Fact]`
`@@ -50,7 +50,7 @@ public void MutateCallsImageOperationsProvider_ListOfProcessors_OriginalImage()`
`50`	`50`	`this.image.Mutate(this.processor);`
`51`	`51`
`52`	`52`	`Assert.True(this.provider.HasCreated(this.image));`
`53`		`- Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));`
	`53`	`+ Assert.Contains(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`[Fact]`
`@@ -59,7 +59,7 @@ public void CloneCallsImageOperationsProvider_Func_WithDuplicateImage()`
`59`	`59`	`Image<Rgba32> returned = this.image.Clone(x => x.ApplyProcessor(this.processor));`
`60`	`60`
`61`	`61`	`Assert.True(this.provider.HasCreated(returned));`
`62`		`- Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.Processor));`
	`62`	`+ Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.GenericProcessor));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`[Fact]`
`@@ -68,31 +68,31 @@ public void CloneCallsImageOperationsProvider_ListOfProcessors_WithDuplicateImag`
`68`	`68`	`Image<Rgba32> returned = this.image.Clone(this.processor);`
`69`	`69`
`70`	`70`	`Assert.True(this.provider.HasCreated(returned));`
`71`		`- Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.Processor));`
	`71`	`+ Assert.Contains(this.processor, this.provider.AppliedOperations(returned).Select(x => x.GenericProcessor));`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`[Fact]`
`75`	`75`	`public void CloneCallsImageOperationsProvider_Func_NotOnOrigional()`
`76`	`76`	`{`
`77`	`77`	`Image<Rgba32> returned = this.image.Clone(x => x.ApplyProcessor(this.processor));`
`78`	`78`	`Assert.False(this.provider.HasCreated(this.image));`
`79`		`- Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));`
	`79`	`+ Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`[Fact]`
`83`	`83`	`public void CloneCallsImageOperationsProvider_ListOfProcessors_NotOnOrigional()`
`84`	`84`	`{`
`85`	`85`	`Image<Rgba32> returned = this.image.Clone(this.processor);`
`86`	`86`	`Assert.False(this.provider.HasCreated(this.image));`
`87`		`- Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.Processor));`
	`87`	`+ Assert.DoesNotContain(this.processor, this.provider.AppliedOperations(this.image).Select(x => x.GenericProcessor));`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`[Fact]`
`91`	`91`	`public void ApplyProcessors_ListOfProcessors_AppliesAllProcessorsToOperation()`
`92`	`92`	`{`
`93`	`93`	`var operations = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(null, false);`
`94`	`94`	`operations.ApplyProcessors(this.processor);`
`95`		`- Assert.Contains(this.processor, operations.Applied.Select(x => x.Processor));`
	`95`	`+ Assert.Contains(this.processor, operations.Applied.Select(x => x.GenericProcessor));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`public void Dispose() => this.image.Dispose();`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ public string GetFileNameWithoutExtension(object value)`
`134`	`134`	`/// <returns>`
`135`	`135`	`/// The <see cref="ImageSharp.Image"/>.`
`136`	`136`	`/// </returns>`
`137`		`- public Image<Rgba32> CreateImage()`
	`137`	`+ public Image<Rgba32> CreateRgba32Image()`
`138`	`138`	`{`
`139`	`139`	`return this.Image.Clone();`
`140`	`140`	`}`
`@@ -145,9 +145,9 @@ public Image<Rgba32> CreateImage()`
`145`	`145`	`/// <returns>`
`146`	`146`	`/// The <see cref="ImageSharp.Image"/>.`
`147`	`147`	`/// </returns>`
`148`		`- public Image<Rgba32> CreateImage(IImageDecoder decoder)`
	`148`	`+ public Image<Rgba32> CreateRgba32Image(IImageDecoder decoder)`
`149`	`149`	`{`
`150`		`- return ImageSharp.Image.Load(this.Image.GetConfiguration(), this.Bytes, decoder);`
	`150`	`+ return ImageSharp.Image.Load<Rgba32>(this.Image.GetConfiguration(), this.Bytes, decoder);`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,29 +12,24 @@ namespace SixLabors.ImageSharp.Tests`
`12`	`12`	`/// </summary>`
`13`	`13`	`public class TestFileSystem : ImageSharp.IO.IFileSystem`
`14`	`14`	`{`
`15`		`-`
`16`		`- public static TestFileSystem Global { get; } = new TestFileSystem();`
`17`		`-`
`18`		`- public static void RegisterGlobalTestFormat()`
`19`		`- {`
`20`		`- Configuration.Default.FileSystem = Global;`
`21`		`- }`
`22`		`-`
`23`		`- Dictionary<string, Stream> fileSystem = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);`
	`15`	`+ private readonly Dictionary<string, Stream> fileSystem = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);`
`24`	`16`
`25`	`17`	`public void AddFile(string path, Stream data)`
`26`	`18`	`{`
`27`		`- fileSystem.Add(path, data);`
	`19`	`+ lock (this.fileSystem)`
	`20`	`+ {`
	`21`	`+ this.fileSystem.Add(path, data);`
	`22`	`+ }`
`28`	`23`	`}`
`29`	`24`
`30`	`25`	`public Stream Create(string path)`
`31`	`26`	`{`
`32`	`27`	`// if we have injected a fake file use it instead`
`33`		`- lock (fileSystem)`
	`28`	`+ lock (this.fileSystem)`
`34`	`29`	`{`
`35`		`- if (fileSystem.ContainsKey(path))`
	`30`	`+ if (this.fileSystem.ContainsKey(path))`
`36`	`31`	`{`
`37`		`- Stream stream = fileSystem[path];`
	`32`	`+ Stream stream = this.fileSystem[path];`
`38`	`33`	`stream.Position = 0;`
`39`	`34`	`return stream;`
`40`	`35`	`}`
`@@ -43,15 +38,14 @@ public Stream Create(string path)`
`43`	`38`	`return File.Create(path);`
`44`	`39`	`}`
`45`	`40`
`46`		`-`
`47`	`41`	`public Stream OpenRead(string path)`
`48`	`42`	`{`
`49`	`43`	`// if we have injected a fake file use it instead`
`50`		`- lock (fileSystem)`
	`44`	`+ lock (this.fileSystem)`
`51`	`45`	`{`
`52`		`- if (fileSystem.ContainsKey(path))`
	`46`	`+ if (this.fileSystem.ContainsKey(path))`
`53`	`47`	`{`
`54`		`- Stream stream = fileSystem[path];`
	`48`	`+ Stream stream = this.fileSystem[path];`
`55`	`49`	`stream.Position = 0;`
`56`	`50`	`return stream;`
`57`	`51`	`}`
`@@ -60,5 +54,4 @@ public Stream OpenRead(string path)`
`60`	`54`	`return File.OpenRead(path);`
`61`	`55`	`}`
`62`	`56`	`}`
`63`		`-}`
`64`		`-`
	`57`	`+}`