21327634179

Committed 25 Jan 2026 05:35AM UTC coverage: 42.23% (-0.02%) from 42.249%

Build # 21327634179

Build Type

push

github

Committed by

MeltyPlayer

Commit Message

Okay, I think we're back to baseline now?

Run Details

6863 of 18402 branches covered (37.29%)

Branch coverage included in aggregate %.

29404 of 67477 relevant lines covered (43.58%)

64428.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.11

/FinModelUtility/Fin/Fin/src/io/filesystem/ComplexFileSystem_File.cs

﻿using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.IO.Abstractions;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

using Microsoft.Win32.SafeHandles;

using Encoding = System.Text.Encoding;

namespace fin.io.filesystem;

public partial class ComplexFileSystem {
  public IFile File { get; }

  private sealed class FileImpl(ComplexFileSystem impl) : IFile {
    public IFileSystem FileSystem => impl;

    // Tricky
    public void Move(string sourceFileName, string destFileName) {
      var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);
      var destFileSystem = impl.GetFileSystemForPath_(destFileName);

      if (sourceFileSystem == destFileSystem) {
        sourceFileSystem.File.Move(sourceFileName, destFileName);
        return;
      }

      throw new NotImplementedException();
    }

    public void Move(string sourceFileName,
                     string destFileName,
                     bool overwrite) {
      var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);
      var destFileSystem = impl.GetFileSystemForPath_(destFileName);

      if (sourceFileSystem == destFileSystem) {
        sourceFileSystem.File.Move(sourceFileName, destFileName, overwrite);
        return;
      }

      throw new NotImplementedException();
    }

    public void Copy(string sourceFileName, string destFileName) {
      var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);
      var destFileSystem = impl.GetFileSystemForPath_(destFileName);

      if (sourceFileSystem == destFileSystem) {
        sourceFileSystem.File.Copy(sourceFileName, destFileName);
        return;
      }

      throw new NotImplementedException();
    }

    public void Copy(string sourceFileName,
                     string destFileName,
                     bool overwrite) {
      var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);
      var destFileSystem = impl.GetFileSystemForPath_(destFileName);

      if (sourceFileSystem == destFileSystem) {
        sourceFileSystem.File.Copy(sourceFileName, destFileName, overwrite);
        return;
      }

      throw new NotImplementedException();
    }

    public void Replace(string sourceFileName,
                        string destinationFileName,
                        string? destinationBackupFileName) {
      throw new NotImplementedException();
    }

    public void Replace(string sourceFileName,
                        string destinationFileName,
                        string? destinationBackupFileName,
                        bool ignoreMetadataErrors) {
      throw new NotImplementedException();
    }

    // Simple
    public void AppendAllBytes(string path, byte[] bytes)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllBytes(path, bytes);

    public void AppendAllBytes(string path, ReadOnlySpan<byte> bytes)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllBytes(path, bytes);

    public Task AppendAllBytesAsync(
        string path,
        byte[] bytes,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllBytesAsync(path, bytes, cancellationToken);

    public Task AppendAllBytesAsync(
        string path,
        ReadOnlyMemory<byte> bytes,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllBytesAsync(path, bytes, cancellationToken);

    public void AppendAllLines(string path, IEnumerable<string> contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllLines(path, contents);

    public void AppendAllLines(string path,
                               IEnumerable<string> contents,
                               Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllLines(path, contents, encoding);

    public Task AppendAllLinesAsync(
        string path,
        IEnumerable<string> contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllLinesAsync(path, contents, cancellationToken);

    public Task AppendAllLinesAsync(
        string path,
        IEnumerable<string> contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllLinesAsync(path, contents, encoding, cancellationToken);

    public void AppendAllText(string path, string? contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllText(path, contents);

    public void AppendAllText(string path,
                              string? contents,
                              Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllText(path, contents, encoding);

    public void AppendAllText(string path, ReadOnlySpan<char> contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllText(path, contents);

    public void AppendAllText(string path,
                              ReadOnlySpan<char> contents,
                              Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllText(path, contents, encoding);

    public Task AppendAllTextAsync(
        string path,
        string? contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllTextAsync(path, contents, cancellationToken);

    public Task AppendAllTextAsync(
        string path,
        string? contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllTextAsync(path, contents, encoding, cancellationToken);

    public Task AppendAllTextAsync(
        string path,
        ReadOnlyMemory<char> contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllTextAsync(path, contents, cancellationToken);

    public Task AppendAllTextAsync(
        string path,
        ReadOnlyMemory<char> contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendAllTextAsync(path, contents, encoding, cancellationToken);

    public StreamWriter AppendText(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .AppendText(path);

    public FileSystemStream Create(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .Create(path);

    public FileSystemStream Create(string path, int bufferSize)
      => impl.GetFileSystemForPath_(path)
             .File
             .Create(path, bufferSize);

    public FileSystemStream Create(string path,
                                   int bufferSize,
                                   FileOptions options)
      => impl.GetFileSystemForPath_(path)
             .File
             .Create(path, bufferSize, options);

    public IFileSystemInfo CreateSymbolicLink(
        string path,
        string pathToTarget)
      => impl.GetFileSystemForPath_(path)
             .File
             .CreateSymbolicLink(path, pathToTarget);

    public StreamWriter CreateText(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .CreateText(path);

    public void Decrypt(string path) {
      if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
        throw new NotImplementedException();
      }

      impl.GetFileSystemForPath_(path)
          .File
          .Decrypt(path);
    }

    public void Encrypt(string path) {
      if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
        throw new NotImplementedException();
      }

      impl.GetFileSystemForPath_(path)
          .File
          .Encrypt(path);
    }

    public void Delete(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .Delete(path);

    public bool Exists([NotNullWhen(true)] string? path)
      => impl.GetFileSystemForPath_(path!)
             .File
             .Exists(path);

    public FileAttributes GetAttributes(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetAttributes(path);

    public DateTime GetCreationTime(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetCreationTime(path);

    public DateTime GetCreationTimeUtc(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetCreationTimeUtc(path);

    public DateTime GetLastAccessTime(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetLastAccessTime(path);

    public DateTime GetLastAccessTimeUtc(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetLastAccessTimeUtc(path);

    public DateTime GetLastWriteTime(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetLastWriteTime(path);

    public DateTime GetLastWriteTimeUtc(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .GetLastWriteTimeUtc(path);

    public UnixFileMode GetUnixFileMode(string path) {
      if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
        throw new NotImplementedException();
      }
      
      return impl.GetFileSystemForPath_(path)
                 .File
                 .GetUnixFileMode(path);
    }

    public void SetUnixFileMode(string path, UnixFileMode mode) {
      if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
        throw new NotImplementedException();
      }

      impl.GetFileSystemForPath_(path)
          .File
          .SetUnixFileMode(path, mode);
    }

    public FileSystemStream Open(string path, FileMode mode)
      => impl.GetFileSystemForPath_(path)
             .File
             .Open(path, mode);

    public FileSystemStream Open(
        string path,
        FileMode mode,
        FileAccess access)
      => impl.GetFileSystemForPath_(path)
             .File
             .Open(path, mode, access);

    public FileSystemStream Open(string path,
                                 FileMode mode,
                                 FileAccess access,
                                 FileShare share)
      => impl.GetFileSystemForPath_(path)
             .File
             .Open(path, mode, access, share);

    public FileSystemStream Open(string path, FileStreamOptions options)
      => impl.GetFileSystemForPath_(path)
             .File
             .Open(path, options);

    public FileSystemStream OpenRead(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .OpenRead(path);

    public StreamReader OpenText(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .OpenText(path);

    public FileSystemStream OpenWrite(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .OpenWrite(path);

    public byte[] ReadAllBytes(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllBytes(path);

    public Task<byte[]> ReadAllBytesAsync(
        string path,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllBytesAsync(path, cancellationToken);

    public string[] ReadAllLines(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllLines(path);

    public string[] ReadAllLines(string path, Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllLines(path, encoding);

    public Task<string[]> ReadAllLinesAsync(
        string path,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllLinesAsync(path, cancellationToken);

    public Task<string[]> ReadAllLinesAsync(
        string path,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllLinesAsync(path, encoding, cancellationToken);

    public string ReadAllText(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllText(path);

    public string ReadAllText(string path, Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllText(path, encoding);

    public Task<string> ReadAllTextAsync(
        string path,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllTextAsync(path, cancellationToken);

    public Task<string> ReadAllTextAsync(
        string path,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadAllTextAsync(path, encoding, cancellationToken);

    public IEnumerable<string> ReadLines(string path)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadLines(path);

    public IEnumerable<string> ReadLines(string path, Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadLines(path, encoding);

    public IAsyncEnumerable<string> ReadLinesAsync(
        string path,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadLinesAsync(path, cancellationToken);

    public IAsyncEnumerable<string> ReadLinesAsync(
        string path,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .ReadLinesAsync(path, encoding, cancellationToken);

    public IFileSystemInfo? ResolveLinkTarget(string linkPath,
                                              bool returnFinalTarget)
      => impl.GetFileSystemForPath_(linkPath)
             .File
             .ResolveLinkTarget(linkPath, returnFinalTarget);

    public void SetAttributes(string path, FileAttributes fileAttributes)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetAttributes(path, fileAttributes);

    public void SetCreationTime(string path, DateTime creationTime)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetCreationTime(path, creationTime);

    public void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetCreationTimeUtc(path, creationTimeUtc);

    public void SetLastAccessTime(string path, DateTime lastAccessTime)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetLastAccessTime(path, lastAccessTime);

    public void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetLastAccessTimeUtc(path, lastAccessTimeUtc);

    public void SetLastWriteTime(string path, DateTime lastWriteTime)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetLastWriteTime(path, lastWriteTime);

    public void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
      => impl.GetFileSystemForPath_(path)
             .File
             .SetLastWriteTimeUtc(path, lastWriteTimeUtc);

    public void WriteAllBytes(string path, byte[] bytes)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllBytes(path, bytes);

    public void WriteAllBytes(string path, ReadOnlySpan<byte> bytes)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllBytes(path, bytes);

    public Task WriteAllBytesAsync(
        string path,
        byte[] bytes,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllBytesAsync(path, bytes, cancellationToken);

    public Task WriteAllBytesAsync(
        string path,
        ReadOnlyMemory<byte> bytes,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllBytesAsync(path, bytes, cancellationToken);

    public void WriteAllLines(string path, string[] contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLines(path, contents);

    public void WriteAllLines(string path, IEnumerable<string> contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLines(path, contents);

    public void WriteAllLines(string path,
                              string[] contents,
                              Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLines(path, contents, encoding);

    public void WriteAllLines(string path,
                              IEnumerable<string> contents,
                              Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLines(path, contents, encoding);

    public Task WriteAllLinesAsync(
        string path,
        IEnumerable<string> contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLinesAsync(path, contents, cancellationToken);

    public Task WriteAllLinesAsync(
        string path,
        IEnumerable<string> contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllLinesAsync(path, contents, encoding, cancellationToken);

    public void WriteAllText(string path, string? contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllText(path, contents);

    public void WriteAllText(string path, string? contents, Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllText(path, contents, encoding);

    public void WriteAllText(string path, ReadOnlySpan<char> contents)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllText(path, contents);

    public void WriteAllText(string path,
                             ReadOnlySpan<char> contents,
                             Encoding encoding)
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllText(path, contents, encoding);

    public Task WriteAllTextAsync(
        string path,
        string? contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllTextAsync(path, contents, cancellationToken);

    public Task WriteAllTextAsync(
        string path,
        string? contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllTextAsync(path, contents, encoding, cancellationToken);

    public Task WriteAllTextAsync(
        string path,
        ReadOnlyMemory<char> contents,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllTextAsync(path, contents, cancellationToken);

    public Task WriteAllTextAsync(
        string path,
        ReadOnlyMemory<char> contents,
        Encoding encoding,
        CancellationToken cancellationToken = new())
      => impl.GetFileSystemForPath_(path)
             .File
             .WriteAllTextAsync(path, contents, encoding, cancellationToken);

    // Unsupported

    public FileAttributes GetAttributes(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetCreationTime(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetCreationTimeUtc(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetLastAccessTime(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetLastAccessTimeUtc(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetLastWriteTime(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public DateTime GetLastWriteTimeUtc(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public UnixFileMode GetUnixFileMode(SafeFileHandle fileHandle)
      => throw new NotImplementedException();

    public void SetAttributes(SafeFileHandle fileHandle,
                              FileAttributes fileAttributes)
      => throw new NotImplementedException();

    public void SetCreationTime(SafeFileHandle fileHandle,
                                DateTime creationTime)
      => throw new NotImplementedException();

    public void SetCreationTimeUtc(SafeFileHandle fileHandle,
                                   DateTime creationTimeUtc)
      => throw new NotImplementedException();

    public void SetLastAccessTime(SafeFileHandle fileHandle,
                                  DateTime lastAccessTime)
      => throw new NotImplementedException();

    public void SetLastAccessTimeUtc(SafeFileHandle fileHandle,
                                     DateTime lastAccessTimeUtc)
      => throw new NotImplementedException();

    public void SetLastWriteTime(SafeFileHandle fileHandle,
                                 DateTime lastWriteTime)
      => throw new NotImplementedException();

    public void SetLastWriteTimeUtc(SafeFileHandle fileHandle,
                                    DateTime lastWriteTimeUtc)
      => throw new NotImplementedException();

    public void SetUnixFileMode(SafeFileHandle fileHandle, UnixFileMode mode)
      => throw new NotImplementedException();
  }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.IO;
5	using System.IO.Abstractions;
6	using System.Runtime.InteropServices;
7	using System.Threading;
8	using System.Threading.Tasks;
9
10	using Microsoft.Win32.SafeHandles;
11
12	using Encoding = System.Text.Encoding;
13
14	namespace fin.io.filesystem;
15
16	public partial class ComplexFileSystem {
17	public IFile File { get; }	18,270✔
18
19	private sealed class FileImpl(ComplexFileSystem impl) : IFile {	22✔
20	public IFileSystem FileSystem => impl;	×
21
22	// Tricky
23	public void Move(string sourceFileName, string destFileName) {	×
24	var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);	×
25	var destFileSystem = impl.GetFileSystemForPath_(destFileName);	×
26
27	if (sourceFileSystem == destFileSystem) {	×
28	sourceFileSystem.File.Move(sourceFileName, destFileName);	×
29	return;	×
30	}
31
32	throw new NotImplementedException();	×
33	}	×
34
35	public void Move(string sourceFileName,
36	string destFileName,
37	bool overwrite) {	×
38	var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);	×
39	var destFileSystem = impl.GetFileSystemForPath_(destFileName);	×
40
41	if (sourceFileSystem == destFileSystem) {	×
42	sourceFileSystem.File.Move(sourceFileName, destFileName, overwrite);	×
43	return;	×
44	}
45
46	throw new NotImplementedException();	×
47	}	×
48
49	public void Copy(string sourceFileName, string destFileName) {	×
50	var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);	×
51	var destFileSystem = impl.GetFileSystemForPath_(destFileName);	×
52
53	if (sourceFileSystem == destFileSystem) {	×
54	sourceFileSystem.File.Copy(sourceFileName, destFileName);	×
55	return;	×
56	}
57
58	throw new NotImplementedException();	×
59	}	×
60
61	public void Copy(string sourceFileName,
62	string destFileName,
63	bool overwrite) {	×
64	var sourceFileSystem = impl.GetFileSystemForPath_(sourceFileName);	×
65	var destFileSystem = impl.GetFileSystemForPath_(destFileName);	×
66
67	if (sourceFileSystem == destFileSystem) {	×
68	sourceFileSystem.File.Copy(sourceFileName, destFileName, overwrite);	×
69	return;	×
70	}
71
72	throw new NotImplementedException();	×
73	}	×
74
75	public void Replace(string sourceFileName,
76	string destinationFileName,
77	string? destinationBackupFileName) {	×
78	throw new NotImplementedException();	×
79	}
80
81	public void Replace(string sourceFileName,
82	string destinationFileName,
83	string? destinationBackupFileName,
84	bool ignoreMetadataErrors) {	×
85	throw new NotImplementedException();	×
86	}
87
88	// Simple
89	public void AppendAllBytes(string path, byte[] bytes)
90	=> impl.GetFileSystemForPath_(path)	×
91	.File	×
92	.AppendAllBytes(path, bytes);	×
93
94	public void AppendAllBytes(string path, ReadOnlySpan<byte> bytes)
95	=> impl.GetFileSystemForPath_(path)	×
96	.File	×
97	.AppendAllBytes(path, bytes);	×
98
99	public Task AppendAllBytesAsync(
100	string path,
101	byte[] bytes,
102	CancellationToken cancellationToken = new())
103	=> impl.GetFileSystemForPath_(path)	×
104	.File	×
105	.AppendAllBytesAsync(path, bytes, cancellationToken);	×
106
107	public Task AppendAllBytesAsync(
108	string path,
109	ReadOnlyMemory<byte> bytes,
110	CancellationToken cancellationToken = new())
111	=> impl.GetFileSystemForPath_(path)	×
112	.File	×
113	.AppendAllBytesAsync(path, bytes, cancellationToken);	×
114
115	public void AppendAllLines(string path, IEnumerable<string> contents)
116	=> impl.GetFileSystemForPath_(path)	×
117	.File	×
118	.AppendAllLines(path, contents);	×
119
120	public void AppendAllLines(string path,
121	IEnumerable<string> contents,
122	Encoding encoding)
123	=> impl.GetFileSystemForPath_(path)	×
124	.File	×
125	.AppendAllLines(path, contents, encoding);	×
126
127	public Task AppendAllLinesAsync(
128	string path,
129	IEnumerable<string> contents,
130	CancellationToken cancellationToken = new())
131	=> impl.GetFileSystemForPath_(path)	×
132	.File	×
133	.AppendAllLinesAsync(path, contents, cancellationToken);	×
134
135	public Task AppendAllLinesAsync(
136	string path,
137	IEnumerable<string> contents,
138	Encoding encoding,
139	CancellationToken cancellationToken = new())
140	=> impl.GetFileSystemForPath_(path)	×
141	.File	×
142	.AppendAllLinesAsync(path, contents, encoding, cancellationToken);	×
143
144	public void AppendAllText(string path, string? contents)
145	=> impl.GetFileSystemForPath_(path)	×
146	.File	×
147	.AppendAllText(path, contents);	×
148
149	public void AppendAllText(string path,
150	string? contents,
151	Encoding encoding)
152	=> impl.GetFileSystemForPath_(path)	×
153	.File	×
154	.AppendAllText(path, contents, encoding);	×
155
156	public void AppendAllText(string path, ReadOnlySpan<char> contents)
157	=> impl.GetFileSystemForPath_(path)	×
158	.File	×
159	.AppendAllText(path, contents);	×
160
161	public void AppendAllText(string path,
162	ReadOnlySpan<char> contents,
163	Encoding encoding)
164	=> impl.GetFileSystemForPath_(path)	×
165	.File	×
166	.AppendAllText(path, contents, encoding);	×
167
168	public Task AppendAllTextAsync(
169	string path,
170	string? contents,
171	CancellationToken cancellationToken = new())
172	=> impl.GetFileSystemForPath_(path)	×
173	.File	×
174	.AppendAllTextAsync(path, contents, cancellationToken);	×
175
176	public Task AppendAllTextAsync(
177	string path,
178	string? contents,
179	Encoding encoding,
180	CancellationToken cancellationToken = new())
181	=> impl.GetFileSystemForPath_(path)	×
182	.File	×
183	.AppendAllTextAsync(path, contents, encoding, cancellationToken);	×
184
185	public Task AppendAllTextAsync(
186	string path,
187	ReadOnlyMemory<char> contents,
188	CancellationToken cancellationToken = new())
189	=> impl.GetFileSystemForPath_(path)	×
190	.File	×
191	.AppendAllTextAsync(path, contents, cancellationToken);	×
192
193	public Task AppendAllTextAsync(
194	string path,
195	ReadOnlyMemory<char> contents,
196	Encoding encoding,
197	CancellationToken cancellationToken = new())
198	=> impl.GetFileSystemForPath_(path)	×
199	.File	×
200	.AppendAllTextAsync(path, contents, encoding, cancellationToken);	×
201
202	public StreamWriter AppendText(string path)
203	=> impl.GetFileSystemForPath_(path)	×
204	.File	×
205	.AppendText(path);	×
206
207	public FileSystemStream Create(string path)
208	=> impl.GetFileSystemForPath_(path)	81✔
209	.File	81✔
210	.Create(path);	81✔
211
212	public FileSystemStream Create(string path, int bufferSize)
213	=> impl.GetFileSystemForPath_(path)	×
214	.File	×
215	.Create(path, bufferSize);	×
216
217	public FileSystemStream Create(string path,
218	int bufferSize,
219	FileOptions options)
220	=> impl.GetFileSystemForPath_(path)	×
221	.File	×
222	.Create(path, bufferSize, options);	×
223
224	public IFileSystemInfo CreateSymbolicLink(
225	string path,
226	string pathToTarget)
227	=> impl.GetFileSystemForPath_(path)	×
228	.File	×
229	.CreateSymbolicLink(path, pathToTarget);	×
230
231	public StreamWriter CreateText(string path)
232	=> impl.GetFileSystemForPath_(path)	×
233	.File	×
234	.CreateText(path);	×
235
236	public void Decrypt(string path) {	×
237	if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {	×
238	throw new NotImplementedException();	×
239	}
240
241	impl.GetFileSystemForPath_(path)	×
242	.File	×
243	.Decrypt(path);	×
244	}	×
245
246	public void Encrypt(string path) {	×
247	if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {	×
248	throw new NotImplementedException();	×
249	}
250
251	impl.GetFileSystemForPath_(path)	×
252	.File	×
253	.Encrypt(path);	×
254	}	×
255
256	public void Delete(string path)
257	=> impl.GetFileSystemForPath_(path)	×
258	.File	×
259	.Delete(path);	×
260
261	public bool Exists([NotNullWhen(true)] string? path)
262	=> impl.GetFileSystemForPath_(path!)	128✔
263	.File	128✔
264	.Exists(path);	128✔
265
266	public FileAttributes GetAttributes(string path)
267	=> impl.GetFileSystemForPath_(path)	×
268	.File	×
269	.GetAttributes(path);	×
270
271	public DateTime GetCreationTime(string path)
272	=> impl.GetFileSystemForPath_(path)	×
273	.File	×
274	.GetCreationTime(path);	×
275
276	public DateTime GetCreationTimeUtc(string path)
277	=> impl.GetFileSystemForPath_(path)	×
278	.File	×
279	.GetCreationTimeUtc(path);	×
280
281	public DateTime GetLastAccessTime(string path)
282	=> impl.GetFileSystemForPath_(path)	×
283	.File	×
284	.GetLastAccessTime(path);	×
285
286	public DateTime GetLastAccessTimeUtc(string path)
287	=> impl.GetFileSystemForPath_(path)	×
288	.File	×
289	.GetLastAccessTimeUtc(path);	×
290
291	public DateTime GetLastWriteTime(string path)
292	=> impl.GetFileSystemForPath_(path)	×
293	.File	×
294	.GetLastWriteTime(path);	×
295
296	public DateTime GetLastWriteTimeUtc(string path)
297	=> impl.GetFileSystemForPath_(path)	×
298	.File	×
299	.GetLastWriteTimeUtc(path);	×
300
301	public UnixFileMode GetUnixFileMode(string path) {	×
302	if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {	×
303	throw new NotImplementedException();	×
304	}
305
306	return impl.GetFileSystemForPath_(path)	×
307	.File	×
308	.GetUnixFileMode(path);	×
309	}	×
310
311	public void SetUnixFileMode(string path, UnixFileMode mode) {	×
312	if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {	×
313	throw new NotImplementedException();	×
314	}
315
316	impl.GetFileSystemForPath_(path)	×
317	.File	×
318	.SetUnixFileMode(path, mode);	×
319	}	×
320
321	public FileSystemStream Open(string path, FileMode mode)
322	=> impl.GetFileSystemForPath_(path)	×
323	.File	×
324	.Open(path, mode);	×
325
326	public FileSystemStream Open(
327	string path,
328	FileMode mode,
329	FileAccess access)
330	=> impl.GetFileSystemForPath_(path)	×
331	.File	×
332	.Open(path, mode, access);	×
333
334	public FileSystemStream Open(string path,
335	FileMode mode,
336	FileAccess access,
337	FileShare share)
338	=> impl.GetFileSystemForPath_(path)	×
339	.File	×
340	.Open(path, mode, access, share);	×
341
342	public FileSystemStream Open(string path, FileStreamOptions options)
343	=> impl.GetFileSystemForPath_(path)	×
344	.File	×
345	.Open(path, options);	×
346
347	public FileSystemStream OpenRead(string path)
348	=> impl.GetFileSystemForPath_(path)	12,402✔
349	.File	12,402✔
350	.OpenRead(path);	12,402✔
351
352	public StreamReader OpenText(string path)
353	=> impl.GetFileSystemForPath_(path)	×
354	.File	×
355	.OpenText(path);	×
356
357	public FileSystemStream OpenWrite(string path)
358	=> impl.GetFileSystemForPath_(path)	4,794✔
359	.File	4,794✔
360	.OpenWrite(path);	4,794✔
361
362	public byte[] ReadAllBytes(string path)
363	=> impl.GetFileSystemForPath_(path)	×
364	.File	×
365	.ReadAllBytes(path);	×
366
367	public Task<byte[]> ReadAllBytesAsync(
368	string path,
369	CancellationToken cancellationToken = new())
370	=> impl.GetFileSystemForPath_(path)	×
371	.File	×
372	.ReadAllBytesAsync(path, cancellationToken);	×
373
374	public string[] ReadAllLines(string path)
375	=> impl.GetFileSystemForPath_(path)	×
376	.File	×
377	.ReadAllLines(path);	×
378
379	public string[] ReadAllLines(string path, Encoding encoding)
380	=> impl.GetFileSystemForPath_(path)	×
381	.File	×
382	.ReadAllLines(path, encoding);	×
383
384	public Task<string[]> ReadAllLinesAsync(
385	string path,
386	CancellationToken cancellationToken = new())
387	=> impl.GetFileSystemForPath_(path)	×
388	.File	×
389	.ReadAllLinesAsync(path, cancellationToken);	×
390
391	public Task<string[]> ReadAllLinesAsync(
392	string path,
393	Encoding encoding,
394	CancellationToken cancellationToken = new())
395	=> impl.GetFileSystemForPath_(path)	×
396	.File	×
397	.ReadAllLinesAsync(path, encoding, cancellationToken);	×
398
399	public string ReadAllText(string path)
400	=> impl.GetFileSystemForPath_(path)	×
401	.File	×
402	.ReadAllText(path);	×
403
404	public string ReadAllText(string path, Encoding encoding)
405	=> impl.GetFileSystemForPath_(path)	×
406	.File	×
407	.ReadAllText(path, encoding);	×
408
409	public Task<string> ReadAllTextAsync(
410	string path,
411	CancellationToken cancellationToken = new())
412	=> impl.GetFileSystemForPath_(path)	×
413	.File	×
414	.ReadAllTextAsync(path, cancellationToken);	×
415
416	public Task<string> ReadAllTextAsync(
417	string path,
418	Encoding encoding,
419	CancellationToken cancellationToken = new())
420	=> impl.GetFileSystemForPath_(path)	×
421	.File	×
422	.ReadAllTextAsync(path, encoding, cancellationToken);	×
423
424	public IEnumerable<string> ReadLines(string path)
425	=> impl.GetFileSystemForPath_(path)	×
426	.File	×
427	.ReadLines(path);	×
428
429	public IEnumerable<string> ReadLines(string path, Encoding encoding)
430	=> impl.GetFileSystemForPath_(path)	×
431	.File	×
432	.ReadLines(path, encoding);	×
433
434	public IAsyncEnumerable<string> ReadLinesAsync(
435	string path,
436	CancellationToken cancellationToken = new())
437	=> impl.GetFileSystemForPath_(path)	×
438	.File	×
439	.ReadLinesAsync(path, cancellationToken);	×
440
441	public IAsyncEnumerable<string> ReadLinesAsync(
442	string path,
443	Encoding encoding,
444	CancellationToken cancellationToken = new())
445	=> impl.GetFileSystemForPath_(path)	×
446	.File	×
447	.ReadLinesAsync(path, encoding, cancellationToken);	×
448
449	public IFileSystemInfo? ResolveLinkTarget(string linkPath,
450	bool returnFinalTarget)
451	=> impl.GetFileSystemForPath_(linkPath)	×
452	.File	×
453	.ResolveLinkTarget(linkPath, returnFinalTarget);	×
454
455	public void SetAttributes(string path, FileAttributes fileAttributes)
456	=> impl.GetFileSystemForPath_(path)	×
457	.File	×
458	.SetAttributes(path, fileAttributes);	×
459
460	public void SetCreationTime(string path, DateTime creationTime)
461	=> impl.GetFileSystemForPath_(path)	×
462	.File	×
463	.SetCreationTime(path, creationTime);	×
464
465	public void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
466	=> impl.GetFileSystemForPath_(path)	×
467	.File	×
468	.SetCreationTimeUtc(path, creationTimeUtc);	×
469
470	public void SetLastAccessTime(string path, DateTime lastAccessTime)
471	=> impl.GetFileSystemForPath_(path)	×
472	.File	×
473	.SetLastAccessTime(path, lastAccessTime);	×
474
475	public void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
476	=> impl.GetFileSystemForPath_(path)	×
477	.File	×
478	.SetLastAccessTimeUtc(path, lastAccessTimeUtc);	×
479
480	public void SetLastWriteTime(string path, DateTime lastWriteTime)
481	=> impl.GetFileSystemForPath_(path)	×
482	.File	×
483	.SetLastWriteTime(path, lastWriteTime);	×
484
485	public void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
486	=> impl.GetFileSystemForPath_(path)	×
487	.File	×
488	.SetLastWriteTimeUtc(path, lastWriteTimeUtc);	×
489
490	public void WriteAllBytes(string path, byte[] bytes)
491	=> impl.GetFileSystemForPath_(path)	×
492	.File	×
493	.WriteAllBytes(path, bytes);	×
494
495	public void WriteAllBytes(string path, ReadOnlySpan<byte> bytes)
496	=> impl.GetFileSystemForPath_(path)	865✔
497	.File	865✔
498	.WriteAllBytes(path, bytes);	865✔
499
500	public Task WriteAllBytesAsync(
501	string path,
502	byte[] bytes,
503	CancellationToken cancellationToken = new())
504	=> impl.GetFileSystemForPath_(path)	×
505	.File	×
506	.WriteAllBytesAsync(path, bytes, cancellationToken);	×
507
508	public Task WriteAllBytesAsync(
509	string path,
510	ReadOnlyMemory<byte> bytes,
511	CancellationToken cancellationToken = new())
512	=> impl.GetFileSystemForPath_(path)	×
513	.File	×
514	.WriteAllBytesAsync(path, bytes, cancellationToken);	×
515
516	public void WriteAllLines(string path, string[] contents)
517	=> impl.GetFileSystemForPath_(path)	×
518	.File	×
519	.WriteAllLines(path, contents);	×
520
521	public void WriteAllLines(string path, IEnumerable<string> contents)
522	=> impl.GetFileSystemForPath_(path)	×
523	.File	×
524	.WriteAllLines(path, contents);	×
525
526	public void WriteAllLines(string path,
527	string[] contents,
528	Encoding encoding)
529	=> impl.GetFileSystemForPath_(path)	×
530	.File	×
531	.WriteAllLines(path, contents, encoding);	×
532
533	public void WriteAllLines(string path,
534	IEnumerable<string> contents,
535	Encoding encoding)
536	=> impl.GetFileSystemForPath_(path)	×
537	.File	×
538	.WriteAllLines(path, contents, encoding);	×
539
540	public Task WriteAllLinesAsync(
541	string path,
542	IEnumerable<string> contents,
543	CancellationToken cancellationToken = new())
544	=> impl.GetFileSystemForPath_(path)	×
545	.File	×
546	.WriteAllLinesAsync(path, contents, cancellationToken);	×
547
548	public Task WriteAllLinesAsync(
549	string path,
550	IEnumerable<string> contents,
551	Encoding encoding,
552	CancellationToken cancellationToken = new())
553	=> impl.GetFileSystemForPath_(path)	×
554	.File	×
555	.WriteAllLinesAsync(path, contents, encoding, cancellationToken);	×
556
557	public void WriteAllText(string path, string? contents)
558	=> impl.GetFileSystemForPath_(path)	×
559	.File	×
560	.WriteAllText(path, contents);	×
561
562	public void WriteAllText(string path, string? contents, Encoding encoding)
563	=> impl.GetFileSystemForPath_(path)	×
564	.File	×
565	.WriteAllText(path, contents, encoding);	×
566
567	public void WriteAllText(string path, ReadOnlySpan<char> contents)
568	=> impl.GetFileSystemForPath_(path)	×
569	.File	×
570	.WriteAllText(path, contents);	×
571
572	public void WriteAllText(string path,
573	ReadOnlySpan<char> contents,
574	Encoding encoding)
575	=> impl.GetFileSystemForPath_(path)	×
576	.File	×
577	.WriteAllText(path, contents, encoding);	×
578
579	public Task WriteAllTextAsync(
580	string path,
581	string? contents,
582	CancellationToken cancellationToken = new())
583	=> impl.GetFileSystemForPath_(path)	×
584	.File	×
585	.WriteAllTextAsync(path, contents, cancellationToken);	×
586
587	public Task WriteAllTextAsync(
588	string path,
589	string? contents,
590	Encoding encoding,
591	CancellationToken cancellationToken = new())
592	=> impl.GetFileSystemForPath_(path)	×
593	.File	×
594	.WriteAllTextAsync(path, contents, encoding, cancellationToken);	×
595
596	public Task WriteAllTextAsync(
597	string path,
598	ReadOnlyMemory<char> contents,
599	CancellationToken cancellationToken = new())
600	=> impl.GetFileSystemForPath_(path)	×
601	.File	×
602	.WriteAllTextAsync(path, contents, cancellationToken);	×
603
604	public Task WriteAllTextAsync(
605	string path,
606	ReadOnlyMemory<char> contents,
607	Encoding encoding,
608	CancellationToken cancellationToken = new())
609	=> impl.GetFileSystemForPath_(path)	×
610	.File	×
611	.WriteAllTextAsync(path, contents, encoding, cancellationToken);	×
612
613	// Unsupported
614
615	public FileAttributes GetAttributes(SafeFileHandle fileHandle)
616	=> throw new NotImplementedException();	×
617
618	public DateTime GetCreationTime(SafeFileHandle fileHandle)
619	=> throw new NotImplementedException();	×
620
621	public DateTime GetCreationTimeUtc(SafeFileHandle fileHandle)
622	=> throw new NotImplementedException();	×
623
624	public DateTime GetLastAccessTime(SafeFileHandle fileHandle)
625	=> throw new NotImplementedException();	×
626
627	public DateTime GetLastAccessTimeUtc(SafeFileHandle fileHandle)
628	=> throw new NotImplementedException();	×
629
630	public DateTime GetLastWriteTime(SafeFileHandle fileHandle)
631	=> throw new NotImplementedException();	×
632
633	public DateTime GetLastWriteTimeUtc(SafeFileHandle fileHandle)
634	=> throw new NotImplementedException();	×
635
636	public UnixFileMode GetUnixFileMode(SafeFileHandle fileHandle)
637	=> throw new NotImplementedException();	×
638
639	public void SetAttributes(SafeFileHandle fileHandle,
640	FileAttributes fileAttributes)
641	=> throw new NotImplementedException();	×
642
643	public void SetCreationTime(SafeFileHandle fileHandle,
644	DateTime creationTime)
645	=> throw new NotImplementedException();	×
646
647	public void SetCreationTimeUtc(SafeFileHandle fileHandle,
648	DateTime creationTimeUtc)
649	=> throw new NotImplementedException();	×
650
651	public void SetLastAccessTime(SafeFileHandle fileHandle,
652	DateTime lastAccessTime)
653	=> throw new NotImplementedException();	×
654
655	public void SetLastAccessTimeUtc(SafeFileHandle fileHandle,
656	DateTime lastAccessTimeUtc)
657	=> throw new NotImplementedException();	×
658
659	public void SetLastWriteTime(SafeFileHandle fileHandle,
660	DateTime lastWriteTime)
661	=> throw new NotImplementedException();	×
662
663	public void SetLastWriteTimeUtc(SafeFileHandle fileHandle,
664	DateTime lastWriteTimeUtc)
665	=> throw new NotImplementedException();	×
666
667	public void SetUnixFileMode(SafeFileHandle fileHandle, UnixFileMode mode)
668	=> throw new NotImplementedException();	×
669	}
670	}

MeltyPlayer / MeltyTool / 21327634179

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous