On 10/31/2014 10:31 AM, mulhern wrote:
Make everything that should be a Size a Size as soon as it is
created,
for clarity, consistency, correctness.
* Clarity --- it's a way for the programmer to state, yes, I believe this is
a Size and I'm pretty confident about its units.
* Consistency --- a lot of methods say they return a Size, but many return a
Size or an int, depending on the path taken through the method. Better to
make these methods actually return a Size always.
* Correctness --- type correctness and logical correctness. The more we
ensure that we have the right type, the less likely we are to get an
AttributeError invoking convertTo() or humanReadable() on an int or a
Decimal. When we use Size we are required to specify the units, at least
implicitly, so we can better avoid intepreting a bare number as, for example,
1/1024th of its intended value.
Other changes in this patch:
* For the first argument of sum(), use a generator, not a list.
* Use // for division when a whole number is required (instead of casting to
an int after the division).
This is changing at least one documented int to a Decimal -- probably
more. Have you verified that pyparted is content with Decimal for
sectors and lengths? Any autopart installation using anaconda in a vm
should be sufficient to establish this.
This patch can not be guaranteed to be complete. These instance of values
that should be Sizes() were found by grepping and by instrumenting Size
to raise an error if it detected a computation with an incorrect type.
There are probably some more lurking.
Note: Currently blivet only has two types of units to compute with,
numbers (which could represent anything), and Sizes() which represent
numbers of bytes. This patch turns numbers into Sizes as much as possible.
At the present time, Size is implemented as a subclass of decimal.Decimal.
It overloads a few of the operations of Decimal, typically returning a Size
result. Sometimes this is the correct thing to do, and sometimes not.
For example, a number times a Size evaluates to a Size and a Size divided
by a number is a Size, which are both correct results with correct units.
It depends on the order of the operands:
>> 5 * Size("1 MiB")
Decimal('5242880')
>> Size("1 MiB") * 5
Size('5 MiB')
However, it is wrong for a Size divided by a Size to evaluate to a Size;
as a ratio of two Sizes, the result should be a plain number.
It is wrong for the product of two Sizes to yield a Size, and almost certainly
a sign that there is a mistake, as most of our computations should not
result in products of Sizes. A Size + a plain number is a Size, which is
the typical way to let in errors where a plain number that represents MiBs
is added to a Size() yielding an incorrect Size result.
The issues above seem fairly easy to remedy, aside from preventing
someone adding a non-size representing something other than bytes to a
Size. I can certainly live with the latter problem.
Eventually this problem should be fixed. In the meantime, however, the changes
I have made in this patch are intended to be compatible with a corrected
implementation of Size. The most sigificant instance is that sum() is
given a start value of Size(0), in case the list being summed over is empty.
The alternative, to convert the result of the sum operation to a Size,
is incompatible with a correct version of Size which would consider adding
a Size to a plain number to be an error.
Overall I think this is a good change.
A couple more comments inline, below...
Signed-off-by: mulhern <amulhern(a)redhat.com>
---
blivet/__init__.py | 2 +-
blivet/deviceaction.py | 3 ++-
blivet/devicefactory.py | 12 ++++++------
blivet/devicelibs/lvm.py | 6 +++---
blivet/devicelibs/mdraid.py | 3 ++-
blivet/devicelibs/raid.py | 13 +++++++------
blivet/devices/btrfs.py | 6 +++---
blivet/devices/disk.py | 3 ++-
blivet/devices/lvm.py | 14 +++++---------
blivet/devices/md.py | 4 ++--
blivet/devices/nodev.py | 3 ++-
blivet/devices/partition.py | 12 ++++++------
blivet/devices/storage.py | 4 ++--
blivet/formats/disklabel.py | 7 +++----
blivet/formats/fs.py | 16 +++++++---------
blivet/partitioning.py | 12 ++++++------
tests/devicelibs_test/raid_test.py | 24 ++++++++++++------------
tests/partitioning_test.py | 4 ++--
tests/size_test.py | 4 ++--
19 files changed, 75 insertions(+), 77 deletions(-)
diff --git a/blivet/__init__.py b/blivet/__init__.py
index ab44eff..cbc3f60 100644
--- a/blivet/__init__.py
+++ b/blivet/__init__.py
@@ -1537,7 +1537,7 @@ class Blivet(object):
def fileSystemFreeSpace(self):
""" Combined free space in / and /usr as :class:`~.size.Size`.
"""
mountpoints = ["/", "/usr"]
- free = 0
+ free = Size(0)
btrfs_volumes = []
for mountpoint in mountpoints:
device = self.mountpoints.get(mountpoint)
diff --git a/blivet/deviceaction.py b/blivet/deviceaction.py
index 07d2493..0f7f2b0 100644
--- a/blivet/deviceaction.py
+++ b/blivet/deviceaction.py
@@ -33,6 +33,7 @@ from parted import partitionFlag, PARTITION_LBA
from .i18n import _, N_
from .callbacks import CreateFormatPreData, CreateFormatPostData
from .callbacks import ResizeFormatPreData, ResizeFormatPostData
+from .size import Size
import logging
log = logging.getLogger("blivet")
@@ -435,7 +436,7 @@ class ActionResizeDevice(DeviceAction):
self.dir = RESIZE_GROW
else:
self.dir = RESIZE_SHRINK
- if device.targetSize > 0:
+ if device.targetSize > Size(0):
self.origsize = device.targetSize
else:
self.origsize = device.size
diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py
index 8b0d163..c383b4d 100644
--- a/blivet/devicefactory.py
+++ b/blivet/devicefactory.py
@@ -549,7 +549,7 @@ class DeviceFactory(object):
#
def _create_device(self):
""" Create the factory device. """
- if self.size == 0:
+ if self.size == Size(0):
# A factory with a size of zero means you're adjusting a container
# after removing a device from it.
return
@@ -573,7 +573,7 @@ class DeviceFactory(object):
# this gets us a size value that takes into account the actual size of
# the container
size = self._get_device_size()
- if size <= 0:
+ if size <= Size(0):
raise DeviceFactoryError("not enough free space for new device")
parents = self._get_parent_devices()
@@ -1511,11 +1511,11 @@ class LVMThinPFactory(LVMFactory):
def _create_pool(self):
""" Create a pool large enough to contain the new device.
"""
- if self.size == 0:
+ if self.size == Size(0):
return
size = self._get_pool_size()
- if size == 0:
+ if size == Size(0):
raise DeviceFactoryError("not enough free space for thin pool")
self.pool = self._get_new_pool(size=size, parents=[self.container])
@@ -1632,11 +1632,11 @@ class BTRFSFactory(DeviceFactory):
if self.container_size == SIZE_POLICY_AUTO:
# automatic
if self.container and not self.device:
- if self.size != 0:
+ if self.size != Size(0):
# For new subvols the size is in addition to the volume's
size.
size += self.container.size
else:
- size += sum(s.req_size for s in self.container.subvolumes)
+ size += sum((s.req_size for s in self.container.subvolumes),
Size(0))
size += self._get_device_space()
elif self.container_size == SIZE_POLICY_MAX:
diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index 44ac34c..cf21902 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -164,8 +164,8 @@ def get_pv_space(size, disks, pesize=LVM_PE_SIZE):
# TODO: handle striped and mirrored
# this is adding one extent for the lv's metadata
# pylint: disable=unused-argument
- if size == 0:
- return size
+ if size == Size(0):
+ return Size(0)
space = clampSize(size, pesize, roundup=True) + pesize
return space
@@ -214,7 +214,7 @@ def is_valid_thin_pool_chunk_size(size, discard=False):
if discard:
return (math.log(size, 2) % 1.0 == 0)
else:
- return (size % LVM_THINP_MIN_CHUNK_SIZE == 0)
+ return (size % LVM_THINP_MIN_CHUNK_SIZE == Size(0))
def strip_lvm_warnings(buf):
""" Strip out lvm warning lines
diff --git a/blivet/devicelibs/mdraid.py b/blivet/devicelibs/mdraid.py
index 7d031e2..11e06d7 100644
--- a/blivet/devicelibs/mdraid.py
+++ b/blivet/devicelibs/mdraid.py
@@ -70,8 +70,9 @@ def get_raid_superblock_size(size, version=None):
# MDADM: operations, but limit this to 128Meg (0.1% of 10Gig)
# MDADM: which is plenty for efficient reshapes
# NOTE: In the mdadm code this is in 512b sectors. Converted to use MiB
+ MIN_HEADROOM = Size("1 MiB")
headroom = int(Size("128 MiB"))
- while headroom << 10 > size and headroom > Size("1 MiB"):
+ while Size(headroom << 10) > size and Size(headroom) >
MIN_HEADROOM:
headroom >>= 1
headroom = Size(headroom)
diff --git a/blivet/devicelibs/raid.py b/blivet/devicelibs/raid.py
index b3f7c49..0f0f1b4 100644
--- a/blivet/devicelibs/raid.py
+++ b/blivet/devicelibs/raid.py
@@ -26,6 +26,7 @@ import abc
from six import add_metaclass
from ..errors import RaidError
+from ..size import Size
def div_up(a,b):
"""Rounds up integer division. For example, div_up(3, 2) is 2.
@@ -188,7 +189,7 @@ class RAIDn(RAIDLevel):
"""
if member_count < self.min_members:
raise RaidError("%s requires at least %d disks" % (self.name,
self.min_members))
- if smallest_member_size < 0:
+ if smallest_member_size < Size(0):
raise RaidError("size is a negative number")
return self._get_net_array_size(member_count, smallest_member_size)
@@ -268,12 +269,12 @@ class RAIDn(RAIDLevel):
under construction.
"""
if not member_sizes:
- return 0
+ return Size(0)
if num_members is None:
num_members = len(member_sizes)
- if chunk_size is None or chunk_size == 0:
+ if chunk_size is None or chunk_size == Size(0):
raise RaidError("chunk_size parameter value %s is not
acceptable")
if superblock_size_func is None:
@@ -588,7 +589,7 @@ class Container(RAIDLevel):
raise RaidError("get_recommended_stride is not defined for level
container")
def get_size(self, member_sizes, num_members=None, chunk_size=None,
superblock_size_func=None):
# pylint: disable=unused-argument
- return sum(member_sizes)
+ return sum(member_sizes, Size(0))
Container = Container()
ALL_LEVELS.addRaidLevel(Container)
@@ -623,12 +624,12 @@ class ErsatzRAID(RAIDLevel):
def get_size(self, member_sizes, num_members=None, chunk_size=None,
superblock_size_func=None):
# pylint: disable=unused-argument
if not member_sizes:
- return 0
+ return Size(0)
if superblock_size_func is None:
raise RaidError("superblock_size_func value of None is not
acceptable")
- total_space = sum(member_sizes)
+ total_space = sum(member_sizes, Size(0))
superblock_size = superblock_size_func(total_space)
return total_space - len(member_sizes) * superblock_size
diff --git a/blivet/devices/btrfs.py b/blivet/devices/btrfs.py
index e2931e3..b405a1e 100644
--- a/blivet/devices/btrfs.py
+++ b/blivet/devices/btrfs.py
@@ -31,6 +31,7 @@ from ..flags import flags
from ..storage_log import log_method_call
from .. import udev
from ..formats import getFormat, DeviceFormat
+from ..size import Size
import logging
log = logging.getLogger("blivet")
@@ -73,8 +74,7 @@ class BTRFSDevice(StorageDevice):
self.setupParents(orig=True)
def _getSize(self):
- size = sum([d.size for d in self.parents])
- return size
+ return sum((d.size for d in self.parents), Size(0))
def _setSize(self, newsize):
raise RuntimeError("cannot directly set size of btrfs volume")
@@ -276,7 +276,7 @@ class BTRFSVolumeDevice(BTRFSDevice, ContainerDevice, RaidDevice):
self.format.mountopts = self.parents[0].format.mountopts
def _getSize(self):
- size = sum([d.size for d in self.parents])
+ size = sum((d.size for d in self.parents), Size(0))
if self.dataLevel in (raid.RAID1, raid.RAID10):
size /= len(self.parents)
diff --git a/blivet/devices/disk.py b/blivet/devices/disk.py
index 3874714..f14638d 100644
--- a/blivet/devices/disk.py
+++ b/blivet/devices/disk.py
@@ -27,6 +27,7 @@ from .. import util
from ..flags import flags
from ..storage_log import log_method_call
from .. import udev
+from ..size import Size
from ..fcoe import fcoe
@@ -103,7 +104,7 @@ class DiskDevice(StorageDevice):
# Some drivers (cpqarray <blegh>) make block device nodes for
# controllers with no disks attached and then report a 0 size,
# treat this as no media present
- return self.partedDevice.getLength(unit="B") != 0
+ return Size(self.partedDevice.getLength(unit="B")) != Size(0)
@property
def description(self):
diff --git a/blivet/devices/lvm.py b/blivet/devices/lvm.py
index 1f00dae..3dd77de 100644
--- a/blivet/devices/lvm.py
+++ b/blivet/devices/lvm.py
@@ -315,7 +315,7 @@ class LVMVolumeGroupDevice(ContainerDevice):
reserved = Size(0)
if self.reserved_percent > 0:
reserved = self.reserved_percent * Decimal('0.01') * self.size
- elif self.reserved_space > 0:
+ elif self.reserved_space > Size(0):
reserved = self.reserved_space
return self.align(reserved, roundup=True)
@@ -326,11 +326,7 @@ class LVMVolumeGroupDevice(ContainerDevice):
# TODO: just ask lvm if isModified returns False
# sum up the sizes of the PVs and align to pesize
- size = 0
- for pv in self.pvs:
- size += max(0, self.align(pv.size - pv.format.peStart))
-
- return size
+ return sum((max(Size(0), self.align(pv.size - pv.format.peStart)) for pv in
self.pvs), Size(0))
@property
def extents(self):
@@ -352,7 +348,7 @@ class LVMVolumeGroupDevice(ContainerDevice):
# total the sizes of any LVs
log.debug("%s size is %s", self.name, self.size)
- used = sum(lv.vgSpaceUsed for lv in self.lvs)
+ used = sum((lv.vgSpaceUsed for lv in self.lvs), Size(0))
if not self.exists and raid_disks:
# (only) we allocate (5 * num_disks) extra extents for LV metadata
# on RAID (see the devicefactory.LVMFactory._get_total_space method)
@@ -1058,7 +1054,7 @@ class LVMThinPoolDevice(LVMLogicalVolumeDevice):
@property
def usedSpace(self):
- return sum(l.poolSpaceUsed for l in self.lvs)
+ return sum((l.poolSpaceUsed for l in self.lvs), Size(0))
@property
def freeSpace(self):
@@ -1118,7 +1114,7 @@ class LVMThinLogicalVolumeDevice(LVMLogicalVolumeDevice):
@property
def vgSpaceUsed(self):
- return 0 # the pool's size is already accounted for in the vg
+ return Size(0) # the pool's size is already accounted for in the vg
def _setSize(self, size):
if not isinstance(size, Size):
diff --git a/blivet/devices/md.py b/blivet/devices/md.py
index aabd628..dcd0c54 100644
--- a/blivet/devices/md.py
+++ b/blivet/devices/md.py
@@ -182,7 +182,7 @@ class MDRaidArrayDevice(ContainerDevice, RaidDevice):
If the array has no redundancy, a bitmap is just pointless.
"""
try:
- return self.level.has_redundancy() and self.size >= 1000 and
self.format.type != "swap"
+ return self.level.has_redundancy() and self.size >= Size(1000) and
self.format.type != "swap"
except errors.RaidError:
# If has_redundancy() raises an exception then this device has
# a level for which the redundancy question is meaningless. In
@@ -220,7 +220,7 @@ class MDRaidArrayDevice(ContainerDevice, RaidDevice):
self.getSuperBlockSize)
except (errors.MDRaidError, errors.RaidError) as e:
log.info("could not calculate size of device %s for raid level %s:
%s", self.name, self.level, e)
- size = 0
+ size = Size(0)
log.debug("non-existent RAID %s size == %s", self.level, size)
else:
size = Size(self.partedDevice.getLength(unit="B"))
diff --git a/blivet/devices/nodev.py b/blivet/devices/nodev.py
index a66636c..618332d 100644
--- a/blivet/devices/nodev.py
+++ b/blivet/devices/nodev.py
@@ -24,6 +24,7 @@ from ..storage_log import log_method_call
import logging
log = logging.getLogger("blivet")
+from ..size import Size
from .storage import StorageDevice
class NoDevice(StorageDevice):
@@ -91,7 +92,7 @@ class TmpFSDevice(NoDevice):
elif self.format:
return self.format.size
else:
- return 0
+ return Size(0)
@property
def fstabSpec(self):
diff --git a/blivet/devices/partition.py b/blivet/devices/partition.py
index 6ad107a..1868678 100644
--- a/blivet/devices/partition.py
+++ b/blivet/devices/partition.py
@@ -133,7 +133,7 @@ class PartitionDevice(StorageDevice):
self._partType = None
self._partedPartition = None
self._origPath = None
- self._currentSize = 0
+ self._currentSize = Size(0)
# FIXME: Validate size, but only if this is a new partition.
# For existing partitions we will get the size from
@@ -162,7 +162,7 @@ class PartitionDevice(StorageDevice):
# for new partitions.
if not self._size:
if start is not None and end is not None:
- self._size = 0
+ self._size = Size(0)
else:
# default size for new partition requests
self._size = self.defaultSize
@@ -506,11 +506,11 @@ class PartitionDevice(StorageDevice):
start = self.partedPartition.geometry.start
part_len = self.partedPartition.geometry.end - start
- bs = self.partedPartition.geometry.device.sectorSize
+ bs = Size(self.partedPartition.geometry.device.sectorSize)
device = self.partedPartition.geometry.device.path
# Erase 1MiB or to end of partition
- count = int(Size("1 MiB") / bs)
+ count = Size("1 MiB") // bs
count = min(count, part_len)
cmd = ["dd", "if=/dev/zero", "of=%s" % device,
"bs=%s" % bs,
@@ -577,7 +577,7 @@ class PartitionDevice(StorageDevice):
# compute new size for partition
currentGeom = partition.geometry
currentDev = currentGeom.device
- newLen = int(self.targetSize) / currentDev.sectorSize
+ newLen = self.targetSize // Size(currentDev.sectorSize)
newGeometry = parted.Geometry(device=currentDev,
start=currentGeom.start,
length=newLen)
@@ -738,7 +738,7 @@ class PartitionDevice(StorageDevice):
if self.exists:
return self._currentSize
else:
- return 0
+ return Size(0)
@property
def resizable(self):
diff --git a/blivet/devices/storage.py b/blivet/devices/storage.py
index e1ee390..f6542c2 100644
--- a/blivet/devices/storage.py
+++ b/blivet/devices/storage.py
@@ -539,7 +539,7 @@ class StorageDevice(Device):
def _getSize(self):
""" Get the device's size, accounting for pending changes.
"""
if self.exists and not self.mediaPresent:
- return 0
+ return Size(0)
if self.exists and self.partedDevice:
self._size = self.currentSize
@@ -572,7 +572,7 @@ class StorageDevice(Device):
If the device does not exist, then the actual size is 0.
"""
- size = 0
+ size = Size(0)
if self.exists and self.partedDevice:
size = Size(self.partedDevice.getLength(unit="B"))
elif self.exists:
diff --git a/blivet/formats/disklabel.py b/blivet/formats/disklabel.py
index d4d7ae7..afb8679 100644
--- a/blivet/formats/disklabel.py
+++ b/blivet/formats/disklabel.py
@@ -204,7 +204,7 @@ class DiskLabel(DeviceFormat):
@property
def sectorSize(self):
try:
- return self.partedDevice.sectorSize
+ return Size(self.partedDevice.sectorSize)
except AttributeError:
log_exception_info()
return None
@@ -221,7 +221,7 @@ class DiskLabel(DeviceFormat):
size = Size(self.partedDevice.getLength(unit="B"))
except Exception: # pylint: disable=broad-except
log_exception_info()
- size = 0
+ size = Size(0)
return size
@@ -395,8 +395,7 @@ class DiskLabel(DeviceFormat):
@property
def free(self):
- return Size(sum(f.getLength(unit="B")
- for f in self.partedDisk.getFreeSpacePartitions()))
+ return sum((Size(f.getLength(unit="B")) for f in
self.partedDisk.getFreeSpacePartitions()), Size(0))
@property
def magicPartitionNumber(self):
diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py
index 1bd3b93..a188c18 100644
--- a/blivet/formats/fs.py
+++ b/blivet/formats/fs.py
@@ -310,7 +310,7 @@ class FS(DeviceFormat):
break
if len(values) != len(self._existingSizeFields):
- return 0
+ return Size(0)
size = 1
for value in values:
@@ -332,11 +332,10 @@ class FS(DeviceFormat):
@property
def free(self):
- free = 0
+ free = Size(0)
if self.exists:
- if self.currentSize and self.minSize and \
- self.currentSize != self.minSize:
- free = int(max(0, self.currentSize - self.minSize)) # truncate
+ if self.currentSize is not None and self.minSize is not None:
+ free = max(Size(0), self.currentSize - self.minSize)
return free
@@ -1305,7 +1304,7 @@ class MacEFIFS(HFSPlus):
_name = N_("Linux HFS+ ESP")
_labelfs = fslabeling.HFSPlusLabeling()
_udevTypes = []
- _minSize = 50
+ _minSize = Size("50 MiB")
@property
def supported(self):
@@ -1505,9 +1504,9 @@ class TmpFS(NoDevFS):
# it is Linux-native
_linuxNative = True
# empty tmpfs has zero overhead
- _minInstanceSize = 0
+ _minInstanceSize = Size(0)
# tmpfs really does not occupy any space by itself
- _minSize = 0
+ _minSize = Size(0)
# in a sense, I guess tmpfs is formattable
# in the regard that the format is automatically created
# once mounted
@@ -1591,7 +1590,6 @@ class TmpFS(NoDevFS):
@property
def free(self):
- free_space = 0
if self._mountpoint:
# If self._mountpoint is defined, it means this tmpfs mount
# has been mounted and there is a path we can use as a handle to
diff --git a/blivet/partitioning.py b/blivet/partitioning.py
index 7107fd3..6ddc222 100644
--- a/blivet/partitioning.py
+++ b/blivet/partitioning.py
@@ -666,7 +666,7 @@ def sizeToSectors(size, sectorSize):
:returns: sector count
:rtype: int
"""
- sectors = int(size / sectorSize)
+ sectors = size // sectorSize
return sectors
This now returns a Decimal while the docstring says it returns an int.
def removeNewPartitions(disks, remove, all_partitions):
@@ -1315,12 +1315,12 @@ class LVRequest(Request):
# Round up to nearest pe. For growable requests this will mean that
# first growth is to fill the remainder of any unused extent.
- self.base = int(lv.vg.align(lv.req_size, roundup=True) / lv.vg.peSize)
+ self.base = lv.vg.align(lv.req_size, roundup=True) // lv.vg.peSize
if lv.req_grow:
- limits = [int(l / lv.vg.peSize) for l in
- [lv.vg.align(lv.req_max_size),
- lv.vg.align(lv.format.maxSize)] if l > 0]
+ limits = [l // lv.vg.peSize for l in
+ (lv.vg.align(lv.req_max_size),
+ lv.vg.align(lv.format.maxSize)) if l > Size(0)]
if limits:
max_units = min(limits)
@@ -1821,7 +1821,7 @@ class TotalSizeSet(object):
self.requests = []
- self.allocated = sum([d.req_base_size for d in self.devices])
+ self.allocated = sum((d.req_base_size for d in self.devices), Size(0))
log.debug("set.allocated = %d", self.allocated)
def allocate(self, amount):
diff --git a/tests/devicelibs_test/raid_test.py b/tests/devicelibs_test/raid_test.py
index e7b2f60..ba1a580 100644
--- a/tests/devicelibs_test/raid_test.py
+++ b/tests/devicelibs_test/raid_test.py
@@ -86,13 +86,13 @@ class RaidTestCase(unittest.TestCase):
##
## get_net_array_size
##
- self.assertEqual(raid.RAID0.get_net_array_size(4, 2), 8)
- self.assertEqual(raid.RAID1.get_net_array_size(4, 2), 2)
- self.assertEqual(raid.RAID4.get_net_array_size(4, 2), 6)
- self.assertEqual(raid.RAID5.get_net_array_size(4, 2), 6)
- self.assertEqual(raid.RAID6.get_net_array_size(4, 2), 4)
- self.assertEqual(raid.RAID10.get_net_array_size(4, 2), 4)
- self.assertEqual(raid.RAID10.get_net_array_size(5, 2), 4)
+ self.assertEqual(raid.RAID0.get_net_array_size(4, Size(2)), Size(8))
+ self.assertEqual(raid.RAID1.get_net_array_size(4, Size(2)), Size(2))
+ self.assertEqual(raid.RAID4.get_net_array_size(4, Size(2)), Size(6))
+ self.assertEqual(raid.RAID5.get_net_array_size(4, Size(2)), Size(6))
+ self.assertEqual(raid.RAID6.get_net_array_size(4, Size(2)), Size(4))
+ self.assertEqual(raid.RAID10.get_net_array_size(4, Size(2)), Size(4))
+ self.assertEqual(raid.RAID10.get_net_array_size(5, Size(2)), Size(4))
##
## get_recommended_stride
@@ -115,24 +115,24 @@ class RaidTestCase(unittest.TestCase):
sizes = [Size("32MiB"), Size("128MiB"),
Size("128MiB"), Size("64MiB")]
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x:
Size(0)),
- r.get_net_array_size(4, Size("32MiB")) if isinstance(r,
raid.RAIDn) else sum(sizes))
+ r.get_net_array_size(4, Size("32MiB")) if isinstance(r,
raid.RAIDn) else sum(sizes, Size(0)))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 5, Size("1MiB"), lambda x:
Size(0)),
- r.get_net_array_size(5, Size("32MiB")) if isinstance(r,
raid.RAIDn) else sum(sizes))
+ r.get_net_array_size(5, Size("32MiB")) if isinstance(r,
raid.RAIDn) else sum(sizes, Size(0)))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
self.assertEqual(r.get_size(sizes, 4, Size("1MiB"), lambda x:
Size("32MiB")),
- 0 if isinstance(r, raid.RAIDn) else (sum(sizes) - 4 *
Size("32MiB")))
+ Size(0) if isinstance(r, raid.RAIDn) else (sum(sizes, Size(0)) - 4 *
Size("32MiB")))
for r in (l for l in raid.ALL_LEVELS if l not in (raid.Container, raid.Dup)):
if isinstance(r, raid.RAIDn):
if r not in (raid.RAID1, raid.RAID10):
- self.assertEqual(r.get_size(sizes, 4, Size("2MiB"), lambda
x: Size("31MiB")), 0)
+ self.assertEqual(r.get_size(sizes, 4, Size("2MiB"), lambda
x: Size("31MiB")), Size(0))
else:
self.assertEqual(r.get_size(sizes, 4, Size("2MiB"),
lambda x: Size("31MiB")), r.get_net_array_size(4, Size("1MiB")))
else:
- self.assertEqual(r.get_size(sizes, 4, Size("2MiB"), lambda x:
Size("31MiB")), sum(sizes) - 4 * Size("31MiB"))
+ self.assertEqual(r.get_size(sizes, 4, Size("2MiB"), lambda x:
Size("31MiB")), sum(sizes, Size(0)) - 4 * Size("31MiB"))
##
## names
diff --git a/tests/partitioning_test.py b/tests/partitioning_test.py
index 41ca1a0..87c994f 100644
--- a/tests/partitioning_test.py
+++ b/tests/partitioning_test.py
@@ -161,7 +161,7 @@ class PartitioningTestCase(unittest.TestCase):
sector_size = geom.device.sectorSize
self.assertEqual(alignment.isAligned(free, geom.start), True)
self.assertEqual(alignment.isAligned(free, geom.end + 1), True)
- self.assertEqual(part.geometry.length, Size("10 MiB") /
sector_size)
+ self.assertEqual(Size(part.geometry.length), Size("10 MiB") /
sector_size)
length is an integer. I think you want to cast the second argument to
int instead of making length a size.
disk.format.removePartition(part)
self.assertEqual(len(disk.format.partitions), 0)
@@ -456,7 +456,7 @@ class PartitioningTestCase(unittest.TestCase):
self.assertEqual(chunk.length, vg.extents)
self.assertEqual(chunk.pool, vg.freeExtents)
- base_size = vg.align(sum(lv.size for lv in vg.lvs), roundup=True)
+ base_size = vg.align(sum((lv.size for lv in vg.lvs), Size(0)), roundup=True)
base = base_size / vg.peSize
self.assertEqual(chunk.base, base)
diff --git a/tests/size_test.py b/tests/size_test.py
index ead34d6..d6731cc 100644
--- a/tests/size_test.py
+++ b/tests/size_test.py
@@ -41,7 +41,7 @@ class SizeTestCase(unittest.TestCase):
def testExceptions(self):
zero = Size(0)
- self.assertEqual(zero, 0.0)
+ self.assertEqual(zero, Size(0.0))
s = Size(500)
with self.assertRaises(SizePlacesError):
@@ -53,7 +53,7 @@ class SizeTestCase(unittest.TestCase):
c = numbytes * factor
s = Size(c)
- self.assertEquals(s, c)
+ self.assertEquals(s, Size(c))
if prefix:
u = "%sbytes" % prefix