public void OpenFile_PassesFileMode()
{
TestHelper.WipeStores();
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
string file = "OpenFile_PassesFileMode";
using (isf.OpenFile(file, FileMode.CreateNew)) { }
Assert.True(isf.FileExists(file), "file exists");
Assert.Throws <IsolatedStorageException>(() => isf.OpenFile(file, FileMode.CreateNew));
using (isf.OpenFile(file, FileMode.Create)) { }
}
}
public void RemoveUserStoreForDomain()
{
TestHelper.WipeStores();
using (var isf = IsolatedStorageFile.GetUserStoreForDomain())
{
string root = isf.GetUserRootDirectory();
isf.Remove();
Assert.False(Directory.Exists(root), "store root folder should not exist");
string parent = Path.GetDirectoryName(root.TrimEnd(Path.DirectorySeparatorChar));
Assert.False(Directory.Exists(parent), "domain identity folder should not exist");
parent = Path.GetDirectoryName(root.TrimEnd(Path.DirectorySeparatorChar));
Assert.False(Directory.Exists(parent), "assembly identity folder should not exist");
}
}
public async Task DisposeAsync_FlushesAndCloses(PresetScopes scope)
{
TestHelper.WipeStores();
using (IsolatedStorageFile isf = GetPresetScope(scope))
{
IsolatedStorageFileStream isfs = isf.CreateFile("DisposeAsyncFile");
isfs.Write(new byte[100], 0, 100);
await isfs.DisposeAsync();
using (isfs = isf.OpenFile("DisposeAsyncFile", FileMode.Open))
{
Assert.Equal(100, isfs.Length);
}
}
}
public void DeleteFile_DeletesFile(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
using (var stream = isf.OpenFile("DeleteFile_DeletesFile", FileMode.Create))
{
}
Assert.True(isf.FileExists("DeleteFile_DeletesFile"));
isf.DeleteFile("DeleteFile_DeletesFile");
Assert.False(isf.FileExists("DeleteFile_DeletesFile"));
}
}
public void ContainsUnknownFiles_OkFiles(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
string rootDirectory = isf.GetIdentityRootDirectory();
string identityFile = Path.Combine(rootDirectory, "identity.dat");
string quotaFile = Path.Combine(rootDirectory, "info.dat");
using (File.OpenWrite(identityFile)) { }
Assert.False((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "identity ok");
File.Move(identityFile, quotaFile);
Assert.False((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "quota ok");
using (File.OpenWrite(identityFile)) { }
Assert.False((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "both ok");
}
}
public void GetFileNames_GetsFileNames(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
isf.CreateTestFile("A");
isf.CreateTestFile("B");
isf.CreateDirectory("C");
isf.CreateTestFile(Path.Combine("C", "D"));
isf.CreateTestFile(Path.Combine("C", "E"));
Assert.Equal(new string[] { "A", "B" }, isf.GetFileNames().OrderBy(s => s));
Assert.Equal(new string[] { "A", "B" }, isf.GetFileNames("*").OrderBy(s => s));
Assert.Equal(new string[] { "A" }, isf.GetFileNames("A"));
Assert.Equal(new string[] { "D", "E" }, isf.GetFileNames(Path.Combine("C", "*")).OrderBy(s => s));
Assert.Equal(new string[] { "D" }, isf.GetFileNames(Path.Combine("C", "D")));
}
}
public void DeleteDirectory_CannotDeleteWithContent(PresetScopes scope)
{
TestHelper.WipeStores();
// Validating that we aren't passing recursive:true
using (var isf = GetPresetScope(scope))
{
string directory = "DeleteDirectory_CannotDeleteWithContent";
isf.CreateDirectory(directory);
Assert.True(isf.DirectoryExists(directory), "directory exists");
string testFile = Path.Combine(directory, "content.file");
isf.CreateTestFile(testFile);
Assert.Throws <IsolatedStorageException>(() => isf.DeleteDirectory(directory));
isf.DeleteFile(testFile);
isf.DeleteDirectory(directory);
Assert.False(isf.DirectoryExists(directory));
}
}
public void OpenFile_Existence(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
string file = "OpenFile_Existence";
string subdirectory = "OpenFile_Existence_Subdirectory";
using (isf.OpenFile(file, FileMode.CreateNew)) { }
Assert.True(isf.FileExists(file), "file exists");
isf.CreateDirectory(subdirectory);
Assert.True(isf.DirectoryExists(subdirectory), "directory exists");
string nestedFile = Path.Combine(subdirectory, file);
using (isf.OpenFile(nestedFile, FileMode.CreateNew)) { }
Assert.True(isf.FileExists(nestedFile), "nested file exists");
}
}
public void ContainsUnknownFiles_NotOkFiles(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
string rootDirectory = isf.GetIdentityRootDirectory();
string otherFile = Path.Combine(rootDirectory, "ContainsUnknownFiles_NotOkFiles");
string identityFile = Path.Combine(rootDirectory, "identity.dat");
string quotaFile = Path.Combine(rootDirectory, "info.dat");
using (File.OpenWrite(otherFile)) { }
Assert.True((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "other file not ok");
using (File.OpenWrite(identityFile)) { }
Assert.True((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "other file with identity not ok");
File.Move(identityFile, quotaFile);
Assert.True((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "other file with quota not ok");
using (File.OpenWrite(identityFile)) { }
Assert.True((bool)s_containsUnknownFilesMethod.Invoke(isf, new object[] { rootDirectory }), "too many files not ok");
}
}
public void OpenFile_PassesFileAccess()
{
TestHelper.WipeStores();
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
string file = "OpenFile_PassesFileAccess";
using (var stream = isf.OpenFile(file, FileMode.CreateNew, FileAccess.Write))
{
Assert.True(isf.FileExists(file), "file exists");
stream.WriteByte(0xAB);
}
using (var stream = isf.OpenFile(file, FileMode.Open, FileAccess.Read))
{
Assert.Equal(0xAB, stream.ReadByte());
Assert.Throws <NotSupportedException>(() => stream.WriteByte(0xCD));
}
}
}
public void OpenFile_PassesFileShare()
{
TestHelper.WipeStores();
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly())
{
string file = "OpenFile_PassesFileShare";
using (var stream = isf.OpenFile(file, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite))
{
Assert.True(isf.FileExists(file), "file exists");
using (isf.OpenFile(file, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite)) { }
}
using (var stream = isf.OpenFile(file, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
Assert.True(isf.FileExists(file), "file exists");
Assert.Throws <IsolatedStorageException>(() => isf.OpenFile(file, FileMode.Open, FileAccess.ReadWrite));
}
}
}
public void MoveDirectory_MovesDirectory(PresetScopes scope)
{
TestHelper.WipeStores();
using (var isf = GetPresetScope(scope))
{
isf.CreateDirectory("foo");
isf.CreateTestFile(Path.Combine("foo", "foofile"), "MoveDirectory_MovesDirectory");
isf.MoveDirectory("foo", "bar");
Assert.True(isf.DirectoryExists("bar"), "bar exists");
Assert.False(isf.DirectoryExists("foo"), "foo doesn't exist");
Assert.Equal("MoveDirectory_MovesDirectory", isf.ReadAllText(Path.Combine("bar", "foofile")));
// Move into nested
isf.CreateDirectory("foo");
string nestedDirectory = Path.Combine("foo", "foobar");
isf.MoveDirectory("bar", nestedDirectory);
Assert.True(isf.DirectoryExists(nestedDirectory), "nested directory exists");
Assert.Equal("MoveDirectory_MovesDirectory", isf.ReadAllText(Path.Combine(nestedDirectory, "foofile")));
}
}
