public void Returns_binary_tree_object_when_input_data_is_valid()
{
//Arrange
const string inputDir = @"c:\root\in";
const string inputFileName = "myfile.txt";
var inputFilePath = Path.Combine(inputDir, inputFileName);
var textLfileLines = new StringBuilder();
textLfileLines.AppendLine("1");
textLfileLines.AppendLine("8 9");
textLfileLines.AppendLine("1 5 9");
textLfileLines.AppendLine("4 5 2 3");
var mockInputFile = new MockFileData(textLfileLines.ToString());
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(inputFilePath, mockInputFile);
var sut = new BinaryTreeReader(mockFileSystem);
//Act
var actualResult = sut.GetBinaryTree(inputFilePath);
//Assert
actualResult.IsSuccess.Should().BeTrue();
actualResult.IsFailure.Should().BeFalse();
actualResult.Value.GetType().Should().Be(typeof(BinaryTree));
}
public void Returns_error_when_line_has_same_number_of_values_comparing_to_previous_line()
{
//Arrange
const string inputDir = @"c:\root\in";
const string inputFileName = "myfile.txt";
var inputFilePath = Path.Combine(inputDir, inputFileName);
var textLfileLines = new StringBuilder();
textLfileLines.AppendLine("1");
textLfileLines.AppendLine("8 9");
textLfileLines.AppendLine("1 5 9");
textLfileLines.AppendLine("4 5 2");
var mockInputFile = new MockFileData(textLfileLines.ToString());
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(inputFilePath, mockInputFile);
var sut = new BinaryTreeReader(mockFileSystem);
//Act
var actualResult = sut.GetBinaryTree(inputFilePath);
//Assert
actualResult.IsFailure.Should().BeTrue();
actualResult.IsSuccess.Should().BeFalse();
actualResult.Error.Should().Be("Invalid binary tree data structure.");
}
public void Returns_correct_max_sum_of_odd_event_sequential_nodes_path_3()
{
//Arrange
const string inputDir = @"c:\root\in";
const string inputFileName = "myfile.txt";
var inputFilePath = Path.Combine(inputDir, inputFileName);
var textLfileLines = new StringBuilder();
textLfileLines.AppendLine("1");
textLfileLines.AppendLine("8 8");
textLfileLines.AppendLine("1 5 9");
textLfileLines.AppendLine("4 5 2 2");
var mockInputFile = new MockFileData(textLfileLines.ToString());
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(inputFilePath, mockInputFile);
var binaryTreeReader = new BinaryTreeReader(mockFileSystem);
var sut = binaryTreeReader.GetBinaryTree(inputFilePath).Value;
//Act
var actualResult = sut.GetMaxSumOfOddEventSequentialNodes();
//Assert
actualResult.IsSuccess.Should().BeTrue();
actualResult.IsFailure.Should().BeFalse();
actualResult.Value.Should().Be(20);
}
public void Returns_error_then_no_valid_path_exist()
{
//Arrange
const string inputDir = @"c:\root\in";
const string inputFileName = "myfile.txt";
var inputFilePath = Path.Combine(inputDir, inputFileName);
var textLfileLines = new StringBuilder();
textLfileLines.AppendLine("1");
textLfileLines.AppendLine("8 9");
textLfileLines.AppendLine("2 2 9");
textLfileLines.AppendLine("4 5 2 3");
var mockInputFile = new MockFileData(textLfileLines.ToString());
var mockFileSystem = new MockFileSystem();
mockFileSystem.AddFile(inputFilePath, mockInputFile);
var binaryTreeReader = new BinaryTreeReader(mockFileSystem);
var sut = binaryTreeReader.GetBinaryTree(inputFilePath).Value;
//Act
var actualResult = sut.GetMaxSumOfOddEventSequentialNodes();
//Assert
actualResult.IsSuccess.Should().BeFalse();
actualResult.IsFailure.Should().BeTrue();
actualResult.Error.Should().Be("Binary tree does not contain valid path.");
}
public static FileSystem ReadBsoa(System.IO.Stream stream)
{
using (BinaryTreeReader reader = new BinaryTreeReader(stream))
{
FileSystem result = new FileSystem();
result.DB.Read(reader);
return(result);
}
}
public static Run ReadBsoa(System.IO.Stream stream)
{
using (BinaryTreeReader reader = new BinaryTreeReader(stream))
{
Run result = new Run();
result.DB.Read(reader);
return(result);
}
}
public static Company ReadBsoa(System.IO.Stream stream)
{
using (BinaryTreeReader reader = new BinaryTreeReader(stream))
{
Company result = new Company();
result.DB.Read(reader);
return(result);
}
}
public static TreeDiagnostics Diagnostics(System.IO.Stream stream)
{
using (BinaryTreeReader btr = new BinaryTreeReader(stream))
using (TreeDiagnosticsReader reader = new TreeDiagnosticsReader(btr))
{
FileSystem result = new FileSystem();
result.DB.Read(reader);
return(reader.Tree);
}
}
public void Returns_error_then_file_does_not_exist()
{
//Arrange
var sut = new BinaryTreeReader();
//Act
var actualResult = sut.GetBinaryTree("nonexistingfile.txt");
//Assert
actualResult.IsFailure.Should().BeTrue();
actualResult.IsSuccess.Should().BeFalse();
actualResult.Error.Should().StartWith("Could not find file");
}
public void Returns_correct_max_sum_of_odd_event_sequential_nodes_when_reads_real_file()
{
//Arrange
var binaryTreeReader = new BinaryTreeReader();
var sut = binaryTreeReader.GetBinaryTree("testdata2.txt").Value;
//Act
var actualResult = sut.GetMaxSumOfOddEventSequentialNodes();
//Assert
actualResult.IsSuccess.Should().BeTrue();
actualResult.IsFailure.Should().BeFalse();
actualResult.Value.Should().Be(16);
}
public bool Read(string path)
{
if (!File.Exists(path))
{
return(false);
}
try
{
using (BinaryTreeReader reader = new BinaryTreeReader(path))
{
// get root node
BinaryReader node = reader.GetRootNode();
if (node == null)
{
return(false);
}
node.ReadByte(); // first byte of otb is 0
node.ReadUInt32(); // 4 bytes flags, unused
byte attr = node.ReadByte();
if ((RootAttribute)attr == RootAttribute.Version)
{
ushort datalen = node.ReadUInt16();
if (datalen != 140) // 4 + 4 + 4 + 1 * 128
{
Trace.WriteLine(String.Format("Size of version header is invalid, updated .otb version?"));
return(false);
}
this.Items.MajorVersion = node.ReadUInt32(); // major, file version
this.Items.MinorVersion = node.ReadUInt32(); // minor, client version
this.Items.BuildNumber = node.ReadUInt32(); // build number, revision
node.BaseStream.Seek(128, SeekOrigin.Current);
}
node = reader.GetChildNode();
if (node == null)
{
return(false);
}
do
{
ServerItem item = new ServerItem();
ServerItemGroup itemGroup = (ServerItemGroup)node.ReadByte();
switch (itemGroup)
{
case ServerItemGroup.None:
item.Type = ServerItemType.None;
break;
case ServerItemGroup.Ground:
item.Type = ServerItemType.Ground;
break;
case ServerItemGroup.Container:
item.Type = ServerItemType.Container;
break;
case ServerItemGroup.Splash:
item.Type = ServerItemType.Splash;
break;
case ServerItemGroup.Fluid:
item.Type = ServerItemType.Fluid;
break;
case ServerItemGroup.Deprecated:
item.Type = ServerItemType.Deprecated;
break;
}
ServerItemFlag flags = (ServerItemFlag)node.ReadUInt32();
item.Unpassable = ((flags & ServerItemFlag.Unpassable) == ServerItemFlag.Unpassable);
item.BlockMissiles = ((flags & ServerItemFlag.BlockMissiles) == ServerItemFlag.BlockMissiles);
item.BlockPathfinder = ((flags & ServerItemFlag.BlockPathfinder) == ServerItemFlag.BlockPathfinder);
item.HasElevation = ((flags & ServerItemFlag.HasElevation) == ServerItemFlag.HasElevation);
item.ForceUse = ((flags & ServerItemFlag.ForceUse) == ServerItemFlag.ForceUse);
item.MultiUse = ((flags & ServerItemFlag.MultiUse) == ServerItemFlag.MultiUse);
item.Pickupable = ((flags & ServerItemFlag.Pickupable) == ServerItemFlag.Pickupable);
item.Movable = ((flags & ServerItemFlag.Movable) == ServerItemFlag.Movable);
item.Stackable = ((flags & ServerItemFlag.Stackable) == ServerItemFlag.Stackable);
item.HasStackOrder = ((flags & ServerItemFlag.StackOrder) == ServerItemFlag.StackOrder);
item.Readable = ((flags & ServerItemFlag.Readable) == ServerItemFlag.Readable);
item.Rotatable = ((flags & ServerItemFlag.Rotatable) == ServerItemFlag.Rotatable);
item.Hangable = ((flags & ServerItemFlag.Hangable) == ServerItemFlag.Hangable);
item.HookSouth = ((flags & ServerItemFlag.HookSouth) == ServerItemFlag.HookSouth);
item.HookEast = ((flags & ServerItemFlag.HookEast) == ServerItemFlag.HookEast);
item.AllowDistanceRead = ((flags & ServerItemFlag.AllowDistanceRead) == ServerItemFlag.AllowDistanceRead);
item.HasCharges = ((flags & ServerItemFlag.ClientCharges) == ServerItemFlag.ClientCharges);
item.IgnoreLook = ((flags & ServerItemFlag.IgnoreLook) == ServerItemFlag.IgnoreLook);
item.FullGround = ((flags & ServerItemFlag.FullGround) == ServerItemFlag.FullGround);
item.IsAnimation = ((flags & ServerItemFlag.IsAnimation) == ServerItemFlag.IsAnimation);
while (node.PeekChar() != -1)
{
ServerItemAttribute attribute = (ServerItemAttribute)node.ReadByte();
ushort datalen = node.ReadUInt16();
switch (attribute)
{
case ServerItemAttribute.ServerID:
item.ID = node.ReadUInt16();
break;
case ServerItemAttribute.ClientID:
item.ClientId = node.ReadUInt16();
break;
case ServerItemAttribute.GroundSpeed:
item.GroundSpeed = node.ReadUInt16();
break;
case ServerItemAttribute.PriceCount:
item.PriceCount = node.ReadUInt32();
break;
case ServerItemAttribute.Name:
byte[] buffer = node.ReadBytes(datalen);
item.Name = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
break;
case ServerItemAttribute.SpriteHash:
item.SpriteHash = node.ReadBytes(datalen);
break;
case ServerItemAttribute.MinimaColor:
item.MinimapColor = node.ReadUInt16();
break;
case ServerItemAttribute.MaxReadWriteChars:
item.MaxReadWriteChars = node.ReadUInt16();
break;
case ServerItemAttribute.MaxReadChars:
item.MaxReadChars = node.ReadUInt16();
break;
case ServerItemAttribute.Light:
item.LightLevel = node.ReadUInt16();
item.LightColor = node.ReadUInt16();
break;
case ServerItemAttribute.StackOrder:
item.StackOrder = (TileStackOrder)node.ReadByte();
break;
case ServerItemAttribute.TradeAs:
item.TradeAs = node.ReadUInt16();
break;
default:
node.BaseStream.Seek(datalen, SeekOrigin.Current);
break;
}
}
if (item.SpriteHash == null && item.Type != ServerItemType.Deprecated)
{
item.SpriteHash = new byte[16];
}
this.Items.Add(item);
node = reader.GetNextNode();
}while (node != null);
}
}
catch
{
return(false);
}
return(true);
}
