// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
-using System.Collections.Generic;
using System.Linq;
+using System.Text;
using Xunit;
namespace System.IO.Tests
Assert.Throws<ArgumentOutOfRangeException>(() => new FileStreamOptions { BufferSize = -1 });
}
+
+ [Theory]
+ [InlineData(FileMode.Create, FileAccess.Write, FileOptions.None)]
+ [InlineData(FileMode.Create, FileAccess.Write, FileOptions.Asynchronous)]
+ [InlineData(FileMode.Open, FileAccess.Read, FileOptions.None)]
+ [InlineData(FileMode.Open, FileAccess.Read, FileOptions.Asynchronous)]
+ [InlineData(FileMode.Create, FileAccess.ReadWrite, FileOptions.None)]
+ [InlineData(FileMode.Create, FileAccess.ReadWrite, FileOptions.Asynchronous)]
+ public void SettingsArePropagated(FileMode mode, FileAccess access, FileOptions fileOptions)
+ {
+ string filePath = GetTestFilePath();
+ if (mode == FileMode.Open)
+ {
+ File.Create(filePath).Dispose();
+ }
+
+ bool canRead = (access & FileAccess.Read) != 0;
+ bool canWrite = (access & FileAccess.Write) != 0;
+ bool isAsync = (fileOptions & FileOptions.Asynchronous) != 0;
+
+ var options = new FileStreamOptions
+ {
+ Mode = mode,
+ Access = access,
+ Options = fileOptions
+ };
+
+ Validate(new FileStream(filePath, options), filePath, isAsync, canRead, canWrite);
+ Validate(File.Open(filePath, options), filePath, isAsync, canRead, canWrite);
+ Validate(new FileInfo(filePath).Open(options), filePath, isAsync, canRead, canWrite);
+
+ if (canWrite)
+ {
+ Validate((FileStream)new StreamWriter(filePath, options).BaseStream, filePath, isAsync, canRead, canWrite);
+ Validate((FileStream)new StreamWriter(filePath, Encoding.UTF8, options).BaseStream, filePath, isAsync, canRead, canWrite);
+ }
+
+ if (canRead)
+ {
+ Validate((FileStream)new StreamReader(filePath, options).BaseStream, filePath, isAsync, canRead, canWrite);
+ Validate((FileStream)new StreamReader(filePath, Encoding.UTF8, false, options).BaseStream, filePath, isAsync, canRead, canWrite);
+ }
+
+ static void Validate(FileStream fs, string expectedPath, bool expectedAsync, bool expectedCanRead, bool expectedCanWrite)
+ {
+ using (fs)
+ {
+ Assert.Equal(expectedPath, fs.Name);
+ Assert.Equal(expectedAsync, fs.IsAsync);
+ Assert.Equal(expectedCanRead, fs.CanRead);
+ Assert.Equal(expectedCanWrite, fs.CanWrite);
+ }
+ }
+ }
}
}
AssertExtensions.Throws<ArgumentOutOfRangeException>("bufferSize", () => new StreamReader("path", Encoding.UTF8, true, 0));
}
+ [Fact]
+ public static void LackOfReadAccess_ThrowsArgumentException()
+ {
+ var noReadAccess = new FileStreamOptions { Access = FileAccess.Write };
+
+ AssertExtensions.Throws<ArgumentException>("options", () => new StreamReader("path", noReadAccess));
+ AssertExtensions.Throws<ArgumentException>("options", () => new StreamReader("path", Encoding.UTF8, false, noReadAccess));
+ AssertExtensions.Throws<ArgumentException>("options", () => new StreamReader("path", Encoding.UTF8, true, noReadAccess));
+ }
+
[Theory]
[InlineData(true)]
[InlineData(false)]