Imported Upstream version 3.10.0

Former-commit-id: 172c8e3c300b39d5785c7a3e8dfb08ebdbc1a99b

mcs/class/System.IO.Compression.FileSystem/Makefile

@@ -4,7 +4,6 @@ include ../../build/rules.make
 
 LIBRARY = System.IO.Compression.FileSystem.dll
 LIB_MCS_FLAGS = /r:System /r:System.IO.Compression.dll
-
-NO_TEST = yes
+TEST_MCS_FLAGS = /r:System /r:System.Core /r:System.IO.Compression.dll
 
 include ../../build/library.make

mcs/class/System.IO.Compression.FileSystem/System.IO.Compression.FileSystem_test.dll.sources

@@ -0,0 +1 @@
+System.IO.Compression.FileSystem/ZipTest.cs

mcs/class/System.IO.Compression.FileSystem/Test/System.IO.Compression.FileSystem/ZipTest.cs

@@ -0,0 +1,109 @@
+//
+// ZipTest.cs
+//
+// Author:
+//       João Matos <joao.matos@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Security.Cryptography;
+using NUnit.Framework;
+
+namespace MonoTests.System.IO.Compression.FileSystem
+{
+	[TestFixture]
+	public class ZipArchiveTests
+	{
+		[TearDown]
+		public void Dispose()
+		{
+			File.Delete ("foo.zip");
+		}
+
+		[Test]
+		public void ZipCreateFromDirectory()
+		{
+			if (File.Exists ("foo.zip"))
+				File.Delete ("foo.zip");
+
+			ZipFile.CreateFromDirectory ("foo", "foo.zip");
+			Assert.IsTrue(File.Exists("foo.zip"));
+
+			using (var archive = new ZipArchive (File.Open ("foo.zip", FileMode.Open),
+				ZipArchiveMode.Read))
+			{
+				Assert.IsNotNull (archive.GetEntry ("foo.txt"));
+				Assert.IsNotNull (archive.GetEntry ("bar.txt"));
+
+				Assert.IsNotNull (archive.GetEntry ("foobar/foo.txt"));
+				Assert.IsNotNull (archive.GetEntry ("foobar/bar.txt"));				
+			}
+		}
+
+		[Test]
+		public void ZipCreateFromDirectoryIncludeBase()
+		{
+			if (File.Exists ("foo.zip"))
+				File.Delete ("foo.zip");
+
+			ZipFile.CreateFromDirectory ("foo", "foo.zip", CompressionLevel.Fastest,
+				includeBaseDirectory: true);
+			Assert.IsTrue (File.Exists ("foo.zip"));
+
+			using (var archive = new ZipArchive (File.Open ("foo.zip", FileMode.Open),
+				ZipArchiveMode.Read))
+			{
+				Assert.IsNotNull (archive.GetEntry ("foo/foo.txt"));
+				Assert.IsNotNull (archive.GetEntry ("foo/bar.txt"));
+
+				Assert.IsNotNull (archive.GetEntry ("foo/foobar/foo.txt"));
+				Assert.IsNotNull (archive.GetEntry ("foo/foobar/bar.txt"));				
+			}
+		}		
+
+		[Test]
+		public void ZipExtractToDirectory()
+		{
+			if (Directory.Exists ("extract"))
+				Directory.Delete ("extract", true);
+
+			if (File.Exists ("foo.zip"))
+				File.Delete ("foo.zip");
+
+			ZipFile.CreateFromDirectory ("foo", "foo.zip");
+
+			ZipFile.ExtractToDirectory ("foo.zip", "extract");
+			Assert.IsTrue(Directory.Exists ("extract"));
+
+			Assert.IsTrue (File.Exists ("extract/foo.txt"));
+			Assert.IsTrue (File.Exists ("extract/bar.txt"));
+			Assert.IsTrue (Directory.Exists ("extract/foobar"));
+			Assert.IsTrue (File.Exists ("extract/foobar/foo.txt"));
+			Assert.IsTrue (File.Exists ("extract/foobar/bar.txt"));
+
+			Directory.Delete ("extract", true);
+		}
+	}
+}

mcs/class/System.IO.Compression.FileSystem/ZipFile.cs

@@ -2,6 +2,7 @@
 // ZipFile.cs
 //
 // Author:
+//       João Matos <joao.matos@xamarin.com>
 //       Martin Baulig <martin.baulig@xamarin.com>
 //
 // Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
@@ -28,20 +29,21 @@ using System.Text;
 
 namespace System.IO.Compression
 {
-	[MonoTODO]
 	public static class ZipFile
 	{
 		public static void CreateFromDirectory (
 			string sourceDirectoryName, string destinationArchiveFileName)
 		{
-			throw new NotImplementedException ();
+			CreateFromDirectory (sourceDirectoryName, destinationArchiveFileName,
+				CompressionLevel.Fastest, includeBaseDirectory: false);
 		}
 
 		public static void CreateFromDirectory (
 			string sourceDirectoryName, string destinationArchiveFileName,
 			CompressionLevel compressionLevel, bool includeBaseDirectory)
 		{
-			throw new NotImplementedException ();
+			CreateFromDirectory (sourceDirectoryName, destinationArchiveFileName,
+				CompressionLevel.Fastest, includeBaseDirectory, Encoding.UTF8);
 		}
 
 		public static void CreateFromDirectory (
@@ -51,38 +53,129 @@ namespace System.IO.Compression
 			bool includeBaseDirectory,
 			Encoding entryNameEncoding)
 		{
-			throw new NotImplementedException ();
+			if (sourceDirectoryName == null)
+				throw new ArgumentNullException ("sourceDirectoryName");
+
+			if (destinationArchiveFileName == null)
+				throw new ArgumentNullException ("destinationArchiveFileName");
+
+			if (string.IsNullOrWhiteSpace (sourceDirectoryName))
+				throw new ArgumentException ("sourceDirectoryName");
+				
+			if (string.IsNullOrWhiteSpace (destinationArchiveFileName))
+				throw new ArgumentException ("destinationArchiveFileName");
+
+			if (entryNameEncoding == Encoding.Unicode ||
+			    entryNameEncoding == Encoding.UTF32 ||
+			    entryNameEncoding == Encoding.UTF7)
+				throw new ArgumentException ("entryNameEncoding");
+
+			if (entryNameEncoding == null)
+				entryNameEncoding = Encoding.UTF8;
+
+			if (!Directory.Exists (sourceDirectoryName))
+				throw new DirectoryNotFoundException ("sourceDirectoryName is invalid or does not exist");
+
+			var sourceDir = new DirectoryInfo (Path.GetFullPath (sourceDirectoryName));
+
+			string fullBaseName = sourceDir.FullName;
+			if (includeBaseDirectory && sourceDir.Parent != null)
+				fullBaseName = sourceDir.Parent.FullName;
+
+			bool hasEntries = false;
+			char[] separators = new char[] {
+				Path.DirectorySeparatorChar,
+				Path.AltDirectorySeparatorChar
+			};
+
+			using (var zipFile = ZipFile.Open (destinationArchiveFileName, ZipArchiveMode.Create,
+				entryNameEncoding)) {
+				var entries = sourceDir.EnumerateFileSystemInfos ("*", SearchOption.AllDirectories);
+				foreach (var entry in entries) {
+					hasEntries = true;
+
+					int length = entry.FullName.Length - fullBaseName.Length;
+					string entryName = entry.FullName.Substring(fullBaseName.Length, length);
+
+					entryName = entryName.TrimStart(separators);
+
+					if (entry is FileInfo)
+						zipFile.CreateEntryFromFile (entry.FullName, entryName, compressionLevel);
+					else
+						zipFile.CreateEntry (entryName + Path.DirectorySeparatorChar);
+				}
+
+				// Create the base directory even if we had no entries
+				if (includeBaseDirectory && !hasEntries)
+					zipFile.CreateEntry(sourceDir.Name + Path.DirectorySeparatorChar);
+			}
 		}
 
 		public static void ExtractToDirectory (
 			string sourceArchiveFileName, string destinationDirectoryName)
 		{
-			throw new NotImplementedException ();
+			ExtractToDirectory (sourceArchiveFileName, destinationDirectoryName,
+				Encoding.UTF8);
 		}
 
 		public static void ExtractToDirectory (
 			string sourceArchiveFileName, string destinationDirectoryName,
 			Encoding entryNameEncoding)
 		{
-			throw new NotImplementedException ();
+			if (sourceArchiveFileName == null)
+				throw new ArgumentNullException ("sourceArchiveFileName");
+
+			using (ZipArchive zipArchive = ZipFile.Open(sourceArchiveFileName,
+				ZipArchiveMode.Read, entryNameEncoding))
+			{
+				zipArchive.ExtractToDirectory(destinationDirectoryName);
+			}
 		}
 
 		public static ZipArchive Open (
 			string archiveFileName, ZipArchiveMode mode)
 		{
-			throw new NotImplementedException ();
+			return Open (archiveFileName, mode);
 		}
 
 		public static ZipArchive Open (
 			string archiveFileName, ZipArchiveMode mode,
 			Encoding entryNameEncoding)
 		{
-			throw new NotImplementedException ();
+			if (archiveFileName == null)
+				throw new ArgumentNullException ("archiveFileName");
+
+			if (string.IsNullOrWhiteSpace (archiveFileName))
+				throw new ArgumentException ("archiveFileName");
+
+			FileStream stream;
+
+			switch (mode) {
+			case ZipArchiveMode.Read:
+				if (!File.Exists (archiveFileName))
+					throw new FileNotFoundException ();
+				stream = new FileStream (archiveFileName, FileMode.Open, FileAccess.Read,
+					FileShare.Read);
+				break;
+			case ZipArchiveMode.Create:
+				if (File.Exists (archiveFileName))
+					throw new IOException ("mode is set to Create but the file already exists");
+				stream = new FileStream (archiveFileName, FileMode.CreateNew, FileAccess.Write);
+				break;
+			case ZipArchiveMode.Update:
+				stream = new FileStream (archiveFileName, FileMode.OpenOrCreate,
+					FileAccess.ReadWrite);
+				break;
+			default:
+				throw new ArgumentOutOfRangeException ();
+			}
+
+			return new ZipArchive (stream, mode, false, entryNameEncoding);
 		}
 
 		public static ZipArchive OpenRead (string archiveFileName)
 		{
-			throw new NotImplementedException ();
+			return ZipFile.Open (archiveFileName, ZipArchiveMode.Read);
 		}
 	}
 }

mcs/class/System.IO.Compression.FileSystem/ZipFileExtensions.cs

@@ -2,6 +2,7 @@
 // ZipFileExtensions.cs
 //
 // Author:
+//       João Matos <joao.matos@xamarin.com>
 //       Martin Baulig <martin.baulig@xamarin.com>
 //
 // Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
@@ -27,43 +28,95 @@ using System;
 
 namespace System.IO.Compression
 {
-	[MonoTODO]
 	public static class ZipFileExtensions
 	{
 		public static ZipArchiveEntry CreateEntryFromFile (
 			this ZipArchive destination, string sourceFileName,
 			string entryName)
 		{
-			throw new NotImplementedException ();
+			return CreateEntryFromFile (destination, sourceFileName, entryName,
+				CompressionLevel.Fastest);
 		}
 
 		public static ZipArchiveEntry CreateEntryFromFile (
 			this ZipArchive destination, string sourceFileName,
-			string entryName, CompressionLevel compressionLevel
-			)
+			string entryName, CompressionLevel compressionLevel)
 		{
-			throw new NotImplementedException ();
+			if (destination == null)
+				throw new ArgumentNullException ("destination");
+
+			if (sourceFileName == null)
+				throw new ArgumentNullException ("sourceFileName");
+
+			if (entryName == null)
+				throw new ArgumentNullException ("entryName");
+
+			ZipArchiveEntry entry;
+			using (Stream stream = File.Open (sourceFileName, FileMode.Open,
+				FileAccess.Read, FileShare.Read))
+			{
+				var zipArchiveEntry = destination.CreateEntry (entryName, compressionLevel);
+
+				using (Stream entryStream = zipArchiveEntry.Open ())
+					stream.CopyTo (entryStream);
+
+				entry = zipArchiveEntry;
+			}
+
+			return entry;
 		}
 
 		public static void ExtractToDirectory (
 			this ZipArchive source,
 			string destinationDirectoryName)
 		{
-			throw new NotImplementedException ();
+			if (source == null)
+				throw new ArgumentNullException ("source");
+
+			if (destinationDirectoryName == null)
+				throw new ArgumentNullException ("destinationDirectoryName");
+
+			var destDirInfo = Directory.CreateDirectory (destinationDirectoryName);
+			string fullName = destDirInfo.FullName;
+
+			foreach (var zipEntry in source.Entries)
+			{
+				var fullPath = Path.GetFullPath (Path.Combine (fullName, zipEntry.FullName));
+
+				var isFileName = Path.GetFileName (fullPath).Length != 0;
+				var dirPath = isFileName ? Path.GetDirectoryName (fullPath) : fullPath;
+				Directory.CreateDirectory (dirPath);
+
+				if (isFileName)
+					zipEntry.ExtractToFile (fullPath, false);
+			}
 		}
 
 		public static void ExtractToFile (
 			this ZipArchiveEntry source,
 			string destinationFileName)
 		{
-			throw new NotImplementedException ();
+			ExtractToFile (source, destinationFileName, overwrite: false);
 		}
 
 		public static void ExtractToFile (
 			this ZipArchiveEntry source, string destinationFileName,
 			bool overwrite)
 		{
-			throw new NotImplementedException ();
+			if (source == null)
+				throw new ArgumentNullException ("source");
+
+			if (destinationFileName == null)
+				throw new ArgumentNullException ("destinationFileName");
+				
+			var mode = overwrite ? FileMode.Create : FileMode.CreateNew;
+			using (var stream = File.Open (destinationFileName, mode, FileAccess.Write))
+			{
+				using (var stream2 = source.Open ())
+					stream2.CopyTo(stream);
+			}
+
+			File.SetLastWriteTime(destinationFileName, source.LastWriteTime.DateTime);
 		}
 	}
 }