public void CanReadDataset_Chunked_Legacy() { var versions = new H5F.libver_t[] { H5F.libver_t.EARLIEST, H5F.libver_t.V18 }; TestUtils.RunForVersions(versions, version => { foreach (var withShuffle in new bool[] { false, true }) { // Arrange var filePath = TestUtils.PrepareTestFile(version, fileId => TestUtils.AddChunkedDataset_Legacy(fileId, withShuffle)); // Act using var root = H5File.OpenReadCore(filePath, deleteOnClose: true); var parent = root.Group("chunked"); var dataset = parent.Dataset("chunked"); var actual = dataset.Read <int>(); // Assert Assert.True(actual.SequenceEqual(TestData.MediumData)); } }); }
public void DisposeOfProperly() { int N = H5Base.nObjects; using (H5File hf = H5File.Open(testfile, mode: "r")) { Assert.Equal(N + 2, H5Base.nObjects); // +file +root H5DataSet DSET = hf.Root["datasets/float2d"]; Assert.Equal(N + 3, H5Base.nObjects); // +dataset Assert.NotNull(DSET); Assert.Equal(2, DSET.Rank); Assert.Equal(Edge, DSET.Dims[0]); Assert.Equal(Edge, DSET.Dims[1]); Assert.Equal(Edge, DSET.MaxDims[0]); Assert.Equal(Edge, DSET.MaxDims[1]); Assert.Equal(Square, DSET.Length); Assert.Equal(typeof(float), DSET.PrimitiveType); // check, that the object count is stable.. Assert.Equal(N + 3, H5Base.nObjects); // +/- 0 DSET.Dispose(); Assert.Equal(N + 2, H5Base.nObjects); // -dataset } Assert.Equal(N + 0, H5Base.nObjects); // -root -file }
public void InjectReadonly() { string path = Path.Combine(demodata, "test_inject_readonly.h5"); if (!File.Exists(path)) { using (H5File hf = H5File.Open(path, "x")) { var dset = hf.Root.CreateDataset("existing", 1, new long[] { 1 }, typeof(int)); // make sure, the file is closed properly: dset.Dispose(); } } // first try: readonly file mode.. using (var hf = H5File.Open(path, "r")) { using (ReadOnlyObject myo = new ReadOnlyObject(hf.Root)) { // ..dataset has been skipped: Assert.Null(myo.readonli); Assert.NotNull(myo.existing); } } }
public void WriteToMapping() { using (TempH5FileContainer container = new TempH5FileContainer()) { H5File hf = container.Content(); Assert.True(hf.Root.IsWritable); MyNewObject myo = new MyNewObject(hf.Root); Assert.Throws <KeyNotFoundException>(() => myo.Attr["not_existing"]); Assert.NotNull(myo.Attr["please_create"]); Assert.NotNull(myo.Attr["dataset_attr"]); myo.Attr["dataset_attr"].Writes("foo"); myo.Attr["please_create"].Write(3.14f); Assert.Throws <InvalidCastException>(() => myo.Attr["please_create"].Write(3.14)); Assert.Equal("foo", myo.Attr["dataset_attr"].Reads()); Assert.Equal(3.14f, myo.Attr["please_create"].Read <float>()); Assert.Equal(3.14f, myo.Attr["please_create"].Read()); myo.Dispose(); } }
public void Test_Link_Dont_Exist(string key) { using (H5File hf = H5File.Open(demodata + "test_link_exists.h5", mode: "r")) { Assert.False(H5Link.Exists(hf.ID, key)); } }
public void AttemptToWriteClosedFileFails() { string path = Path.GetTempFileName(); H5File FILE = H5File.Open(path, mode: "w"); // create some stuff.. H5Group GROUP = FILE.Root.SubGroup("foo", create: true); GROUP.CreateDataset("bar", 1, new long[] { 7L }, typeof(byte)); dset1d <byte> DSET = GROUP["bar"] as dset1d <byte>; Assert.NotNull(DSET); DSET[3] = 5; // close all H5Objects manually in this test-scenario: GROUP.Dispose(); DSET.Dispose(); FILE.Dispose(); // the file.ID becomes the H5F.close() return value, which is often // (but not guaranteed to be) zero / non-negative: Assert.Equal((H5Ohm.hid_t) 0, FILE.ID); Assert.Equal((H5Ohm.hid_t) 0, FILE.Root.ID); Assert.Equal((H5Ohm.hid_t) 0, DSET.ID); Assert.Equal((H5Ohm.hid_t) 0, GROUP.ID); Assert.Throws <InvalidOperationException>(() => FILE.Root["foo/bar"]); Assert.Throws <InvalidOperationException>(() => DSET[5] = 3); Assert.Throws <InvalidOperationException>(() => GROUP["bar"]); }
public void double2d_Arrays() { using (H5File hf = H5File.Open(testfile, mode: "r")) { dset2d <double> DSET = hf.Root["datasets/double2d"] as dset2d <double>; Assert.NotNull(DSET); Assert.Equal(Square, DSET.Length); Assert.Equal(new double[] { 0, 0, 4, 0, 0, 0, 0 }, DSET.Row(2)); Assert.Equal(new double[] { 0, 0, 0, 9, 0, 0, 0 }, DSET.Row(3)); Assert.Equal(new double[] { 0, 0, 0, 0, 0, 25, 0 }, DSET.Row(5)); Assert.Equal(new double[] { 0, 1, 4, 9, 16, 25, 36 }, DSET.Row(6)); Assert.Equal(new double[] { 0, 0, 4, 0, 0, 0, 4 }, DSET.Column(2)); Assert.Equal(new double[] { 0, 0, 0, 9, 0, 0, 9 }, DSET.Column(3)); Assert.Equal(new double[] { 0, 0, 0, 0, 0, 25, 25 }, DSET.Column(5)); Assert.Equal(new double[] { 0, 0, 0, 0, 0, 0, 36 }, DSET.Column(6)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Row(7)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Row(17)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Row(-1)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Column(7)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Column(17)); Assert.Throws <IndexOutOfRangeException>(() => DSET.Column(-1)); } }
public void ClosePreviouslyInitializedFile() { string path = Path.GetTempFileName(); H5File FILE = H5File.Open(path, mode: "w"); // initialize a test-object, which creates two datasets: var PIG = new GuineaPig(FILE.Root); Assert.True(PIG.stringset.ID > 0); Assert.True(PIG.byteset.ID > 0); // th test-object must be disposed of as this is not automatic: PIG.Dispose(); FILE.Dispose(); // trying to re-open is a surefire way to check if FILE was closed correctly: H5File FILE2 = H5File.Open(path, mode: "w"); FILE2.Dispose(); Assert.Equal((hid_t)0, PIG.stringset.ID); Assert.Equal((hid_t)0, PIG.byteset.ID); File.Delete(path); Assert.False(File.Exists(FILE.Path)); }
public void string2d_To2dArray() { using (H5File hf = H5File.Open(testfile, mode: "r")) { string2d DSET = hf.Root["datasets/string2d"] as string2d; Assert.NotNull(DSET); Assert.Equal(5 * 5, DSET.Length); var expect = new string[5, 5] { { "foo", "", "", "", "", }, { "", "bar", "", "", "", }, { "", "", "zoom", "", "", }, { "", "", "", "grok", "", }, { "foo", "bar", "zoom", "grok", "yom" }, }; var actual = DSET.Values; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { Assert.Equal(expect[i, j], actual[i, j]); } } } }
public void float2d_To2dArray() { using (H5File hf = H5File.Open(testfile, mode: "r")) { dset2d <float> DSET = hf.Root["datasets/float2d"] as dset2d <float>; Assert.NotNull(DSET); Assert.Equal(Square, DSET.Length); var expect = new float[7, 7] { { 0, 0, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 }, { 0, 0, 4, 0, 0, 0, 0 }, { 0, 0, 0, 9, 0, 0, 0 }, { 0, 0, 0, 0, 16, 0, 0 }, { 0, 0, 0, 0, 0, 25, 0 }, { 0, 1, 4, 9, 16, 25, 36 }, }; var actual = DSET.Values; for (int i = 0; i < 7; i++) { for (int j = 0; j < 7; j++) { Assert.Equal(expect[i, j], actual[i, j]); } } } }
public void CanAccessAbsolutePaths() { using (var container = new TempH5FileContainer()) { H5File hf = container.Content(); using (H5Group GRP = hf.Root.CreateGroup("foo")) { H5Group SUBGRP = GRP.SubGroup("bar", create: true); SUBGRP.Dispose(); Assert.True(H5Link.Exists(hf.ID, "/foo/")); Assert.True(H5Link.Exists(hf.ID, "/foo/bar/")); SUBGRP = hf.Root.SubGroup("/foo"); Assert.NotNull(GRP); SUBGRP.Dispose(); SUBGRP = hf.Root.SubGroup("/foo/bar"); Assert.NotNull(GRP); SUBGRP.Dispose(); SUBGRP = hf.Root.SubGroup("foo/bar"); Assert.NotNull(SUBGRP); SUBGRP.Dispose(); } } }
public void CanDefilterBZip2() { // # Works only with Linux! On Windows, deflate is used instead. // import numpy // import tables // fileName = 'bzip2.h5' // shape = (1000,) // atom = tables.Int32Atom() // filters = tables.Filters(complevel=9, complib='bzip2') // with tables.open_file(fileName, 'w') as f: // dataset = f.create_carray(f.root, 'bzip2', atom, shape, filters=filters) // dataset[:] = list(range(0, 1000)) // Arrange var filePath = "./testfiles/bzip2.h5"; var expected = Enumerable.Range(0, 1000).ToArray(); H5Filter.Register(identifier: (H5FilterID)307, name: "bzip2", filterFunc: BZip2Helper.FilterFunc); // Act using var root = H5File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read); var dataset = root.Dataset("bzip2"); var actual = dataset.Read <int>(); // Assert Assert.True(actual.SequenceEqual(expected)); }
public void Elements() { using (H5File hf = H5File.Open(testfile, mode: "r")) { using (dset1d <int> DSET = hf.Root["datasets/int1d"] as dset1d <int>) { Assert.NotNull(DSET); var actual = DSET.Elements().ToArray(); var expected = new int[] { 0, 1, 2, 3, 4, 5, 6 }; Assert.Equal(expected, actual); } using (dset2d <int> DSET = hf.Root["datasets/int2d"] as dset2d <int>) { Assert.NotNull(DSET); var actual = DSET.Elements().Skip(5 * 7 + 4).Take(7).ToArray(); var expected = new int[7] { 0, 25, 0, 0, 1, 4, 9 }; Assert.Equal(expected, actual); } } }
public void DeleteSubGroup() { using (var container = new TempH5FileContainer()) { H5File hf = container.Content(); Assert.False(H5Link.Exists(hf.ID, "foo")); Assert.False(H5Link.Exists(hf.ID, "bar")); using (hf.Root.CreateGroup("foo")) { } using (hf.Root.CreateGroup("bar")) { } Assert.True(H5Link.Exists(hf.ID, "foo")); Assert.True(H5Link.Exists(hf.ID, "bar")); hf.Root.DeleteGroup("bar"); Assert.True(H5Link.Exists(hf.ID, "foo")); Assert.False(H5Link.Exists(hf.ID, "bar")); hf.Root.DeleteGroup("foo"); Assert.False(H5Link.Exists(hf.ID, "foo")); Assert.False(H5Link.Exists(hf.ID, "bar")); } }
public void CreateSubGroup() { using (var container = new TempH5FileContainer()) { H5File hf = container.Content(); Assert.False(H5Link.Exists(hf.ID, "foo")); Assert.Throws <KeyNotFoundException>(() => hf.Root.SubGroup("foo")); using (var GRP = hf.Root.CreateGroup("foo")) { Assert.True(H5Link.Exists(hf.ID, "foo")); using (hf.Root.SubGroup("foo")) { } // dispose immediately Assert.False(H5Link.Exists(hf.ID, "bar")); Assert.Throws <KeyNotFoundException>(() => hf.Root.SubGroup("bar")); // create on-the-fly.. using (hf.Root.SubGroup("bar", create: true)) { } Assert.True(H5Link.Exists(hf.ID, "bar")); } } }
public void ComplexDatatypeCreate() { var points = new NamedPoint[10]; for (int i = 0; i < 10; i++) { var p = new NamedPoint {point = {x = i*2, y = i*3}}; var name = Encoding.ASCII.GetBytes(i.ToString()); unsafe { Marshal.Copy(name, 0, (IntPtr)p.name, name.Length); } points[i] = p; } using (var file = new H5File(TEST_FILE)) { var stringType = file.CreateDatatype("STRING", H5T.H5TClass.STRING, 40); var pointType = file.CreateDatatype("POINT", new[] {"x", "y"}, new[] { new H5Datatype(H5T.H5Type.NATIVE_DOUBLE), new H5Datatype(H5T.H5Type.NATIVE_DOUBLE) }); var type = file.CreateDatatype("NAMED_POINT", new[] {"name", "point"}, new[] {stringType, pointType}); var dataset = file.AddDataset("points", type, points); Assert.AreEqual(points, dataset.GetData<NamedPoint>()); } }
public void CanReadDataset_CompactTestFile() { TestUtils.RunForAllVersions(version => { // Arrange var filePath = "testfiles/h5ex_d_compact.h5"; var expected = new int[4, 7]; for (int i = 0; i < 4; i++) { for (int j = 0; j < 7; j++) { expected[i, j] = i * j - j; } } // Act using var root = H5File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read); var parent = root; var dataset = parent.Dataset("DS1"); var actual = dataset.Read <int>(); // Assert Assert.True(actual.SequenceEqual(expected.Cast <int>())); }); }
public void CanUnshuffleGeneric <T>(T dummy, int length) where T : unmanaged { // Arrange var version = H5F.libver_t.LATEST; var bytesOfType = Unsafe.SizeOf <T>(); var expected = Enumerable.Range(0, length * bytesOfType) .Select(value => unchecked ((byte)value)).ToArray(); var filePath = TestUtils.PrepareTestFile(version, fileId => TestUtils.AddFilteredDataset_Shuffle(fileId, bytesOfType: bytesOfType, length, expected)); using var root = H5File.OpenReadCore(filePath, deleteOnClose: true); var parent = root.Group("filtered"); var dataset = parent.Dataset($"shuffle_{bytesOfType}"); var actual_shuffled = dataset.Read <byte>(null, skipShuffle: true); // Act var actual = new byte[actual_shuffled.Length]; ShuffleGeneric.Unshuffle(bytesOfType, actual_shuffled, actual); // Assert Assert.True(actual.AsSpan().SequenceEqual(expected)); }
public void CanReadDataset_Reference_Region() { TestUtils.RunForAllVersions(version => { // Arrange var filePath = TestUtils.PrepareTestFile(version, fileId => TestUtils.AddRegionReference(fileId, ContainerType.Dataset)); // Act using var root = H5File.OpenReadCore(filePath, deleteOnClose: true); var dataset_references = root.Group("reference").Dataset("region_reference"); var references = dataset_references.Read <H5RegionReference>(); var reference = references[0]; root.Context.Reader.Seek((long)reference.CollectionAddress, SeekOrigin.Begin); // H5Rint.c (H5R__get_region) #warning use more structs? var globalHeapId = new GlobalHeapId(root.Context.Superblock) { CollectionAddress = reference.CollectionAddress, ObjectIndex = reference.ObjectIndex }; var globalHeapCollection = globalHeapId.Collection; var globalHeapObject = globalHeapCollection.GlobalHeapObjects[(int)globalHeapId.ObjectIndex - 1]; var localReader = new H5BinaryReader(new MemoryStream(globalHeapObject.ObjectData)); var address = root.Context.Superblock.ReadOffset(localReader); var selection = new DataspaceSelection(localReader); throw new NotImplementedException(); }); }
public void CanReadAttribute_Reference_Object() { TestUtils.RunForAllVersions(version => { // Arrange var filePath = TestUtils.PrepareTestFile(version, fileId => TestUtils.AddObjectReference(fileId, ContainerType.Attribute)); // Act using var root = H5File.OpenReadCore(filePath, deleteOnClose: true); var attribute_references = root.Group("reference").Attribute("object_reference"); var references = attribute_references.Read <H5ObjectReference>(); var dereferenced = references .Select(reference => root.Get(reference)) .ToArray(); // Assert for (int i = 0; i < TestData.NumericalData.Count; i++) { var dataset = (H5Dataset)dereferenced[i]; var expected = (Array)TestData.NumericalData[i][1]; var elementType = expected.GetType().GetElementType(); var method = typeof(TestUtils).GetMethod(nameof(TestUtils.ReadAndCompare), BindingFlags.Public | BindingFlags.Static); var generic = method.MakeGenericMethod(elementType); var result = (bool)generic.Invoke(null, new object[] { dataset, expected }); Assert.True(result); } }); }
public void CanReadWrappedFiles() { // Arrange var filePath = "testfiles/secret.mat"; // Act using var root = H5File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, deleteOnClose: true); var children = root.Children.ToList(); }
public void OpenNonExistingFails() { string path = Path.Combine(demodata, "aeroiyu359hnfna.soie"); Assert.False(File.Exists(path)); Assert.Throws <FileNotFoundException>(() => H5File.Open(path, mode: "r")); Assert.Throws <FileNotFoundException>(() => H5File.Open(path, mode: "r+")); }
public void CreateDatasetFails() { using (var container = new TempH5FileContainer(filemode: "r")) { H5File hf = container.Content(); Assert.Throws <InvalidOperationException>(() => hf.Root.CreateDataset("zoom", 2, new long[] { 3, 4 }, typeof(float))); } }
public void CanReadWrappedFiles() { // Arrange var filePath = "testfiles/secret.mat"; // Act using var root = H5File.OpenReadCore(filePath, deleteOnClose: true); var children = root.Children.ToList(); }
public TempH5FileContainer(string filemode = "w") { string temp_path = System.IO.Path.GetTempFileName(); hf = H5File.Open(temp_path, mode: "w"); // close.. hf.Dispose(); // ..to reopen: hf = H5File.Open(temp_path, mode: filemode); }
public void NonexistingLookupFails() { using (var container = new TempH5FileContainer()) { H5File hf = container.Content(); Assert.Throws <KeyNotFoundException>(() => hf.Root["zoom"]); Assert.Throws <KeyNotFoundException>(() => hf.Root["foo/bar"]); } }
static void Main(string[] args) { using (var hf = H5File.Open("example.h5", "w")) { using (new MyObject(hf.Root)) { // ... work, work, work ... } } }
public void CreateGroupFails() { using (var container = new TempH5FileContainer(filemode: "r")) { H5File hf = container.Content(); Assert.Throws <InvalidOperationException>(() => hf.Root.SubGroup("foo", create: true)); Assert.Throws <InvalidOperationException>(() => hf.Root.CreateGroup("bar")); } }
public void InitObjectFails() { using (var container = new TempH5FileContainer(filemode: "r")) { H5File hf = container.Content(); Assert.False(hf.Root.IsWritable); Assert.Throws <InvalidOperationException>(() => new GuineaPig(hf.Root)); } }
public void LocateDatasetWith2DProperties(string key) { using (H5File hf = H5File.Open(demodata + "test_link_exists.h5", mode: "r")) { H5DataSet dset = hf.Root[key]; Assert.Equal(2, dset.Rank); Assert.Equal(49L, dset.Length); Assert.Equal(new long[] { 7, 7 }, dset.Dims); } }
public void CannotCreateMultipleGroups() { using (var container = new TempH5FileContainer()) { H5File hf = container.Content(); Assert.False(H5Link.Exists(hf.ID, "grok/")); Assert.False(H5Link.Exists(hf.ID, "grok/fitz")); Assert.Throws <InvalidOperationException>(() => hf.Root.CreateGroup("grok/fitz")); } }
public void NestsGroups() { using (var file = new H5File(TEST_FILE)) { file.AddGroup("out").AddGroup("mid").AddGroup("in"); Assert.AreEqual(1, file.Groups.Count()); var o = file.Groups.First(); Assert.AreEqual("out", o.Name); Assert.AreEqual(1, o.Groups.Count()); var m = o.Groups.First(); Assert.AreEqual("mid", m.Name); Assert.AreEqual(1, m.Groups.Count()); var i = m.Groups.First(); Assert.AreEqual("in", i.Name); Assert.AreEqual(0, i.Groups.Count()); } }
internal H5Datatype(H5File file, string path) : base(file, path) { }
internal H5Attribute(H5File file, string path, string name) : base(file, path) { _name = name; }
protected H5Object(H5File file, string path) { File = file; Path = path; }
internal H5Link(H5File file, string path) : base(file, path) { }
public void ShouldAddEmptyStringAttribute() { using (var file = new H5File(TEST_FILE)) { file.Attributes["attr"] = ""; Assert.AreEqual("", file.Attributes["attr"].GetValue()); } }
public void ShouldDeleteGroup() { using (var file = new H5File(TEST_FILE)) { var group = file.AddGroup("group"); group.Delete(); Assert.AreEqual(0, file.Groups.Count()); } using (var file = new H5File(TEST_FILE)) { Assert.AreEqual(0, file.Groups.Count()); } }
public void ShouldExtendChunkDataset() { using (var file = new H5File(TEST_FILE)) { var type = file.CreateDatatype("POINT", new[] { "x", "y" }, new[] { new H5Datatype(H5T.H5Type.NATIVE_DOUBLE), new H5Datatype(H5T.H5Type.NATIVE_DOUBLE) }); var dataset = file.AddDataset("points", type, new long[] {0}, new long[] {-1}, new long[] {64}); var points = new[] {new Point {x = 1, y = 2}}; // Dataset not yet extended dataset.SetData(points); Assert.AreEqual(0, dataset.GetData<Point>().Count()); dataset.Extend(new long[] {1}); dataset.SetData(points); Assert.AreEqual(1, dataset.GetData<Point>().Count()); Assert.AreEqual(points, dataset.GetData<Point>()); } }
public void PropertyShouldReturnSameObject() { using (var file = new H5File(TEST_FILE)) { var g1 = file.AddGroup("group"); var g2 = file.Groups.First(); var g3 = file.Groups.First(); Assert.IsTrue(g1 == g2 && g2 == g3); } }
public void ObjectsWithSamePathShouldBeEqual() { using (var file = new H5File(TEST_FILE)) { var group = file.AddGroup("group"); Assert.AreEqual(group, file.Groups.First()); } }
public void SimpleGroupCreateFind() { using (var file = new H5File(TEST_FILE)) { file.AddGroup("simple"); } using (var file = new H5File(TEST_FILE)) { Assert.AreEqual(1, file.Groups.Count()); var group = file.Groups.First(); Assert.AreEqual("simple", group.Name); Assert.AreEqual(0, group.Groups.Count()); } }
public void ShouldOverwriteAttribute() { using (var file = new H5File(TEST_FILE)) { file.Attributes["attr"] = "banana"; file.Attributes["attr"] = 123; var attr = file.Attributes.First(); Assert.AreEqual("attr", attr.Name); Assert.AreEqual(123, attr.GetValue()); } }
public void SimpleDatatypeCreateFind() { var points = new Point[10]; for (int i = 0; i < points.Length; i++) { points[i].x = i; points[i].y = i*3; } using (var file = new H5File(TEST_FILE)) { var type = file.CreateDatatype("POINT", new[] {"x", "y"}, new[] { new H5Datatype(H5T.H5Type.NATIVE_DOUBLE), new H5Datatype(H5T.H5Type.NATIVE_DOUBLE) }); var dataset = file.AddDataset("points", type, points); } using (var file = new H5File(TEST_FILE)) { Assert.AreEqual(1, file.Datasets.Count()); var dataset = file.Datasets.First(); var actual = dataset.GetData<Point>(); Assert.AreEqual(points, actual); } }
public void SimpleAttributeCreateFind() { var attributes = new Dictionary<string, object>() { {"attr1", "hello world!"}, {"attr2", 15.6}, {"attr3", new[] {3, 2, 1}} }; using (var file = new H5File(TEST_FILE)) { var group = file.AddGroup("simple"); foreach (var kv in attributes) { group.Attributes[kv.Key] = new H5Attribute(kv.Value); } } using (var file = new H5File(TEST_FILE)) { Assert.AreEqual(1, file.Groups.Count()); var group = file.Groups.First(); var actual = group.Attributes.ToDictionary(a => a.Name, a => a.GetValue()); Assert.AreEqual(attributes, actual); } }
public void ShouldRemoveAttribute() { using (var file = new H5File(TEST_FILE)) { file.Attributes["attr"] = "wowow"; file.Attributes.Remove("attr"); Assert.AreEqual(0, file.Attributes.Count()); } }