mahalex/MatFileHandler
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases 9 Wiki Activity

Move test data

Browse Source
This commit is contained in:
Alexander Luzgarev 2019-03-07 19:02:11 +01:00
parent 957234d30d
commit 0e14434bae
25 changed files with 507 additions and 496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

973
MatFileHandler.Tests/MatFileReaderTests.cs → MatFileHandler.Tests/MatFileReaderLevel5Tests.cs Executable file → Normal file
View File

@ -1,485 +1,490 @@
// Copyright 2017-2018 Alexander Luzgarev // Copyright 2017-2018 Alexander Luzgarev
using System; using System;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Numerics; using System.Numerics;
using NUnit.Framework; using NUnit.Framework;
namespace MatFileHandler.Tests namespace MatFileHandler.Tests
{ {
/// <summary> /// <summary>
/// Tests of file reading API. /// Tests of file reading API.
/// </summary> /// </summary>
[TestFixture] [TestFixture]
public class MatFileReaderTests public class MatFileReaderLevel5Tests
{ {
private const string TestDirectory = "test-data"; private const string TestDirectory = "test-data";
/// <summary> /// <summary>
/// Test reading all files in a given test set. /// Test reading all files in a given test set.
/// </summary> /// </summary>
/// <param name="testSet">Name of the set.</param> /// <param name="testSet">Name of the set.</param>
[TestCase("good")] [TestCase("level5")]
public void TestReader(string testSet) public void TestReader(string testSet)
{ {
foreach (var matFile in GetTests(testSet).GetAllTestData()) foreach (var matFile in GetTests(testSet).GetAllTestData())
{ {
Assert.That(matFile.Variables, Is.Not.Empty); Assert.That(matFile.Variables, Is.Not.Empty);
} }
} }
/// <summary> /// <summary>
/// Test reading lower and upper limits of integer data types. /// Test reading lower and upper limits of integer data types.
/// </summary> /// </summary>
[Test] [Test]
public void TestLimits() public void TestLimits()
{ {
var matFile = GetTests("good")["limits"]; var matFile = ReadLevel5TestFile("limits");
IArray array; IArray array;
array = matFile["int8_"].Value; array = matFile["int8_"].Value;
CheckLimits(array as IArrayOf<sbyte>, CommonData.Int8Limits); CheckLimits(array as IArrayOf<sbyte>, CommonData.Int8Limits);
Assert.That(array.ConvertToDoubleArray(), Is.EqualTo(new[] { -128.0, 127.0 })); Assert.That(array.ConvertToDoubleArray(), Is.EqualTo(new[] { -128.0, 127.0 }));
array = matFile["uint8_"].Value; array = matFile["uint8_"].Value;
CheckLimits(array as IArrayOf<byte>, CommonData.UInt8Limits); CheckLimits(array as IArrayOf<byte>, CommonData.UInt8Limits);
array = matFile["int16_"].Value; array = matFile["int16_"].Value;
CheckLimits(array as IArrayOf<short>, CommonData.Int16Limits); CheckLimits(array as IArrayOf<short>, CommonData.Int16Limits);
array = matFile["uint16_"].Value; array = matFile["uint16_"].Value;
CheckLimits(array as IArrayOf<ushort>, CommonData.UInt16Limits); CheckLimits(array as IArrayOf<ushort>, CommonData.UInt16Limits);
array = matFile["int32_"].Value; array = matFile["int32_"].Value;
CheckLimits(array as IArrayOf<int>, CommonData.Int32Limits); CheckLimits(array as IArrayOf<int>, CommonData.Int32Limits);
array = matFile["uint32_"].Value; array = matFile["uint32_"].Value;
CheckLimits(array as IArrayOf<uint>, CommonData.UInt32Limits); CheckLimits(array as IArrayOf<uint>, CommonData.UInt32Limits);
array = matFile["int64_"].Value; array = matFile["int64_"].Value;
CheckLimits(array as IArrayOf<long>, CommonData.Int64Limits); CheckLimits(array as IArrayOf<long>, CommonData.Int64Limits);
array = matFile["uint64_"].Value; array = matFile["uint64_"].Value;
CheckLimits(array as IArrayOf<ulong>, CommonData.UInt64Limits); CheckLimits(array as IArrayOf<ulong>, CommonData.UInt64Limits);
} }
/// <summary> /// <summary>
/// Test writing lower and upper limits of integer-based complex data types. /// Test writing lower and upper limits of integer-based complex data types.
/// </summary> /// </summary>
[Test] [Test]
public void TestComplexLimits() public void TestComplexLimits()
{ {
var matFile = GetTests("good")["limits_complex"]; var matFile = ReadLevel5TestFile("limits_complex");
IArray array; IArray array;
array = matFile["int8_complex"].Value; array = matFile["int8_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<sbyte>>, CommonData.Int8Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<sbyte>>, CommonData.Int8Limits);
Assert.That( Assert.That(
array.ConvertToComplexArray(), array.ConvertToComplexArray(),
Is.EqualTo(new[] { -128.0 + (127.0 * Complex.ImaginaryOne), 127.0 - (128.0 * Complex.ImaginaryOne) })); Is.EqualTo(new[] { -128.0 + (127.0 * Complex.ImaginaryOne), 127.0 - (128.0 * Complex.ImaginaryOne) }));
array = matFile["uint8_complex"].Value; array = matFile["uint8_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<byte>>, CommonData.UInt8Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<byte>>, CommonData.UInt8Limits);
array = matFile["int16_complex"].Value; array = matFile["int16_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<short>>, CommonData.Int16Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<short>>, CommonData.Int16Limits);
array = matFile["uint16_complex"].Value; array = matFile["uint16_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<ushort>>, CommonData.UInt16Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<ushort>>, CommonData.UInt16Limits);
array = matFile["int32_complex"].Value; array = matFile["int32_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<int>>, CommonData.Int32Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<int>>, CommonData.Int32Limits);
array = matFile["uint32_complex"].Value; array = matFile["uint32_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<uint>>, CommonData.UInt32Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<uint>>, CommonData.UInt32Limits);
array = matFile["int64_complex"].Value; array = matFile["int64_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<long>>, CommonData.Int64Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<long>>, CommonData.Int64Limits);
array = matFile["uint64_complex"].Value; array = matFile["uint64_complex"].Value;
CheckComplexLimits(array as IArrayOf<ComplexOf<ulong>>, CommonData.UInt64Limits); CheckComplexLimits(array as IArrayOf<ComplexOf<ulong>>, CommonData.UInt64Limits);
} }
/// <summary> /// <summary>
/// Test reading an ASCII-encoded string. /// Test reading an ASCII-encoded string.
/// </summary> /// </summary>
[Test] [Test]
public void TestAscii() public void TestAscii()
{ {
var matFile = GetTests("good")["ascii"]; var matFile = ReadLevel5TestFile("ascii");
var arrayAscii = matFile["s"].Value as ICharArray; var arrayAscii = matFile["s"].Value as ICharArray;
Assert.That(arrayAscii, Is.Not.Null); Assert.That(arrayAscii, Is.Not.Null);
Assert.That(arrayAscii.Dimensions, Is.EqualTo(new[] { 1, 3 })); Assert.That(arrayAscii.Dimensions, Is.EqualTo(new[] { 1, 3 }));
Assert.That(arrayAscii.String, Is.EqualTo("abc")); Assert.That(arrayAscii.String, Is.EqualTo("abc"));
Assert.That(arrayAscii[2], Is.EqualTo('c')); Assert.That(arrayAscii[2], Is.EqualTo('c'));
} }
/// <summary> /// <summary>
/// Test reading a Unicode string. /// Test reading a Unicode string.
/// </summary> /// </summary>
[Test] [Test]
public void TestUnicode() public void TestUnicode()
{ {
var matFile = GetTests("good")["unicode"]; var matFile = ReadLevel5TestFile("unicode");
var arrayUnicode = matFile["s"].Value as ICharArray; var arrayUnicode = matFile["s"].Value as ICharArray;
Assert.That(arrayUnicode, Is.Not.Null); Assert.That(arrayUnicode, Is.Not.Null);
Assert.That(arrayUnicode.Dimensions, Is.EqualTo(new[] { 1, 2 })); Assert.That(arrayUnicode.Dimensions, Is.EqualTo(new[] { 1, 2 }));
Assert.That(arrayUnicode.String, Is.EqualTo("必フ")); Assert.That(arrayUnicode.String, Is.EqualTo("必フ"));
Assert.That(arrayUnicode[0], Is.EqualTo('必')); Assert.That(arrayUnicode[0], Is.EqualTo('必'));
Assert.That(arrayUnicode[1], Is.EqualTo('フ')); Assert.That(arrayUnicode[1], Is.EqualTo('フ'));
} }
/// <summary> /// <summary>
/// Test reading a wide Unicode string. /// Test reading a wide Unicode string.
/// </summary> /// </summary>
[Test] [Test]
public void TestUnicodeWide() public void TestUnicodeWide()
{ {
var matFile = GetTests("good")["unicode-wide"]; var matFile = ReadLevel5TestFile("unicode-wide");
var arrayUnicodeWide = matFile["s"].Value as ICharArray; var arrayUnicodeWide = matFile["s"].Value as ICharArray;
Assert.That(arrayUnicodeWide, Is.Not.Null); Assert.That(arrayUnicodeWide, Is.Not.Null);
Assert.That(arrayUnicodeWide.Dimensions, Is.EqualTo(new[] { 1, 2 })); Assert.That(arrayUnicodeWide.Dimensions, Is.EqualTo(new[] { 1, 2 }));
Assert.That(arrayUnicodeWide.String, Is.EqualTo("🍆")); Assert.That(arrayUnicodeWide.String, Is.EqualTo("🍆"));
} }
/// <summary> /// <summary>
/// Test converting a structure array to a Double array. /// Test converting a structure array to a Double array.
/// </summary> /// </summary>
/// <returns>Should return null.</returns> /// <returns>Should return null.</returns>
[Test(ExpectedResult = null)] [Test(ExpectedResult = null)]
public double[] TestConvertToDoubleArray() public double[] TestConvertToDoubleArray()
{ {
var matFile = GetTests("good")["struct"]; var matFile = ReadLevel5TestFile("struct");
var array = matFile.Variables[0].Value; var array = matFile.Variables[0].Value;
return array.ConvertToDoubleArray(); return array.ConvertToDoubleArray();
} }
/// <summary> /// <summary>
/// Test converting a structure array to a Complex array. /// Test converting a structure array to a Complex array.
/// </summary> /// </summary>
/// <returns>Should return null.</returns> /// <returns>Should return null.</returns>
[Test(ExpectedResult = null)] [Test(ExpectedResult = null)]
public Complex[] TestConvertToComplexArray() public Complex[] TestConvertToComplexArray()
{ {
var matFile = GetTests("good")["struct"]; var matFile = ReadLevel5TestFile("struct");
var array = matFile.Variables[0].Value; var array = matFile.Variables[0].Value;
return array.ConvertToComplexArray(); return array.ConvertToComplexArray();
} }
/// <summary> /// <summary>
/// Test reading a structure array. /// Test reading a structure array.
/// </summary> /// </summary>
[Test] [Test]
public void TestStruct() public void TestStruct()
{ {
var matFile = GetTests("good")["struct"]; var matFile = ReadLevel5TestFile("struct");
var structure = matFile["struct_"].Value as IStructureArray; var structure = matFile["struct_"].Value as IStructureArray;
Assert.That(structure, Is.Not.Null); Assert.That(structure, Is.Not.Null);
Assert.That(structure.FieldNames, Is.EquivalentTo(new[] { "x", "y" })); Assert.That(structure.FieldNames, Is.EquivalentTo(new[] { "x", "y" }));
var element = structure[0, 0]; var element = structure[0, 0];
Assert.That(element.ContainsKey("x"), Is.True); Assert.That(element.ContainsKey("x"), Is.True);
Assert.That(element.Count, Is.EqualTo(2)); Assert.That(element.Count, Is.EqualTo(2));
Assert.That(element.TryGetValue("x", out var _), Is.True); Assert.That(element.TryGetValue("x", out var _), Is.True);
Assert.That(element.TryGetValue("z", out var _), Is.False); Assert.That(element.TryGetValue("z", out var _), Is.False);
Assert.That(element.Keys, Has.Exactly(2).Items); Assert.That(element.Keys, Has.Exactly(2).Items);
Assert.That(element.Values, Has.Exactly(2).Items); Assert.That(element.Values, Has.Exactly(2).Items);
var keys = element.Select(pair => pair.Key); var keys = element.Select(pair => pair.Key);
Assert.That(keys, Is.EquivalentTo(new[] { "x", "y" })); Assert.That(keys, Is.EquivalentTo(new[] { "x", "y" }));
Assert.That((element["x"] as IArrayOf<double>)?[0], Is.EqualTo(12.345)); Assert.That((element["x"] as IArrayOf<double>)?[0], Is.EqualTo(12.345));
Assert.That((structure["x", 0, 0] as IArrayOf<double>)?[0], Is.EqualTo(12.345)); Assert.That((structure["x", 0, 0] as IArrayOf<double>)?[0], Is.EqualTo(12.345));
Assert.That((structure["y", 0, 0] as ICharArray)?.String, Is.EqualTo("abc")); Assert.That((structure["y", 0, 0] as ICharArray)?.String, Is.EqualTo("abc"));
Assert.That((structure["x", 1, 0] as ICharArray)?.String, Is.EqualTo("xyz")); Assert.That((structure["x", 1, 0] as ICharArray)?.String, Is.EqualTo("xyz"));
Assert.That(structure["y", 1, 0].IsEmpty, Is.True); Assert.That(structure["y", 1, 0].IsEmpty, Is.True);
Assert.That((structure["x", 0, 1] as IArrayOf<double>)?[0], Is.EqualTo(2.0)); Assert.That((structure["x", 0, 1] as IArrayOf<double>)?[0], Is.EqualTo(2.0));
Assert.That((structure["y", 0, 1] as IArrayOf<double>)?[0], Is.EqualTo(13.0)); Assert.That((structure["y", 0, 1] as IArrayOf<double>)?[0], Is.EqualTo(13.0));
Assert.That(structure["x", 1, 1].IsEmpty, Is.True); Assert.That(structure["x", 1, 1].IsEmpty, Is.True);
Assert.That((structure["y", 1, 1] as ICharArray)?[0, 0], Is.EqualTo('a')); Assert.That((structure["y", 1, 1] as ICharArray)?[0, 0], Is.EqualTo('a'));
Assert.That(((structure["x", 0, 2] as ICellArray)?[0] as ICharArray)?.String, Is.EqualTo("x")); Assert.That(((structure["x", 0, 2] as ICellArray)?[0] as ICharArray)?.String, Is.EqualTo("x"));
Assert.That(((structure["x", 0, 2] as ICellArray)?[1] as ICharArray)?.String, Is.EqualTo("yz")); Assert.That(((structure["x", 0, 2] as ICellArray)?[1] as ICharArray)?.String, Is.EqualTo("yz"));
Assert.That((structure["y", 0, 2] as IArrayOf<double>)?.Dimensions, Is.EqualTo(new[] { 2, 3 })); Assert.That((structure["y", 0, 2] as IArrayOf<double>)?.Dimensions, Is.EqualTo(new[] { 2, 3 }));
Assert.That((structure["y", 0, 2] as IArrayOf<double>)?[0, 2], Is.EqualTo(3.0)); Assert.That((structure["y", 0, 2] as IArrayOf<double>)?[0, 2], Is.EqualTo(3.0));
Assert.That((structure["x", 1, 2] as IArrayOf<float>)?[0], Is.EqualTo(1.5f)); Assert.That((structure["x", 1, 2] as IArrayOf<float>)?[0], Is.EqualTo(1.5f));
Assert.That(structure["y", 1, 2].IsEmpty, Is.True); Assert.That(structure["y", 1, 2].IsEmpty, Is.True);
} }
/// <summary> /// <summary>
/// Test reading a sparse array. /// Test reading a sparse array.
/// </summary> /// </summary>
[Test] [Test]
public void TestSparse() public void TestSparse()
{ {
var matFile = GetTests("good")["sparse"]; var matFile = ReadLevel5TestFile("sparse");
var sparseArray = matFile["sparse_"].Value as ISparseArrayOf<double>; var sparseArray = matFile["sparse_"].Value as ISparseArrayOf<double>;
Assert.That(sparseArray, Is.Not.Null); Assert.That(sparseArray, Is.Not.Null);
Assert.That(sparseArray.Dimensions, Is.EqualTo(new[] { 4, 5 })); Assert.That(sparseArray.Dimensions, Is.EqualTo(new[] { 4, 5 }));
Assert.That(sparseArray.Data[(1, 1)], Is.EqualTo(1.0)); Assert.That(sparseArray.Data[(1, 1)], Is.EqualTo(1.0));
Assert.That(sparseArray[1, 1], Is.EqualTo(1.0)); Assert.That(sparseArray[1, 1], Is.EqualTo(1.0));
Assert.That(sparseArray[1, 2], Is.EqualTo(2.0)); Assert.That(sparseArray[1, 2], Is.EqualTo(2.0));
Assert.That(sparseArray[2, 1], Is.EqualTo(3.0)); Assert.That(sparseArray[2, 1], Is.EqualTo(3.0));
Assert.That(sparseArray[2, 3], Is.EqualTo(4.0)); Assert.That(sparseArray[2, 3], Is.EqualTo(4.0));
Assert.That(sparseArray[0, 4], Is.EqualTo(0.0)); Assert.That(sparseArray[0, 4], Is.EqualTo(0.0));
Assert.That(sparseArray[3, 0], Is.EqualTo(0.0)); Assert.That(sparseArray[3, 0], Is.EqualTo(0.0));
Assert.That(sparseArray[3, 4], Is.EqualTo(0.0)); Assert.That(sparseArray[3, 4], Is.EqualTo(0.0));
} }
/// <summary> /// <summary>
/// Test reading a logical array. /// Test reading a logical array.
/// </summary> /// </summary>
[Test] [Test]
public void TestLogical() public void TestLogical()
{ {
var matFile = GetTests("good")["logical"]; var matFile = ReadLevel5TestFile("logical");
var array = matFile["logical_"].Value; var array = matFile["logical_"].Value;
var logicalArray = array as IArrayOf<bool>; var logicalArray = array as IArrayOf<bool>;
Assert.That(logicalArray, Is.Not.Null); Assert.That(logicalArray, Is.Not.Null);
Assert.That(logicalArray[0, 0], Is.True); Assert.That(logicalArray[0, 0], Is.True);
Assert.That(logicalArray[0, 1], Is.True); Assert.That(logicalArray[0, 1], Is.True);
Assert.That(logicalArray[0, 2], Is.False); Assert.That(logicalArray[0, 2], Is.False);
Assert.That(logicalArray[1, 0], Is.False); Assert.That(logicalArray[1, 0], Is.False);
Assert.That(logicalArray[1, 1], Is.True); Assert.That(logicalArray[1, 1], Is.True);
Assert.That(logicalArray[1, 2], Is.True); Assert.That(logicalArray[1, 2], Is.True);
} }
/// <summary> /// <summary>
/// Test reading a sparse logical array. /// Test reading a sparse logical array.
/// </summary> /// </summary>
[Test] [Test]
public void TestSparseLogical() public void TestSparseLogical()
{ {
var matFile = GetTests("good")["sparse_logical"]; var matFile = ReadLevel5TestFile("sparse_logical");
var array = matFile["sparse_logical"].Value; var array = matFile["sparse_logical"].Value;
var sparseArray = array as ISparseArrayOf<bool>; var sparseArray = array as ISparseArrayOf<bool>;
Assert.That(sparseArray, Is.Not.Null); Assert.That(sparseArray, Is.Not.Null);
Assert.That(sparseArray.Data[(0, 0)], Is.True); Assert.That(sparseArray.Data[(0, 0)], Is.True);
Assert.That(sparseArray[0, 0], Is.True); Assert.That(sparseArray[0, 0], Is.True);
Assert.That(sparseArray[0, 1], Is.True); Assert.That(sparseArray[0, 1], Is.True);
Assert.That(sparseArray[0, 2], Is.False); Assert.That(sparseArray[0, 2], Is.False);
Assert.That(sparseArray[1, 0], Is.False); Assert.That(sparseArray[1, 0], Is.False);
Assert.That(sparseArray[1, 1], Is.True); Assert.That(sparseArray[1, 1], Is.True);
Assert.That(sparseArray[1, 2], Is.True); Assert.That(sparseArray[1, 2], Is.True);
} }
/// <summary> /// <summary>
/// Test reading a global variable. /// Test reading a global variable.
/// </summary> /// </summary>
[Test] [Test]
public void TestGlobal() public void TestGlobal()
{ {
var matFile = GetTests("good")["global"]; var matFile = ReadLevel5TestFile("global");
var variable = matFile.Variables.First(); var variable = matFile.Variables.First();
Assert.That(variable.IsGlobal, Is.True); Assert.That(variable.IsGlobal, Is.True);
} }
/// <summary> /// <summary>
/// Test reading a sparse complex array. /// Test reading a sparse complex array.
/// </summary> /// </summary>
[Test] [Test]
public void TextSparseComplex() public void TextSparseComplex()
{ {
var matFile = GetTests("good")["sparse_complex"]; var matFile = ReadLevel5TestFile("sparse_complex");
var array = matFile["sparse_complex"].Value; var array = matFile["sparse_complex"].Value;
var sparseArray = array as ISparseArrayOf<Complex>; var sparseArray = array as ISparseArrayOf<Complex>;
Assert.That(sparseArray, Is.Not.Null); Assert.That(sparseArray, Is.Not.Null);
Assert.That(sparseArray[0, 0], Is.EqualTo(-1.5 + (2.5 * Complex.ImaginaryOne))); Assert.That(sparseArray[0, 0], Is.EqualTo(-1.5 + (2.5 * Complex.ImaginaryOne)));
Assert.That(sparseArray[1, 0], Is.EqualTo(2 - (3 * Complex.ImaginaryOne))); Assert.That(sparseArray[1, 0], Is.EqualTo(2 - (3 * Complex.ImaginaryOne)));
Assert.That(sparseArray[0, 1], Is.EqualTo(Complex.Zero)); Assert.That(sparseArray[0, 1], Is.EqualTo(Complex.Zero));
Assert.That(sparseArray[1, 1], Is.EqualTo(0.5 + (1.0 * Complex.ImaginaryOne))); Assert.That(sparseArray[1, 1], Is.EqualTo(0.5 + (1.0 * Complex.ImaginaryOne)));
} }
/// <summary> /// <summary>
/// Test reading an object. /// Test reading an object.
/// </summary> /// </summary>
[Test] [Test]
public void TestObject() public void TestObject()
{ {
var matFile = GetTests("good")["object"]; var matFile = ReadLevel5TestFile("object");
var obj = matFile["object_"].Value as IMatObject; var obj = matFile["object_"].Value as IMatObject;
Assert.IsNotNull(obj); Assert.IsNotNull(obj);
Assert.That(obj.ClassName, Is.EqualTo("Point")); Assert.That(obj.ClassName, Is.EqualTo("Point"));
Assert.That(obj.FieldNames, Is.EquivalentTo(new[] { "x", "y" })); Assert.That(obj.FieldNames, Is.EquivalentTo(new[] { "x", "y" }));
Assert.That(obj["x", 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 3.0 })); Assert.That(obj["x", 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 3.0 }));
Assert.That(obj["y", 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 5.0 })); Assert.That(obj["y", 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 5.0 }));
Assert.That(obj["x", 1].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 })); Assert.That(obj["x", 1].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 }));
Assert.That(obj["y", 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 6.0 })); Assert.That(obj["y", 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 6.0 }));
} }
/// <summary> /// <summary>
/// Test reading another object. /// Test reading another object.
/// </summary> /// </summary>
[Test] [Test]
public void TestObject2() public void TestObject2()
{ {
var matFile = GetTests("good")["object2"]; var matFile = ReadLevel5TestFile("object2");
var obj = matFile["object2"].Value as IMatObject; var obj = matFile["object2"].Value as IMatObject;
Assert.IsNotNull(obj); Assert.IsNotNull(obj);
Assert.That(obj.ClassName, Is.EqualTo("Point")); Assert.That(obj.ClassName, Is.EqualTo("Point"));
Assert.That(obj.FieldNames, Is.EquivalentTo(new[] { "x", "y" })); Assert.That(obj.FieldNames, Is.EquivalentTo(new[] { "x", "y" }));
Assert.That(obj["x", 0, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 3.0 })); Assert.That(obj["x", 0, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 3.0 }));
Assert.That(obj["y", 0, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 5.0 })); Assert.That(obj["y", 0, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 5.0 }));
Assert.That(obj["x", 1, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0 })); Assert.That(obj["x", 1, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0 }));
Assert.That(obj["y", 1, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 0.0 })); Assert.That(obj["y", 1, 0].ConvertToDoubleArray(), Is.EqualTo(new[] { 0.0 }));
Assert.That(obj["x", 0, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 })); Assert.That(obj["x", 0, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 }));
Assert.That(obj["y", 0, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 6.0 })); Assert.That(obj["y", 0, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 6.0 }));
Assert.That(obj["x", 1, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 0.0 })); Assert.That(obj["x", 1, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 0.0 }));
Assert.That(obj["y", 1, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0 })); Assert.That(obj["y", 1, 1].ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0 }));
Assert.That(obj[0, 1]["x"].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 })); Assert.That(obj[0, 1]["x"].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 }));
Assert.That(obj[2]["x"].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 })); Assert.That(obj[2]["x"].ConvertToDoubleArray(), Is.EqualTo(new[] { -2.0 }));
} }
/// <summary> /// <summary>
/// Test reading a table. /// Test reading a table.
/// </summary> /// </summary>
[Test] [Test]
public void TestTable() public void TestTable()
{ {
var matFile = GetTests("good")["table"]; var matFile = ReadLevel5TestFile("table");
var obj = matFile["table_"].Value as IMatObject; var obj = matFile["table_"].Value as IMatObject;
var table = new TableAdapter(obj); var table = new TableAdapter(obj);
Assert.That(table.NumberOfRows, Is.EqualTo(3)); Assert.That(table.NumberOfRows, Is.EqualTo(3));
Assert.That(table.NumberOfVariables, Is.EqualTo(2)); Assert.That(table.NumberOfVariables, Is.EqualTo(2));
Assert.That(table.Description, Is.EqualTo("Some table")); Assert.That(table.Description, Is.EqualTo("Some table"));
Assert.That(table.VariableNames, Is.EqualTo(new[] { "variable1", "variable2" })); Assert.That(table.VariableNames, Is.EqualTo(new[] { "variable1", "variable2" }));
var variable1 = table["variable1"] as ICellArray; var variable1 = table["variable1"] as ICellArray;
Assert.That((variable1[0] as ICharArray).String, Is.EqualTo("First row")); Assert.That((variable1[0] as ICharArray).String, Is.EqualTo("First row"));
Assert.That((variable1[1] as ICharArray).String, Is.EqualTo("Second row")); Assert.That((variable1[1] as ICharArray).String, Is.EqualTo("Second row"));
Assert.That((variable1[2] as ICharArray).String, Is.EqualTo("Third row")); Assert.That((variable1[2] as ICharArray).String, Is.EqualTo("Third row"));
var variable2 = table["variable2"]; var variable2 = table["variable2"];
Assert.That(variable2.ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 })); Assert.That(variable2.ConvertToDoubleArray(), Is.EqualTo(new[] { 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 }));
} }
/// <summary> /// <summary>
/// Test subobjects within objects. /// Test subobjects within objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestSubobjects() public void TestSubobjects()
{ {
var matFile = GetTests("good")["pointWithSubpoints"]; var matFile = ReadLevel5TestFile("pointWithSubpoints");
var p = matFile["p"].Value as IMatObject; var p = matFile["p"].Value as IMatObject;
Assert.That(p.ClassName, Is.EqualTo("Point")); Assert.That(p.ClassName, Is.EqualTo("Point"));
var x = p["x"] as IMatObject; var x = p["x"] as IMatObject;
Assert.That(x.ClassName, Is.EqualTo("SubPoint")); Assert.That(x.ClassName, Is.EqualTo("SubPoint"));
Assert.That(x.FieldNames, Is.EquivalentTo(new[] { "a", "b", "c" })); Assert.That(x.FieldNames, Is.EquivalentTo(new[] { "a", "b", "c" }));
var y = p["y"] as IMatObject; var y = p["y"] as IMatObject;
Assert.That(y.ClassName, Is.EqualTo("SubPoint")); Assert.That(y.ClassName, Is.EqualTo("SubPoint"));
Assert.That(y.FieldNames, Is.EquivalentTo(new[] { "a", "b", "c" })); Assert.That(y.FieldNames, Is.EquivalentTo(new[] { "a", "b", "c" }));
Assert.That(x["a"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 1.0 })); Assert.That(x["a"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 1.0 }));
Assert.That(x["b"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 2.0 })); Assert.That(x["b"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 2.0 }));
Assert.That(x["c"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 3.0 })); Assert.That(x["c"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 3.0 }));
Assert.That(y["a"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 14.0 })); Assert.That(y["a"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 14.0 }));
Assert.That(y["b"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 15.0 })); Assert.That(y["b"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 15.0 }));
Assert.That(y["c"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 16.0 })); Assert.That(y["c"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 16.0 }));
} }
/// <summary> /// <summary>
/// Test nested objects. /// Test nested objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestNestedObjects() public void TestNestedObjects()
{ {
var matFile = GetTests("good")["subsubPoint"]; var matFile = ReadLevel5TestFile("subsubPoint");
var p = matFile["p"].Value as IMatObject; var p = matFile["p"].Value as IMatObject;
Assert.That(p.ClassName, Is.EqualTo("Point")); Assert.That(p.ClassName, Is.EqualTo("Point"));
Assert.That(p["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 1.0 })); Assert.That(p["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 1.0 }));
var pp = p["y"] as IMatObject; var pp = p["y"] as IMatObject;
Assert.That(pp.ClassName == "Point"); Assert.That(pp.ClassName == "Point");
Assert.That(pp["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 10.0 })); Assert.That(pp["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 10.0 }));
var ppp = pp["y"] as IMatObject; var ppp = pp["y"] as IMatObject;
Assert.That(ppp["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 100.0 })); Assert.That(ppp["x"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 100.0 }));
Assert.That(ppp["y"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 200.0 })); Assert.That(ppp["y"].ConvertToDoubleArray(), Is.EquivalentTo(new[] { 200.0 }));
} }
/// <summary> /// <summary>
/// Test datetime objects. /// Test datetime objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestDatetime() public void TestDatetime()
{ {
var matFile = GetTests("good")["datetime"]; var matFile = ReadLevel5TestFile("datetime");
var d = matFile["d"].Value as IMatObject; var d = matFile["d"].Value as IMatObject;
var datetime = new DatetimeAdapter(d); var datetime = new DatetimeAdapter(d);
Assert.That(datetime.Dimensions, Is.EquivalentTo(new[] { 1, 2 })); Assert.That(datetime.Dimensions, Is.EquivalentTo(new[] { 1, 2 }));
Assert.That(datetime[0], Is.EqualTo(new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero))); Assert.That(datetime[0], Is.EqualTo(new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero)));
Assert.That(datetime[1], Is.EqualTo(new DateTimeOffset(1987, 1, 2, 3, 4, 5, TimeSpan.Zero))); Assert.That(datetime[1], Is.EqualTo(new DateTimeOffset(1987, 1, 2, 3, 4, 5, TimeSpan.Zero)));
} }
/// <summary> /// <summary>
/// Another test for datetime objects. /// Another test for datetime objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestDatetime2() public void TestDatetime2()
{ {
var matFile = GetTests("good")["datetime2"]; var matFile = ReadLevel5TestFile("datetime2");
var d = matFile["d"].Value as IMatObject; var d = matFile["d"].Value as IMatObject;
var datetime = new DatetimeAdapter(d); var datetime = new DatetimeAdapter(d);
Assert.That(datetime.Dimensions, Is.EquivalentTo(new[] { 1, 1 })); Assert.That(datetime.Dimensions, Is.EquivalentTo(new[] { 1, 1 }));
var diff = new DateTimeOffset(2, 1, 1, 1, 1, 1, 235, TimeSpan.Zero); var diff = new DateTimeOffset(2, 1, 1, 1, 1, 1, 235, TimeSpan.Zero);
Assert.That(datetime[0] - diff < TimeSpan.FromMilliseconds(1)); Assert.That(datetime[0] - diff < TimeSpan.FromMilliseconds(1));
Assert.That(diff - datetime[0] < TimeSpan.FromMilliseconds(1)); Assert.That(diff - datetime[0] < TimeSpan.FromMilliseconds(1));
} }
/// <summary> /// <summary>
/// Test string objects. /// Test string objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestString() public void TestString()
{ {
var matFile = GetTests("good")["string"]; var matFile = ReadLevel5TestFile("string");
var s = matFile["s"].Value as IMatObject; var s = matFile["s"].Value as IMatObject;
var str = new StringAdapter(s); var str = new StringAdapter(s);
Assert.That(str.Dimensions, Is.EquivalentTo(new[] { 4, 1 })); Assert.That(str.Dimensions, Is.EquivalentTo(new[] { 4, 1 }));
Assert.That(str[0], Is.EqualTo("abc")); Assert.That(str[0], Is.EqualTo("abc"));
Assert.That(str[1], Is.EqualTo("defgh")); Assert.That(str[1], Is.EqualTo("defgh"));
Assert.That(str[2], Is.EqualTo("абвгд")); Assert.That(str[2], Is.EqualTo("абвгд"));
Assert.That(str[3], Is.EqualTo("æøå")); Assert.That(str[3], Is.EqualTo("æøå"));
} }
/// <summary> /// <summary>
/// Test duration objects. /// Test duration objects.
/// </summary> /// </summary>
[Test] [Test]
public void TestDuration() public void TestDuration()
{ {
var matFile = GetTests("good")["duration"]; var matFile = ReadLevel5TestFile("duration");
var d = matFile["d"].Value as IMatObject; var d = matFile["d"].Value as IMatObject;
var duration = new DurationAdapter(d); var duration = new DurationAdapter(d);
Assert.That(duration.Dimensions, Is.EquivalentTo(new[] { 1, 3 })); Assert.That(duration.Dimensions, Is.EquivalentTo(new[] { 1, 3 }));
Assert.That(duration[0], Is.EqualTo(TimeSpan.FromTicks(12345678L))); Assert.That(duration[0], Is.EqualTo(TimeSpan.FromTicks(12345678L)));
Assert.That(duration[1], Is.EqualTo(new TimeSpan(0, 2, 4))); Assert.That(duration[1], Is.EqualTo(new TimeSpan(0, 2, 4)));
Assert.That(duration[2], Is.EqualTo(new TimeSpan(1, 3, 5))); Assert.That(duration[2], Is.EqualTo(new TimeSpan(1, 3, 5)));
} }
/// <summary> /// <summary>
/// Test unrepresentable datetime. /// Test unrepresentable datetime.
/// </summary> /// </summary>
[Test] [Test]
public void TestDatetime_Unrepresentable() public void TestDatetime_Unrepresentable()
{ {
var matFile = GetTests("good")["datetime-unrepresentable"]; var matFile = ReadLevel5TestFile("datetime-unrepresentable");
var obj = matFile["d"].Value as IMatObject; var obj = matFile["d"].Value as IMatObject;
var datetime = new DatetimeAdapter(obj); var datetime = new DatetimeAdapter(obj);
var d0 = datetime[0]; var d0 = datetime[0];
Assert.That(d0, Is.Null); Assert.That(d0, Is.Null);
} }
private static AbstractTestDataFactory<IMatFile> GetTests(string factoryName) => private static AbstractTestDataFactory<IMatFile> GetTests(string factoryName) =>
new MatTestDataFactory(Path.Combine(TestDirectory, factoryName)); new MatTestDataFactory(Path.Combine(TestDirectory, factoryName));
private static void CheckLimits<T>(IArrayOf<T> array, T[] limits) private static void CheckLimits<T>(IArrayOf<T> array, T[] limits)
where T : struct where T : struct
{ {
Assert.That(array, Is.Not.Null); Assert.That(array, Is.Not.Null);
Assert.That(array.Dimensions, Is.EqualTo(new[] { 1, 2 })); Assert.That(array.Dimensions, Is.EqualTo(new[] { 1, 2 }));
Assert.That(array.Data, Is.EqualTo(limits)); Assert.That(array.Data, Is.EqualTo(limits));
} }
private static void CheckComplexLimits<T>(IArrayOf<ComplexOf<T>> array, T[] limits) private static void CheckComplexLimits<T>(IArrayOf<ComplexOf<T>> array, T[] limits)
where T : struct where T : struct
{ {
Assert.That(array, Is.Not.Null); Assert.That(array, Is.Not.Null);
Assert.That(array.Dimensions, Is.EqualTo(new[] { 1, 2 })); Assert.That(array.Dimensions, Is.EqualTo(new[] { 1, 2 }));
Assert.That(array[0], Is.EqualTo(new ComplexOf<T>(limits[0], limits[1]))); Assert.That(array[0], Is.EqualTo(new ComplexOf<T>(limits[0], limits[1])));
Assert.That(array[1], Is.EqualTo(new ComplexOf<T>(limits[1], limits[0]))); Assert.That(array[1], Is.EqualTo(new ComplexOf<T>(limits[1], limits[0])));
} }
}
private IMatFile ReadLevel5TestFile(string testName)
{
return GetTests("level5")[testName];
}
}
} }

25
MatFileHandler.Tests/MatFileWriterTests.cs
View File

@ -27,7 +27,7 @@ namespace MatFileHandler.Tests
array[1] = 17.0; array[1] = 17.0;
var variable = builder.NewVariable("test", array); var variable = builder.NewVariable("test", array);
var actual = builder.NewFile(new[] { variable }); var actual = builder.NewFile(new[] { variable });
MatCompareWithTestData("good", "double-array", actual); MatCompareWithLevel5TestData("double-array", actual);
} }
/// <summary> /// <summary>
@ -65,7 +65,7 @@ namespace MatFileHandler.Tests
var int64 = builder.NewVariable("int64_", builder.NewArray(CommonData.Int64Limits, 1, 2)); var int64 = builder.NewVariable("int64_", builder.NewArray(CommonData.Int64Limits, 1, 2));
var uint64 = builder.NewVariable("uint64_", builder.NewArray(CommonData.UInt64Limits, 1, 2)); var uint64 = builder.NewVariable("uint64_", builder.NewArray(CommonData.UInt64Limits, 1, 2));
var actual = builder.NewFile(new[] { int16, int32, int64, int8, uint16, uint32, uint64, uint8 }); var actual = builder.NewFile(new[] { int16, int32, int64, int8, uint16, uint32, uint64, uint8 });
MatCompareWithTestData("good", "limits", actual); MatCompareWithLevel5TestData("limits", actual);
} }
/// <summary> /// <summary>
@ -104,7 +104,7 @@ namespace MatFileHandler.Tests
int16Complex, int32Complex, int64Complex, int8Complex, int16Complex, int32Complex, int64Complex, int8Complex,
uint16Complex, uint32Complex, uint64Complex, uint8Complex, uint16Complex, uint32Complex, uint64Complex, uint8Complex,
}); });
MatCompareWithTestData("good", "limits_complex", actual); MatCompareWithLevel5TestData("limits_complex", actual);
} }
/// <summary> /// <summary>
@ -116,7 +116,7 @@ namespace MatFileHandler.Tests
var builder = new DataBuilder(); var builder = new DataBuilder();
var s = builder.NewVariable("s", builder.NewCharArray("🍆")); var s = builder.NewVariable("s", builder.NewCharArray("🍆"));
var actual = builder.NewFile(new[] { s }); var actual = builder.NewFile(new[] { s });
MatCompareWithTestData("good", "unicode-wide", actual); MatCompareWithLevel5TestData("unicode-wide", actual);
} }
/// <summary> /// <summary>
@ -133,7 +133,7 @@ namespace MatFileHandler.Tests
sparseArray[2, 3] = 4; sparseArray[2, 3] = 4;
var sparse = builder.NewVariable("sparse_", sparseArray); var sparse = builder.NewVariable("sparse_", sparseArray);
var actual = builder.NewFile(new[] { sparse }); var actual = builder.NewFile(new[] { sparse });
MatCompareWithTestData("good", "sparse", actual); MatCompareWithLevel5TestData("sparse", actual);
} }
/// <summary> /// <summary>
@ -161,7 +161,7 @@ namespace MatFileHandler.Tests
structure["y", 1, 2] = builder.NewEmpty(); structure["y", 1, 2] = builder.NewEmpty();
var struct_ = builder.NewVariable("struct_", structure); var struct_ = builder.NewVariable("struct_", structure);
var actual = builder.NewFile(new[] { struct_ }); var actual = builder.NewFile(new[] { struct_ });
MatCompareWithTestData("good", "struct", actual); MatCompareWithLevel5TestData("struct", actual);
} }
/// <summary> /// <summary>
@ -174,7 +174,7 @@ namespace MatFileHandler.Tests
var logical = builder.NewArray(new[] { true, false, true, true, false, true }, 2, 3); var logical = builder.NewArray(new[] { true, false, true, true, false, true }, 2, 3);
var logicalVariable = builder.NewVariable("logical_", logical); var logicalVariable = builder.NewVariable("logical_", logical);
var actual = builder.NewFile(new[] { logicalVariable }); var actual = builder.NewFile(new[] { logicalVariable });
MatCompareWithTestData("good", "logical", actual); MatCompareWithLevel5TestData("logical", actual);
} }
/// <summary> /// <summary>
@ -191,7 +191,7 @@ namespace MatFileHandler.Tests
array[1, 2] = true; array[1, 2] = true;
var sparseLogical = builder.NewVariable("sparse_logical", array); var sparseLogical = builder.NewVariable("sparse_logical", array);
var actual = builder.NewFile(new[] { sparseLogical }); var actual = builder.NewFile(new[] { sparseLogical });
MatCompareWithTestData("good", "sparse_logical", actual); MatCompareWithLevel5TestData("sparse_logical", actual);
} }
/// <summary> /// <summary>
@ -207,7 +207,7 @@ namespace MatFileHandler.Tests
array[1, 1] = 0.5 + Complex.ImaginaryOne; array[1, 1] = 0.5 + Complex.ImaginaryOne;
var sparseComplex = builder.NewVariable("sparse_complex", array); var sparseComplex = builder.NewVariable("sparse_complex", array);
var actual = builder.NewFile(new[] { sparseComplex }); var actual = builder.NewFile(new[] { sparseComplex });
MatCompareWithTestData("good", "sparse_complex", actual); MatCompareWithLevel5TestData("sparse_complex", actual);
} }
/// <summary> /// <summary>
@ -220,7 +220,7 @@ namespace MatFileHandler.Tests
var array = builder.NewArray(new double[] { 1, 3, 5 }, 1, 3); var array = builder.NewArray(new double[] { 1, 3, 5 }, 1, 3);
var global = builder.NewVariable("global_", array, true); var global = builder.NewVariable("global_", array, true);
var actual = builder.NewFile(new[] { global }); var actual = builder.NewFile(new[] { global });
MatCompareWithTestData("good", "global", actual); MatCompareWithLevel5TestData("global", actual);
} }
private static AbstractTestDataFactory<IMatFile> GetMatTestData(string factoryName) => private static AbstractTestDataFactory<IMatFile> GetMatTestData(string factoryName) =>
@ -398,6 +398,11 @@ namespace MatFileHandler.Tests
} }
} }
private void MatCompareWithLevel5TestData(string testName, IMatFile actual)
{
MatCompareWithTestData("level5", testName, actual);
}
private void MatCompareWithTestData(string factoryName, string testName, IMatFile actual) private void MatCompareWithTestData(string factoryName, string testName, IMatFile actual)
{ {
var expected = GetMatTestData(factoryName)[testName]; var expected = GetMatTestData(factoryName)[testName];

0
MatFileHandler.Tests/test-data/good/ascii.mat → MatFileHandler.Tests/test-data/level5/ascii.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/datetime-unrepresentable.mat → MatFileHandler.Tests/test-data/level5/datetime-unrepresentable.mat
View File

0
MatFileHandler.Tests/test-data/good/datetime.mat → MatFileHandler.Tests/test-data/level5/datetime.mat
View File

0
MatFileHandler.Tests/test-data/good/datetime2.mat → MatFileHandler.Tests/test-data/level5/datetime2.mat
View File

0
MatFileHandler.Tests/test-data/good/double-array.mat → MatFileHandler.Tests/test-data/level5/double-array.mat
View File

0
MatFileHandler.Tests/test-data/good/duration.mat → MatFileHandler.Tests/test-data/level5/duration.mat
View File

0
MatFileHandler.Tests/test-data/good/global.mat → MatFileHandler.Tests/test-data/level5/global.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/limits.mat → MatFileHandler.Tests/test-data/level5/limits.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/limits_complex.mat → MatFileHandler.Tests/test-data/level5/limits_complex.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/logical.mat → MatFileHandler.Tests/test-data/level5/logical.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/object.mat → MatFileHandler.Tests/test-data/level5/object.mat
View File

0
MatFileHandler.Tests/test-data/good/object2.mat → MatFileHandler.Tests/test-data/level5/object2.mat
View File

0
MatFileHandler.Tests/test-data/good/pointWithSubpoints.mat → MatFileHandler.Tests/test-data/level5/pointWithSubpoints.mat
View File

0
MatFileHandler.Tests/test-data/good/sparse.mat → MatFileHandler.Tests/test-data/level5/sparse.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/sparse_complex.mat → MatFileHandler.Tests/test-data/level5/sparse_complex.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/sparse_logical.mat → MatFileHandler.Tests/test-data/level5/sparse_logical.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/string.mat → MatFileHandler.Tests/test-data/level5/string.mat
View File

0
MatFileHandler.Tests/test-data/good/struct.mat → MatFileHandler.Tests/test-data/level5/struct.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/subsubPoint.mat → MatFileHandler.Tests/test-data/level5/subsubPoint.mat
View File

0
MatFileHandler.Tests/test-data/good/table.mat → MatFileHandler.Tests/test-data/level5/table.mat
View File

0
MatFileHandler.Tests/test-data/good/unicode-wide.mat → MatFileHandler.Tests/test-data/level5/unicode-wide.mat Executable file → Normal file
View File

0
MatFileHandler.Tests/test-data/good/unicode.mat → MatFileHandler.Tests/test-data/level5/unicode.mat Executable file → Normal file
View File

5
MatFileHandler/MatFileHandler.csproj
View File

@ -26,12 +26,13 @@
<AdditionalFiles Include="..\stylecop.json" /> <AdditionalFiles Include="..\stylecop.json" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="HDF.PInvoke.NETStandard" Version="1.10.200" />
<PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta004"> <PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta004">
<PrivateAssets>All</PrivateAssets> <PrivateAssets>All</PrivateAssets>
</PackageReference> </PackageReference>
<PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" /> <PackageReference Include="System.ValueTuple" Version="4.4.0" Condition="'$(TargetFramework)' == 'net461'" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="..\LICENSE.md" Pack="true" PackagePath=""/> <None Include="..\LICENSE.md" Pack="true" PackagePath="" />
</ItemGroup> </ItemGroup>
</Project> </Project>