From bfa4dba15485b4192f8bbe13345e9658c97ecf76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Picca=20Fr=C3=A9d=C3=A9ric-Emmanuel?= Date: Sat, 7 Oct 2017 07:59:01 +0200 Subject: New upstream version 0.6.0+dfsg --- silx/gui/hdf5/test/_mock.py | 130 ------------ silx/gui/hdf5/test/test_hdf5.py | 454 ++++++++++++++++++++++++++++++++++++---- 2 files changed, 409 insertions(+), 175 deletions(-) delete mode 100644 silx/gui/hdf5/test/_mock.py (limited to 'silx/gui/hdf5/test') diff --git a/silx/gui/hdf5/test/_mock.py b/silx/gui/hdf5/test/_mock.py deleted file mode 100644 index eada590..0000000 --- a/silx/gui/hdf5/test/_mock.py +++ /dev/null @@ -1,130 +0,0 @@ -# coding: utf-8 -# /*########################################################################## -# -# Copyright (c) 2016-2017 European Synchrotron Radiation Facility -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -# ###########################################################################*/ -"""Mock for silx.gui.hdf5 module""" - -__authors__ = ["V. Valls"] -__license__ = "MIT" -__date__ = "12/04/2017" - - -import numpy -try: - import h5py -except ImportError: - h5py = None - - -class Node(object): - - def __init__(self, basename, parent, h5py_class): - self.basename = basename - self.h5py_class = h5py_class - self.attrs = {} - self.parent = parent - if parent is not None: - self.parent._add(self) - - @property - def name(self): - if self.parent is None: - return self.basename - if self.parent.name == "": - return self.basename - return self.parent.name + "/" + self.basename - - @property - def file(self): - if self.parent is None: - return self - return self.parent.file - - -class Group(Node): - """Mock an h5py Group""" - - def __init__(self, name, parent, h5py_class=h5py.Group): - super(Group, self).__init__(name, parent, h5py_class) - self.__items = {} - - def _add(self, node): - self.__items[node.basename] = node - - def __getitem__(self, key): - return self.__items[key] - - def __iter__(self): - for k in self.__items: - yield k - - def __len__(self): - return len(self.__items) - - def get(self, name, getclass=False, getlink=False): - result = self.__items[name] - if getclass: - return result.h5py_class - return result - - def create_dataset(self, name, data): - return Dataset(name, self, data) - - def create_group(self, name): - return Group(name, self) - - def create_NXentry(self, name): - group = Group(name, self) - group.attrs["NX_class"] = "NXentry" - return group - - -class File(Group): - """Mock an h5py File""" - - def __init__(self, filename): - super(File, self).__init__("", None, h5py.File) - self.filename = filename - - -class Dataset(Node): - """Mock an h5py Dataset""" - - def __init__(self, name, parent, value): - super(Dataset, self).__init__(name, parent, h5py.Dataset) - self.__value = value - self.shape = self.__value.shape - self.dtype = self.__value.dtype - self.size = self.__value.size - self.compression = None - self.compression_opts = None - - def __getitem__(self, key): - if not isinstance(self.__value, numpy.ndarray): - if key == tuple(): - return self.__value - elif key == Ellipsis: - return numpy.array(self.__value) - else: - raise ValueError("Bad key") - return self.__value[key] diff --git a/silx/gui/hdf5/test/test_hdf5.py b/silx/gui/hdf5/test/test_hdf5.py index 3bf4897..8e375f2 100644 --- a/silx/gui/hdf5/test/test_hdf5.py +++ b/silx/gui/hdf5/test/test_hdf5.py @@ -26,7 +26,7 @@ __authors__ = ["V. Valls"] __license__ = "MIT" -__date__ = "12/04/2017" +__date__ = "22/09/2017" import time @@ -34,11 +34,12 @@ import os import unittest import tempfile import numpy +import shutil from contextlib import contextmanager from silx.gui import qt from silx.gui.test.utils import TestCaseQt from silx.gui import hdf5 -from . import _mock +from silx.io import commonh5 try: import h5py @@ -54,6 +55,13 @@ class _Holder(object): _called += 1 +def create_NXentry(group, name): + attrs = {"NX_class": "NXentry"} + node = commonh5.Group(name, parent=group, attrs=attrs) + group.add_node(node) + return node + + class TestHdf5TreeModel(TestCaseQt): def setUp(self): @@ -124,14 +132,14 @@ class TestHdf5TreeModel(TestCaseQt): h5File.close() def testInsertObject(self): - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") model = hdf5.Hdf5TreeModel() self.assertEquals(model.rowCount(qt.QModelIndex()), 0) model.insertH5pyObject(h5) self.assertEquals(model.rowCount(qt.QModelIndex()), 1) def testRemoveObject(self): - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") model = hdf5.Hdf5TreeModel() self.assertEquals(model.rowCount(qt.QModelIndex()), 0) model.insertH5pyObject(h5) @@ -223,7 +231,7 @@ class TestHdf5TreeModel(TestCaseQt): return model.data(index, qt.Qt.DisplayRole) def testFileData(self): - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") model = hdf5.Hdf5TreeModel() model.insertH5pyObject(h5) displayed = self.getRowDataAsDict(model, row=0) @@ -236,7 +244,7 @@ class TestHdf5TreeModel(TestCaseQt): self.assertEquals(displayed[hdf5.Hdf5TreeModel.NODE_COLUMN, qt.Qt.DisplayRole], "File") def testGroupData(self): - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") d = h5.create_group("foo") d.attrs["desc"] = "fooo" @@ -252,9 +260,9 @@ class TestHdf5TreeModel(TestCaseQt): self.assertEquals(displayed[hdf5.Hdf5TreeModel.NODE_COLUMN, qt.Qt.DisplayRole], "Group") def testDatasetData(self): - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") value = numpy.array([1, 2, 3]) - d = h5.create_dataset("foo", value) + d = h5.create_dataset("foo", data=value) model = hdf5.Hdf5TreeModel() model.insertH5pyObject(d) @@ -269,8 +277,8 @@ class TestHdf5TreeModel(TestCaseQt): def testDropLastAsFirst(self): model = hdf5.Hdf5TreeModel() - h5_1 = _mock.File("/foo/bar/1.mock") - h5_2 = _mock.File("/foo/bar/2.mock") + h5_1 = commonh5.File("/foo/bar/1.mock", "w") + h5_2 = commonh5.File("/foo/bar/2.mock", "w") model.insertH5pyObject(h5_1) model.insertH5pyObject(h5_2) self.assertEquals(self.getItemName(model, 0), "1.mock") @@ -283,8 +291,8 @@ class TestHdf5TreeModel(TestCaseQt): def testDropFirstAsLast(self): model = hdf5.Hdf5TreeModel() - h5_1 = _mock.File("/foo/bar/1.mock") - h5_2 = _mock.File("/foo/bar/2.mock") + h5_1 = commonh5.File("/foo/bar/1.mock", "w") + h5_2 = commonh5.File("/foo/bar/2.mock", "w") model.insertH5pyObject(h5_1) model.insertH5pyObject(h5_2) self.assertEquals(self.getItemName(model, 0), "1.mock") @@ -297,7 +305,7 @@ class TestHdf5TreeModel(TestCaseQt): def testRootParent(self): model = hdf5.Hdf5TreeModel() - h5_1 = _mock.File("/foo/bar/1.mock") + h5_1 = commonh5.File("/foo/bar/1.mock", "w") model.insertH5pyObject(h5_1) index = model.index(0, 0, qt.QModelIndex()) index = model.parent(index) @@ -318,10 +326,10 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testNXentryStartTime(self): """Test NXentry with start_time""" model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") - h5.create_NXentry("a").create_dataset("start_time", numpy.string_("2015")) - h5.create_NXentry("b").create_dataset("start_time", numpy.string_("2013")) - h5.create_NXentry("c").create_dataset("start_time", numpy.string_("2014")) + h5 = commonh5.File("/foo/bar/1.mock", "w") + create_NXentry(h5, "a").create_dataset("start_time", data=numpy.string_("2015")) + create_NXentry(h5, "b").create_dataset("start_time", data=numpy.string_("2013")) + create_NXentry(h5, "c").create_dataset("start_time", data=numpy.string_("2014")) model.insertH5pyObject(h5) proxy = hdf5.NexusSortFilterProxyModel() @@ -333,10 +341,10 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testNXentryStartTimeInArray(self): """Test NXentry with start_time""" model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") - h5.create_NXentry("a").create_dataset("start_time", numpy.array([numpy.string_("2015")])) - h5.create_NXentry("b").create_dataset("start_time", numpy.array([numpy.string_("2013")])) - h5.create_NXentry("c").create_dataset("start_time", numpy.array([numpy.string_("2014")])) + h5 = commonh5.File("/foo/bar/1.mock", "w") + create_NXentry(h5, "a").create_dataset("start_time", data=numpy.array([numpy.string_("2015")])) + create_NXentry(h5, "b").create_dataset("start_time", data=numpy.array([numpy.string_("2013")])) + create_NXentry(h5, "c").create_dataset("start_time", data=numpy.array([numpy.string_("2014")])) model.insertH5pyObject(h5) proxy = hdf5.NexusSortFilterProxyModel() @@ -348,10 +356,10 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testNXentryEndTimeInArray(self): """Test NXentry with end_time""" model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") - h5.create_NXentry("a").create_dataset("end_time", numpy.array([numpy.string_("2015")])) - h5.create_NXentry("b").create_dataset("end_time", numpy.array([numpy.string_("2013")])) - h5.create_NXentry("c").create_dataset("end_time", numpy.array([numpy.string_("2014")])) + h5 = commonh5.File("/foo/bar/1.mock", "w") + create_NXentry(h5, "a").create_dataset("end_time", data=numpy.array([numpy.string_("2015")])) + create_NXentry(h5, "b").create_dataset("end_time", data=numpy.array([numpy.string_("2013")])) + create_NXentry(h5, "c").create_dataset("end_time", data=numpy.array([numpy.string_("2014")])) model.insertH5pyObject(h5) proxy = hdf5.NexusSortFilterProxyModel() @@ -363,10 +371,10 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testNXentryName(self): """Test NXentry without start_time or end_time""" model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") - h5.create_NXentry("a") - h5.create_NXentry("c") - h5.create_NXentry("b") + h5 = commonh5.File("/foo/bar/1.mock", "w") + create_NXentry(h5, "a") + create_NXentry(h5, "c") + create_NXentry(h5, "b") model.insertH5pyObject(h5) proxy = hdf5.NexusSortFilterProxyModel() @@ -378,10 +386,10 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testStartTime(self): """If it is not NXentry, start_time is not used""" model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") - h5.create_group("a").create_dataset("start_time", numpy.string_("2015")) - h5.create_group("b").create_dataset("start_time", numpy.string_("2013")) - h5.create_group("c").create_dataset("start_time", numpy.string_("2014")) + h5 = commonh5.File("/foo/bar/1.mock", "w") + h5.create_group("a").create_dataset("start_time", data=numpy.string_("2015")) + h5.create_group("b").create_dataset("start_time", data=numpy.string_("2013")) + h5.create_group("c").create_dataset("start_time", data=numpy.string_("2014")) model.insertH5pyObject(h5) proxy = hdf5.NexusSortFilterProxyModel() @@ -392,7 +400,7 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testName(self): model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") h5.create_group("a") h5.create_group("c") h5.create_group("b") @@ -406,7 +414,7 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testNumber(self): model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") h5.create_group("a1") h5.create_group("a20") h5.create_group("a3") @@ -420,7 +428,7 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testMultiNumber(self): model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") h5.create_group("a1-1") h5.create_group("a20-1") h5.create_group("a3-1") @@ -436,7 +444,7 @@ class TestNexusSortFilterProxyModel(TestCaseQt): def testUnconsistantTypes(self): model = hdf5.Hdf5TreeModel() - h5 = _mock.File("/foo/bar/1.mock") + h5 = commonh5.File("/foo/bar/1.mock", "w") h5.create_group("aaa100") h5.create_group("100aaa") model.insertH5pyObject(h5) @@ -448,11 +456,235 @@ class TestNexusSortFilterProxyModel(TestCaseQt): self.assertListEqual(names, ["100aaa", "aaa100"]) -class TestHdf5(TestCaseQt): +class TestH5Node(TestCaseQt): + + @classmethod + def setUpClass(cls): + super(TestH5Node, cls).setUpClass() + if h5py is None: + raise unittest.SkipTest("h5py is not available") + + cls.tmpDirectory = tempfile.mkdtemp() + cls.h5Filename = cls.createResource(cls.tmpDirectory) + cls.h5File = h5py.File(cls.h5Filename, mode="r") + cls.model = cls.createModel(cls.h5File) + + @classmethod + def createResource(cls, directory): + filename = os.path.join(directory, "base.h5") + externalFilename = os.path.join(directory, "base__external.h5") + + externalh5 = h5py.File(externalFilename, mode="w") + externalh5["target/dataset"] = 50 + externalh5["target/link"] = h5py.SoftLink("/target/dataset") + externalh5.close() + + h5 = h5py.File(filename, mode="w") + h5["group/dataset"] = 50 + h5["link/soft_link"] = h5py.SoftLink("/group/dataset") + h5["link/soft_link_to_group"] = h5py.SoftLink("/group") + h5["link/soft_link_to_link"] = h5py.SoftLink("/link/soft_link") + h5["link/soft_link_to_file"] = h5py.SoftLink("/") + h5["link/external_link"] = h5py.ExternalLink(externalFilename, "/target/dataset") + h5["link/external_link_to_link"] = h5py.ExternalLink(externalFilename, "/target/link") + h5["broken_link/external_broken_file"] = h5py.ExternalLink(externalFilename + "_not_exists", "/target/link") + h5["broken_link/external_broken_link"] = h5py.ExternalLink(externalFilename, "/target/not_exists") + h5["broken_link/soft_broken_link"] = h5py.SoftLink("/group/not_exists") + h5["broken_link/soft_link_to_broken_link"] = h5py.SoftLink("/group/not_exists") + h5.close() + + return filename + + @classmethod + def createModel(cls, h5pyFile): + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(h5pyFile) + return model + + @classmethod + def tearDownClass(cls): + cls.model = None + cls.h5File.close() + shutil.rmtree(cls.tmpDirectory) + super(TestH5Node, cls).tearDownClass() + + def getIndexFromPath(self, model, path): + """ + :param qt.QAbstractItemModel: model + """ + index = qt.QModelIndex() + for name in path: + for row in range(model.rowCount(index)): + i = model.index(row, 0, index) + label = model.data(i) + if label == name: + index = i + break + else: + raise RuntimeError("Path not found") + return index + + def getH5NodeFromPath(self, model, path): + index = self.getIndexFromPath(model, path) + item = model.data(index, hdf5.Hdf5TreeModel.H5PY_ITEM_ROLE) + h5node = hdf5.H5Node(item) + return h5node + + def testFile(self): + path = ["base.h5"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "") + self.assertEqual(h5node.physical_name, "/") + self.assertEqual(h5node.local_basename, "") + self.assertEqual(h5node.local_name, "/") + + def testGroup(self): + path = ["base.h5", "group"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "group") + self.assertEqual(h5node.physical_name, "/group") + self.assertEqual(h5node.local_basename, "group") + self.assertEqual(h5node.local_name, "/group") + + def testDataset(self): + path = ["base.h5", "group", "dataset"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/group/dataset") + self.assertEqual(h5node.local_basename, "dataset") + self.assertEqual(h5node.local_name, "/group/dataset") + + def testSoftLink(self): + path = ["base.h5", "link", "soft_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/group/dataset") + self.assertEqual(h5node.local_basename, "soft_link") + self.assertEqual(h5node.local_name, "/link/soft_link") + + def testSoftLinkToLink(self): + path = ["base.h5", "link", "soft_link_to_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/group/dataset") + self.assertEqual(h5node.local_basename, "soft_link_to_link") + self.assertEqual(h5node.local_name, "/link/soft_link_to_link") + + def testExternalLink(self): + path = ["base.h5", "link", "external_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertNotEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.local_filename) + self.assertIn("base__external.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/target/dataset") + self.assertEqual(h5node.local_basename, "external_link") + self.assertEqual(h5node.local_name, "/link/external_link") + + def testExternalLinkToLink(self): + path = ["base.h5", "link", "external_link_to_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertNotEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.local_filename) + self.assertIn("base__external.h5", h5node.physical_filename) + + self.assertNotEqual(h5node.physical_filename, h5node.local_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/target/dataset") + self.assertEqual(h5node.local_basename, "external_link_to_link") + self.assertEqual(h5node.local_name, "/link/external_link_to_link") + + def testExternalBrokenFile(self): + path = ["base.h5", "broken_link", "external_broken_file"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertNotEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.local_filename) + self.assertIn("not_exists", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "link") + self.assertEqual(h5node.physical_name, "/target/link") + self.assertEqual(h5node.local_basename, "external_broken_file") + self.assertEqual(h5node.local_name, "/broken_link/external_broken_file") + + def testExternalBrokenLink(self): + path = ["base.h5", "broken_link", "external_broken_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertNotEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.local_filename) + self.assertIn("__external", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "not_exists") + self.assertEqual(h5node.physical_name, "/target/not_exists") + self.assertEqual(h5node.local_basename, "external_broken_link") + self.assertEqual(h5node.local_name, "/broken_link/external_broken_link") + + def testSoftBrokenLink(self): + path = ["base.h5", "broken_link", "soft_broken_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "not_exists") + self.assertEqual(h5node.physical_name, "/group/not_exists") + self.assertEqual(h5node.local_basename, "soft_broken_link") + self.assertEqual(h5node.local_name, "/broken_link/soft_broken_link") + + def testSoftLinkToBrokenLink(self): + path = ["base.h5", "broken_link", "soft_link_to_broken_link"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "not_exists") + self.assertEqual(h5node.physical_name, "/group/not_exists") + self.assertEqual(h5node.local_basename, "soft_link_to_broken_link") + self.assertEqual(h5node.local_name, "/broken_link/soft_link_to_broken_link") + + def testDatasetFromSoftLinkToGroup(self): + path = ["base.h5", "link", "soft_link_to_group", "dataset"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/group/dataset") + self.assertEqual(h5node.local_basename, "dataset") + self.assertEqual(h5node.local_name, "/link/soft_link_to_group/dataset") + + def testDatasetFromSoftLinkToFile(self): + path = ["base.h5", "link", "soft_link_to_file", "link", "soft_link_to_group", "dataset"] + h5node = self.getH5NodeFromPath(self.model, path) + + self.assertEqual(h5node.physical_filename, h5node.local_filename) + self.assertIn("base.h5", h5node.physical_filename) + self.assertEqual(h5node.physical_basename, "dataset") + self.assertEqual(h5node.physical_name, "/group/dataset") + self.assertEqual(h5node.local_basename, "dataset") + self.assertEqual(h5node.local_name, "/link/soft_link_to_file/link/soft_link_to_group/dataset") + + +class TestHdf5TreeView(TestCaseQt): """Test to check that icons module.""" def setUp(self): - super(TestHdf5, self).setUp() + super(TestHdf5TreeView, self).setUp() if h5py is None: self.skipTest("h5py is not available") @@ -464,15 +696,147 @@ class TestHdf5(TestCaseQt): view = hdf5.Hdf5TreeView() view._createContextMenu(qt.QPoint(0, 0)) + def testSelection_Simple(self): + tree = commonh5.File("/foo/bar/1.mock", "w") + item = tree.create_group("a/b/c/d") + item.create_group("e").create_group("f") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(tree) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(item) + + selected = list(view.selectedH5Nodes())[0] + self.assertIs(item, selected.h5py_object) + + def testSelection_NotFound(self): + tree2 = commonh5.File("/foo/bar/2.mock", "w") + tree = commonh5.File("/foo/bar/1.mock", "w") + item = tree.create_group("a/b/c/d") + item.create_group("e").create_group("f") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(tree) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(tree2) + + selection = list(view.selectedH5Nodes()) + self.assertEqual(len(selection), 0) + + def testSelection_ManyGroupFromSameFile(self): + tree = commonh5.File("/foo/bar/1.mock", "w") + group1 = tree.create_group("a1") + group2 = tree.create_group("a2") + group3 = tree.create_group("a3") + group1.create_group("b/c/d") + item = group2.create_group("b/c/d") + group3.create_group("b/c/d") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(group1) + model.insertH5pyObject(group2) + model.insertH5pyObject(group3) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(item) + + selected = list(view.selectedH5Nodes())[0] + self.assertIs(item, selected.h5py_object) + + def testSelection_RootFromSubTree(self): + tree = commonh5.File("/foo/bar/1.mock", "w") + group = tree.create_group("a1") + group.create_group("b/c/d") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(group) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(group) + + selected = list(view.selectedH5Nodes())[0] + self.assertIs(group, selected.h5py_object) + + def testSelection_FileFromSubTree(self): + tree = commonh5.File("/foo/bar/1.mock", "w") + group = tree.create_group("a1") + group.create_group("b").create_group("b").create_group("d") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(group) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(tree) + + selection = list(view.selectedH5Nodes()) + self.assertEquals(len(selection), 0) + + def testSelection_Tree(self): + tree1 = commonh5.File("/foo/bar/1.mock", "w") + tree2 = commonh5.File("/foo/bar/2.mock", "w") + tree3 = commonh5.File("/foo/bar/3.mock", "w") + tree1.create_group("a/b/c") + tree2.create_group("a/b/c") + tree3.create_group("a/b/c") + item = tree2 + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(tree1) + model.insertH5pyObject(tree2) + model.insertH5pyObject(tree3) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(item) + + selected = list(view.selectedH5Nodes())[0] + self.assertIs(item, selected.h5py_object) + + def testSelection_RecurssiveLink(self): + """ + Recurssive link selection + + This example is not really working as expected cause commonh5 do not + support recurssive links. + But item.name == "/a/b" and the result is found. + """ + tree = commonh5.File("/foo/bar/1.mock", "w") + group = tree.create_group("a") + group.add_node(commonh5.SoftLink("b", "/")) + + item = tree["/a/b/a/b/a/b/a/b/a/b/a/b/a/b/a/b"] + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(tree) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(item) + + selected = list(view.selectedH5Nodes())[0] + self.assertEqual(item.name, selected.h5py_object.name) + + def testSelection_SelectNone(self): + tree = commonh5.File("/foo/bar/1.mock", "w") + + model = hdf5.Hdf5TreeModel() + model.insertH5pyObject(tree) + view = hdf5.Hdf5TreeView() + view.setModel(model) + view.setSelectedH5Node(tree) + view.setSelectedH5Node(None) + + selection = list(view.selectedH5Nodes()) + self.assertEqual(len(selection), 0) + def suite(): test_suite = unittest.TestSuite() - test_suite.addTest( - unittest.defaultTestLoader.loadTestsFromTestCase(TestHdf5TreeModel)) - test_suite.addTest( - unittest.defaultTestLoader.loadTestsFromTestCase(TestNexusSortFilterProxyModel)) - test_suite.addTest( - unittest.defaultTestLoader.loadTestsFromTestCase(TestHdf5)) + loadTests = unittest.defaultTestLoader.loadTestsFromTestCase + test_suite.addTest(loadTests(TestHdf5TreeModel)) + test_suite.addTest(loadTests(TestNexusSortFilterProxyModel)) + test_suite.addTest(loadTests(TestHdf5TreeView)) + test_suite.addTest(loadTests(TestH5Node)) return test_suite -- cgit v1.2.3