FilesExpand file tree

develop

/

FakeFile.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

161 lines (141 loc) · 4.54 KB

develop

/

FakeFile.cs

Copy path

Top

File metadata and controls

• Code
• Blame

161 lines (141 loc) · 4.54 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

using System;

using System.IO;

using Cake.Core.IO;

using Path = Cake.Core.IO.Path;

namespace Cake.Testing

{

/// <summary>

/// Represents a fake file.

/// </summary>

public sealed class FakeFile : IFile

{

private readonly FakeFileSystemTree _tree;

/// <inheritdoc/>

public FilePath Path { get; }

/// <inheritdoc/>

Path IFileSystemInfo.Path => Path;

/// <inheritdoc/>

public bool Exists { get; internal set; }

/// <inheritdoc/>

public bool Hidden { get; internal set; }

/// <summary>

/// Gets the time when this <see cref="IFileSystemInfo"/> was last written to.

/// </summary>

/// <value>The last write time.</value>

public DateTime LastWriteTime { get; internal set; }

/// <inheritdoc/>

public long Length { get; private set; }

/// <inheritdoc/>

public FileAttributes Attributes { get; set; }

internal object ContentLock { get; } = new object();

/// <summary>

/// Gets the length of the content.

/// </summary>

/// <value>

/// The length of the content.

/// </value>

public long ContentLength

{

get { return Length; }

internal set { Length = value; }

}

/// <summary>

/// Gets the content.

/// </summary>

/// <value>The content.</value>

public byte[] Content { get; internal set; } = new byte[4096];

internal FakeFile(FakeFileSystemTree tree, FilePath path)

{

_tree = tree;

Path = path;

Exists = false;

Hidden = false;

}

/// <inheritdoc/>

public void Copy(FilePath destination, bool overwrite)

{

_tree.CopyFile(this, destination, overwrite);

}

/// <inheritdoc/>

public void Move(FilePath destination)

{

_tree.MoveFile(this, destination);

}

/// <inheritdoc/>

public Stream Open(FileMode fileMode, FileAccess fileAccess, FileShare fileShare)

{

bool fileWasCreated;

var position = GetPosition(fileMode, out fileWasCreated);

if (fileWasCreated)

{

_tree.CreateFile(this);

}

return new FakeFileStream(this) { Position = position };

}

/// <inheritdoc/>

public void Delete()

{

_tree.DeleteFile(this);

}

/// <summary>

/// Resizes the file.

/// </summary>

/// <param name="offset">The offset.</param>

public void Resize(long offset)

{

if (Length < offset)

{

Length = offset;

}

if (Content.Length >= Length)

{

return;

}

var buffer = new byte[Length * 2];

Buffer.BlockCopy(Content, 0, buffer, 0, Content.Length);

Content = buffer;

}

private long GetPosition(FileMode fileMode, out bool fileWasCreated)

{

fileWasCreated = false;

if (Exists)

{

switch (fileMode)

{

case FileMode.CreateNew:

throw new IOException();

case FileMode.Create:

case FileMode.Truncate:

Length = 0;

return 0;

case FileMode.Open:

case FileMode.OpenOrCreate:

return 0;

case FileMode.Append:

return Length;

}

}

else

{

switch (fileMode)

{

case FileMode.Create:

case FileMode.Append:

case FileMode.CreateNew:

case FileMode.OpenOrCreate:

fileWasCreated = true;

Exists = true;

LastWriteTime = DateTime.Now;

return Length;

case FileMode.Open:

case FileMode.Truncate:

throw new FileNotFoundException();

}

}

throw new NotSupportedException();

}

}

}