Hello community,
here is the log from the commit of package python-parted for openSUSE:Factory
checked in at 2018-05-29 16:51:08
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-parted (Old)
and /work/SRC/openSUSE:Factory/.python-parted.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-parted"
Tue May 29 16:51:08 2018 rev:2 rq:611907 version:3.11.1
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-parted/python-parted.changes
2017-04-11 09:45:03.821924259 +0200
+++ /work/SRC/openSUSE:Factory/.python-parted.new/python-parted.changes
2018-05-29 16:51:23.965751029 +0200
@@ -1,0 +2,24 @@
+Thu May 24 15:26:23 UTC 2018 - tchva...@suse.com
+
+- Add patch to tweak features detected in tests (parted changes
+ from suse):
+ * python-parted-featurestest.patch
+- Add patch python-parted-parted-binary.patch to run parted full
+ path as user does not see sbin binaries
+- Add patch no-last-flag-check.patch from debian
+- Add patch python-parted-unittests.patch from ubuntu to fix tests
+
+-------------------------------------------------------------------
+Thu May 24 14:49:05 UTC 2018 - tchva...@suse.com
+
+- Implement singlespec version for python3
+- Refresh patch pyparted-3.10.patch to work with python3
+- Enable testsuite to validate it somehow
+
+-------------------------------------------------------------------
+Thu May 24 12:08:12 UTC 2018 - bwiedem...@suse.com
+
+- Update to 3.11.1
+ * make package build reproducible (boo#1041090)
+
+-------------------------------------------------------------------
Old:
----
pyparted-3.10.7.tar.gz
New:
----
no-last-flag-check.patch
pyparted-3.11.1.tar.gz
python-parted-featurestest.patch
python-parted-parted-binary.patch
python-parted-unittests.patch
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-parted.spec ++++++
--- /var/tmp/diff_new_pack.HDSiG1/_old 2018-05-29 16:51:25.641689363 +0200
+++ /var/tmp/diff_new_pack.HDSiG1/_new 2018-05-29 16:51:25.641689363 +0200
@@ -1,7 +1,7 @@
#
# spec file for package python-parted
#
-# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -16,24 +16,34 @@
#
-Summary: Python module for GNU parted
-License: GPL-2.0+
-Group: Development/Languages/Python
-Name: python-parted
%define srcname pyparted
-Version: 3.10.7
+%{?!python_module:%define python_module() python-%{**} python3-%{**}}
+Name: python-parted
+Version: 3.11.1
Release: 0
-Url: http://fedorahosted.org/pyparted
-
-Source0:
https://pypi.org/packages/source/p/%{srcname}/%{srcname}-%{version}.tar.gz
+Summary: Python module for GNU parted
+License: GPL-2.0-or-later
+Group: Development/Languages/Python
+URL: https://github.com/dcantrell/pyparted/
+Source0:
https://github.com/dcantrell/pyparted/archive/v3.11.1.tar.gz#/%{srcname}-%{version}.tar.gz
# catch exception for unknown 'disk flag', kkae...@suse.de
-Patch: pyparted-3.10.patch
-
-BuildRoot: %{_tmppath}/%{name}-%{version}-build
+Patch0: pyparted-3.10.patch
+# do not check for PED_PARTITION)_LAST_FLAG as it is not part of ABI
+Patch1: no-last-flag-check.patch
+Patch2: python-parted-unittests.patch
+Patch3: python-parted-parted-binary.patch
+Patch4: python-parted-featurestest.patch
+BuildRequires: %{python_module devel}
+BuildRequires: %{python_module six}
+# tests requires
+BuildRequires: e2fsprogs
+BuildRequires: parted
+Requires: parted
BuildRequires: fdupes
BuildRequires: parted-devel
BuildRequires: pkgconfig
-BuildRequires: python-devel >= 2.7
+BuildRequires: python-rpm-macros
+%python_subpackages
%description
Python module for the parted library. It is used for manipulating
@@ -41,20 +51,22 @@
%prep
%setup -q -n %{srcname}-%{version}
-%patch -p1
+%autopatch -p1
%build
-make %{?_smp_mflags}
+%python_build
%install
-make install DESTDIR=%{buildroot}
+%python_install
+%python_expand %fdupes %{buildroot}%{$python_sitearch}
-%fdupes %{buildroot}
+%check
+%python_expand PYTHONPATH=%{buildroot}%{$python_sitearch} $python -m unittest
discover -v
-%files
-%defattr(-,root,root,-)
-%doc AUTHORS COPYING NEWS README TODO
-%{python_sitearch}/_ped.so
+%files %{python_files}
+%license COPYING
+%doc AUTHORS NEWS README TODO
+%{python_sitearch}/_ped*.so
%{python_sitearch}/parted
%{python_sitearch}/%{srcname}-%{version}-*.egg-info
++++++ no-last-flag-check.patch ++++++
Description: Remove *_LAST_FLAG checks
The last flag in an enumeration is not really part of the ABI. Checking it
here means that changes to parted may unexpectedly break pyparted.
Author: Colin Watson <cjwat...@debian.org>
Reviewed-by: Herbert Parentes Fortes Neto <h...@ig.com.br>
Bug-Debian: http://bugs.debian.org/697588
Last-Update: 2014-11-30
--- a/src/pydisk.c
+++ b/src/pydisk.c
@@ -1020,7 +1020,7 @@
return NULL;
}
- if ((flag < PED_DISK_FIRST_FLAG) || (flag > PED_DISK_LAST_FLAG)) {
+ if ((flag < PED_DISK_FIRST_FLAG)) {
PyErr_SetString(PyExc_ValueError, "Invalid flag provided.");
return NULL;
}
@@ -1404,7 +1404,7 @@
return NULL;
}
- if ((flag < PED_PARTITION_FIRST_FLAG) || (flag > PED_PARTITION_LAST_FLAG))
{
+ if ((flag < PED_PARTITION_FIRST_FLAG)) {
PyErr_SetString(PyExc_ValueError, "Invalid flag provided.");
return NULL;
}
++++++ pyparted-3.10.patch ++++++
--- /var/tmp/diff_new_pack.HDSiG1/_old 2018-05-29 16:51:25.665688480 +0200
+++ /var/tmp/diff_new_pack.HDSiG1/_new 2018-05-29 16:51:25.665688480 +0200
@@ -9,4 +9,4 @@
+ try:
+ diskFlag[__flag] = _ped.disk_flag_get_name(__flag)
+ except:
-+ print "Bad disk flag:", __flag
++ print("Bad disk flag: {}".format(__flag))
++++++ pyparted-3.10.7.tar.gz -> pyparted-3.11.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/.gitignore
new/pyparted-3.11.1/.gitignore
--- old/pyparted-3.10.7/.gitignore 1970-01-01 01:00:00.000000000 +0100
+++ new/pyparted-3.11.1/.gitignore 2017-06-26 17:20:05.000000000 +0200
@@ -0,0 +1,10 @@
+*.pyc
+*.swp
+ChangeLog
+MANIFEST
+build
+dist
+pyparted.spec
+.tox
+.coverage
+coverage-report.log
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/HACKING new/pyparted-3.11.1/HACKING
--- old/pyparted-3.10.7/HACKING 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/HACKING 2017-06-26 17:20:05.000000000 +0200
@@ -184,7 +184,7 @@
and commit your changes locally and then generate a set of diffs against
the latest upstream code.
- $ git clone https://github.com/rhinstaller/pyparted.git
+ $ git clone https://github.com/dcantrell/pyparted.git
$ cd pyparted
$ # make your changes to files here
$ git add FILE # repeat this add/commit process for
@@ -203,7 +203,7 @@
The best way to submit patches is to fork the repo on github and send a pull
request with your changes:
- https://github.com/rhinstaller/pyparted
+ https://github.com/dcantrell/pyparted
Attach your patch and explanation and it'll be reviewed. There may be some
back and forth as your patch is reviewed and considered for inclusion.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/Makefile new/pyparted-3.11.1/Makefile
--- old/pyparted-3.10.7/Makefile 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/Makefile 2017-06-26 17:20:05.000000000 +0200
@@ -47,6 +47,7 @@
@env PYTHONPATH=$$(find $$(pwd) -name "*.so" | head -n 1 | xargs
dirname):src/parted:src \
$(COVERAGE) run --branch -m unittest discover -v
$(COVERAGE) report --include="build/lib.*/parted/*" --show-missing
+ $(COVERAGE) report --include="build/lib.*/parted/*" >
coverage-report.log
check: clean
env PYTHON=python3 $(MAKE) ; \
@@ -103,4 +104,7 @@
clean:
-rm -r build
-ci: check test
+ci: check coverage
+
+verrel:
+ @echo $(PACKAGE)-$(VERSION)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/PKG-INFO new/pyparted-3.11.1/PKG-INFO
--- old/pyparted-3.10.7/PKG-INFO 2017-03-13 06:13:15.000000000 +0100
+++ new/pyparted-3.11.1/PKG-INFO 1970-01-01 01:00:00.000000000 +0100
@@ -1,10 +0,0 @@
-Metadata-Version: 1.0
-Name: pyparted
-Version: 3.10.7
-Summary: Python bindings for GNU parted
-Home-page: https://fedorahosted.org/pyparted/
-Author: pyparted Development Team
-Author-email: pyparted-de...@redhat.com
-License: GPLv2+
-Description: UNKNOWN
-Platform: UNKNOWN
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/RELEASE new/pyparted-3.11.1/RELEASE
--- old/pyparted-3.10.7/RELEASE 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/RELEASE 2017-06-26 17:20:05.000000000 +0200
@@ -8,7 +8,9 @@
4) make bumpver
5) git commit -a -m "New version."
6) git clean -d -x -f
-7) make release
+7) make dist
+8) gpg --detach-sign -a dist/$(make verrel).tar.gz
+8) twine upload dist/$(make verrel).tar.gz $(make verrel).tar.gz.asc
If packaging in RPM format, you might find the 'make rpmlog' target useful.
It gives you an RPM spec file formatted changelog block that contains the
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/pyparted-3.10.7/examples/make_one_primary_partition.py
new/pyparted-3.11.1/examples/make_one_primary_partition.py
--- old/pyparted-3.10.7/examples/make_one_primary_partition.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyparted-3.11.1/examples/make_one_primary_partition.py 2017-06-26
17:20:05.000000000 +0200
@@ -0,0 +1,129 @@
+# coding=utf-8
+#
+# Copyright 2015 John Florian <jflor...@doubledog.org>
+#
+# This example script is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version so long as this copyright notice remains intact.
+#
+# This example script is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this example script. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+An example program that creates a single, bootable primary partition on a disk.
+"""
+from glob import glob
+from logging import getLogger
+import logging
+
+import parted
+
+
+__author__ = """John Florian <john.flor...@dart.biz>"""
+__copyright__ = """Copyright 2015 John Florian"""
+
+
+class _ConsoleHandler(logging.StreamHandler):
+ def __init__(self):
+ super().__init__()
+ self.setFormatter(
+ logging.Formatter('{levelname} - {message}', style='{')
+ )
+
+
+class ExampleDevice(object):
+ """
+ A simple model of a block storage device that wraps up some examples of
+ pyparted capabilities.
+ """
+
+ def __init__(self, path):
+ """
+ Initialize the ExampleDevice object.
+ """
+ self.path = path
+ self.logger = getLogger(__name__)
+
+ @property
+ def partition_names(self):
+ """
+ @return: A list of partition device names on the block device.
+ @rtype: str
+ """
+ names = glob('{}[0-9]*'.format(self.path))
+ self.logger.debug('has partitions %s', names)
+ return names
+
+ def partition(self):
+ """
+ Create a partition table on the block device.
+
+ The newly created partition will have the following characteristics:
+ - a primary partition using 100% of the device capacity
+ - optimal alignment given the disk topology information
+ - a MS-DOS disk label for simple BIOS booting on PC-type hardware
+ - marked as bootable
+ """
+ self.logger.info('creating primary partition')
+ device = parted.getDevice(self.path)
+ self.logger.debug('created %s', device)
+ disk = parted.freshDisk(device, 'msdos')
+ self.logger.debug('created %s', disk)
+ geometry = parted.Geometry(device=device, start=1,
+ length=device.getLength() - 1)
+ self.logger.debug('created %s', geometry)
+ filesystem = parted.FileSystem(type='ext3', geometry=geometry)
+ self.logger.debug('created %s', filesystem)
+ partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL,
+ fs=filesystem, geometry=geometry)
+ self.logger.debug('created %s', partition)
+ disk.addPartition(partition=partition,
+ constraint=device.optimalAlignedConstraint)
+ partition.setFlag(parted.PARTITION_BOOT)
+ disk.commit()
+
+ def wipe_dev(self, dev_path):
+ """
+ Wipe a device (partition or otherwise) of meta-data, be it file system,
+ LVM, etc.
+
+ @param dev_path: Device path of the partition to be wiped.
+ @type dev_path: str
+ """
+ self.logger.debug('wiping %s', dev_path)
+ with open(dev_path, 'wb') as p:
+ p.write(bytearray(1024))
+
+ def wipe(self):
+ """
+ Wipe the block device of meta-data, be it file system, LVM, etc.
+
+ This is not intended to be secure, but rather to ensure that
+ auto-discovery tools don't recognize anything here.
+ """
+ self.logger.info('wiping partitions and other meta-data')
+ for partition in self.partition_names:
+ self.wipe_dev(partition)
+ self.wipe_dev(self.path)
+
+
+if __name__ == '__main__':
+ # It should be plenty obvious what needs to be done here. If it's not
+ # obvious to you, please don't run this!!!
+ my_unimportant_test_disk = '/dev/sdX__FIXME'
+
+ # Set up a logger for nice visibility.
+ logger = getLogger(__name__)
+ logger.setLevel(logging.DEBUG)
+ logger.addHandler(_ConsoleHandler())
+
+ # Ok, now for the good stuff, the actual example.
+ guinea_pig = ExampleDevice(my_unimportant_test_disk)
+ guinea_pig.wipe()
+ guinea_pig.partition()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/setup.py new/pyparted-3.11.1/setup.py
--- old/pyparted-3.10.7/setup.py 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/setup.py 2017-06-26 17:20:05.000000000 +0200
@@ -1,5 +1,5 @@
# setup.py script for pyparted
-# Copyright (C) 2011-2013 Red Hat, Inc.
+# Copyright (C) 2011-2017 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@@ -30,8 +30,9 @@
from distutils.errors import LinkError
from distutils.core import setup
from distutils.core import Extension
+from distutils.version import LooseVersion
-pyparted_version = '3.10.7'
+pyparted_version = '3.11.1'
python_version = sys.version_info
need_libparted_version = '2.3'
@@ -50,8 +51,8 @@
return kwargs
def check_mod_version(module, version):
- modversion = subprocess.check_output(["pkg-config", "--modversion",
module])
- if not float(modversion) >= float(version):
+ modversion = subprocess.check_output(["pkg-config", "--modversion",
module]).decode('utf-8').split()[0]
+ if not LooseVersion(modversion) >= LooseVersion(version):
sys.stderr.write("*** Minimum required %s version: %s, found: %s\n" %
(module, version, modversion,))
sys.exit(1)
return
@@ -65,15 +66,15 @@
setup(name='pyparted',
version=pyparted_version,
- author='pyparted Development Team',
- author_email='pyparted-de...@redhat.com',
- url='https://fedorahosted.org/pyparted/',
+ author='David Cantrell',
+ author_email='dcantr...@redhat.com',
+ url='https://github.com/dcantrell/pyparted/',
description='Python bindings for GNU parted',
license='GPLv2+',
packages=['parted'],
package_dir={'parted': 'src/parted'},
ext_modules=[Extension('_ped',
- glob.glob(os.path.join('src', '*.c')),
+ sorted(glob.glob(os.path.join('src', '*.c'))),
define_macros=features,
**pkgconfig('libparted',
include_dirs=['include']))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/_pedmodule.c
new/pyparted-3.11.1/src/_pedmodule.c
--- old/pyparted-3.10.7/src/_pedmodule.c 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/src/_pedmodule.c 2017-06-26 17:20:05.000000000
+0200
@@ -634,15 +634,9 @@
PyModule_AddIntConstant(m, "PARTITION_BIOS_GRUB", PED_PARTITION_BIOS_GRUB);
PyModule_AddIntConstant(m, "PARTITION_DIAG", PED_PARTITION_DIAG);
PyModule_AddIntConstant(m, "PARTITION_LEGACY_BOOT",
PED_PARTITION_LEGACY_BOOT);
-#ifdef PED_PARTITION_MSFT_DATA
PyModule_AddIntConstant(m, "PARTITION_MSFT_DATA", PED_PARTITION_MSFT_DATA);
-#endif
-#ifdef PED_PARTITION_IRST
PyModule_AddIntConstant(m, "PARTITION_IRST", PED_PARTITION_IRST);
-#endif
-#ifdef PED_PARTITION_ESP
PyModule_AddIntConstant(m, "PARTITION_ESP", PED_PARTITION_ESP);
-#endif
PyModule_AddIntConstant(m, "DISK_CYLINDER_ALIGNMENT",
PED_DISK_CYLINDER_ALIGNMENT);
PyModule_AddIntConstant(m, "DISK_GPT_PMBR_BOOT", PED_DISK_GPT_PMBR_BOOT);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/fdisk/fdisk.py
new/pyparted-3.11.1/src/fdisk/fdisk.py
--- old/pyparted-3.10.7/src/fdisk/fdisk.py 1970-01-01 01:00:00.000000000
+0100
+++ new/pyparted-3.11.1/src/fdisk/fdisk.py 2017-06-26 17:20:05.000000000
+0200
@@ -0,0 +1,182 @@
+#
+# fdisk.py
+# Partitioning utility with an fdisk-style interface, but written in
+# Python and using the pyparted Python module.
+#
+# Copyright (C) 2009 Red Hat, Inc.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions of
+# the GNU General Public License v.2, or (at your option) any later version.
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY expressed or implied, including the implied warranties of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+# Public License for more details. You should have received a copy of the
+# GNU General Public License along with this program; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
+# source code or documentation are not subject to the GNU General Public
+# License and may only be used or replicated with the express permission of
+# Red Hat, Inc.
+#
+# Red Hat Author(s): David Cantrell <dcantr...@redhat.com>
+#
+
+import getopt
+import os
+import parted
+import sys
+
+def usage(cmd):
+ sys.stdout.write("Usage: %s [-b SSZ] [-u] DISK Change partition
table\n" % (cmd,))
+ sys.stdout.write(" %s [-l] [-b SSZ] [-u] DISK List partition
table(s)\n" % (cmd,))
+ sys.stdout.write(" %s -s PARTITION Give partition
size(s) in blocks\n\n" % (cmd,))
+ sys.stdout.write("Here DISK is something like /dev/hdb or /dev/sda\n")
+ sys.stdout.write("and PARTITION is something like /dev/hda7\n\n")
+ sys.stdout.write("Options:\n")
+ sys.stdout.write(" -b=SSZ, --sectorsize=SSZ Sector size (in bytes) to
use\n")
+ sys.stdout.write(" -l, --list List partition
table(s)\n")
+ sys.stdout.write(" -u, --showsectors Give Start and End in
sector units\n")
+ sys.stdout.write(" -s, --showblocks Give Start and End in
block units\n")
+ sys.stdout.write(" -V, --version Show fdisk version\n")
+ sys.stdout.write(" -?, --help Display fdisk usage
screen\n")
+
+def displayVersion(cmd):
+ ver = parted.version()
+
+ sys.stdout.write("%s:\n" % (cmd,))
+ sys.stdout.write("pyparted version: %s.%s.%s\n" % (ver["pyparted"][0],
ver["pyparted"][1], ver["pyparted"][2]))
+ sys.stdout.write("libparted version: %s\n" % ver["libparted"])
+
+def listPartitionTable(path, sectorsize, showsectors, showblocks):
+ device = parted.getDevice(path)
+ (cylinders, heads, sectors) = device.biosGeometry
+ sizeInBytes = device.length * device.sectorSize
+ disk = parted.Disk(device)
+
+ partlist = []
+ for partition in disk.partitions:
+ if partition.type == parted.PARTITION_PROTECTED or \
+ partition.type == parted.PARTITION_METADATA or \
+ partition.type == parted.PARTITION_FREESPACE:
+ continue
+
+ partlist.append((partition,
+ partition.path,
+ partition.getFlag(parted.PARTITION_BOOT),
+ partition.geometry.start,
+ partition.geometry.end,
+ partition.geometry.length,
+ partition.type,
+ partition.fileSystem))
+
+ colLength = 0
+ for parts in partlist:
+ path = parts[1]
+ if len(path) > colLength:
+ colLength = len(path)
+
+ sys.stdout.write("Disk %s: %%d %%s, %d bytes\n" % (disk.device.path,
sizeInBytes))
+ sys.stdout.write("%d heads, %d sectors/track, %d cylinders\n" % (heads,
sectors, cylinders,))
+ sys.stdout.write("Units = FIXME\n")
+ sys.stdout.write("Disk identifier: FIXME\n\n")
+
+ sys.stdout.write("%-11s %-4s %-11s %-11s %-12s %-4s %s\n" % ("Device",
"Boot", "Start", "End", "Blocks", "Id", "System",))
+
+ for parts in partlist:
+ (partition, path, bootable, start, end, length, ty, fs) = parts
+
+ if bootable:
+ bootflag = '*'
+ else:
+ bootflag = ''
+
+ sys.stdout.write("%-11s %-4s %-11d %-11d %-12d %-4s" % (path,
bootflag, start, end, length, ty,))
+
+ if fs is None:
+ # no filesystem, check flags
+ if partition.getFlag(parted.PARTITION_SWAP):
+ sys.stdout.write(" Linux swap\n")
+ elif partition.getFlag(parted.PARTITION_RAID):
+ sys.stdout.write(" RAID\n")
+ elif partition.getFlag(parted.PARTITION_LVM):
+ sys.stdout.write(" Linux LVM\n")
+ elif partition.getFlag(parted.PARTITION_HPSERVICE):
+ sys.stdout.write(" HP Service\n")
+ elif partition.getFlag(parted.PARTITION_PALO):
+ sys.stdout.write(" PALO\n")
+ elif partition.getFlag(parted.PARTITION_PREP):
+ sys.stdout.write(" PReP\n")
+ elif partition.getFlag(parted.MSFT_RESERVED):
+ sys.stdout.write(" MSFT Reserved\n")
+ else:
+ sys.stdout.write(" unknown\n")
+ else:
+ sys.stdout.write(" %s\n" % (fs.type,))
+
+#Disk /dev/sda: 250.0 GB, 250059350016 bytes
+#255 heads, 63 sectors/track, 30401 cylinders
+#Units = cylinders of 16065 * 512 = 8225280 bytes
+#Disk identifier: 0x00000000
+#
+# Device Boot Start End Blocks Id System
+#/dev/sda1 1 26 204819+ ee GPT
+#/dev/sda2 26 4203 33554432 af Unknown
+#/dev/sda3 * 4203 4229 204800 83 Linux
+#/dev/sda4 4229 30402 210234515+ 8e Linux LVM
+
+def main(argv):
+ cmd = os.path.basename(sys.argv[0])
+ opts, args = [], []
+ showhelp, showlist, showsectors, showblocks = False, False, False, False
+
+ # These three are unused for now so I'm marking them with an underscore
+ # to make pylint happy.
+ sectorsize, _cylinders, _heads, _sectors = None, None, None, None
+
+ if len(sys.argv) == 1:
+ showhelp = True
+
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], "lb:C:H:S:usV?",
+ ["list", "sectorsize=", "cylinders=",
+ "heads=", "sectors=", "showsectors",
+ "showblocks", "version", "help"])
+ except getopt.GetoptError:
+ showhelp = True
+
+ for o, a in opts:
+ if o in ('-l', '--list'):
+ showlist = True
+ elif o in ('-b', '--sectorsize'):
+ sectorsize = a
+ elif o in ('-C', '--cylinders'):
+ _cylinders = a
+ elif o in ('-H', '--heads'):
+ _heads = a
+ elif o in ('-S', '--sectors'):
+ _sectors = a
+ elif o in ('-u', '--showsectors'):
+ showsectors = True
+ elif o in ('-s', '--showblocks'):
+ showblocks = True
+ elif o in ('-V', '--version'):
+ displayVersion(cmd)
+ sys.exit(0)
+ elif o in ('-?', '--help'):
+ usage(cmd)
+ sys.exit(0)
+ else:
+ sys.stderr.write("Invalid option: %s\n\n" % (o,))
+ showhelp = True
+
+ if showhelp:
+ usage(cmd)
+ sys.exit(1)
+
+ for arg in args:
+ if showlist:
+ listPartitionTable(arg, sectorsize, showsectors, showblocks)
+
+if __name__ == "__main__":
+ main(sys.argv)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/fdisk/localtest
new/pyparted-3.11.1/src/fdisk/localtest
--- old/pyparted-3.10.7/src/fdisk/localtest 1970-01-01 01:00:00.000000000
+0100
+++ new/pyparted-3.11.1/src/fdisk/localtest 2017-06-26 17:20:05.000000000
+0200
@@ -0,0 +1,3 @@
+#!/bin/sh
+export PYTHONPATH=$(pwd)/..:$(pwd)/../.libs
+python fdisk.py $*
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/parted/__init__.py
new/pyparted-3.11.1/src/parted/__init__.py
--- old/pyparted-3.10.7/src/parted/__init__.py 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/src/parted/__init__.py 2017-06-26 17:20:05.000000000
+0200
@@ -25,6 +25,7 @@
from __future__ import division
+import math
import platform
import re
import sys
@@ -129,6 +130,9 @@
if hasattr(_ped, 'PARTITION_ESP'):
# pylint: disable=E0611
from _ped import PARTITION_ESP
+if hasattr(_ped, 'PARTITION_NONFS'):
+ # pylint: disable=E0611
+ from _ped import PARTITION_NONFS
from _ped import DISK_CYLINDER_ALIGNMENT
from _ped import DISK_GPT_PMBR_BOOT
@@ -307,7 +311,7 @@
if unit not in __exponents.keys():
raise SyntaxError("{:} is not a valid SI or IEC byte
unit".format(unit))
else:
- return bytes_ * __exponents[unit] // sector_size
+ return math.ceil(bytes_ * __exponents[unit] / sector_size)
# Valid disk labels per architecture type. The list of label
# names map to keys in the parted.diskType hash table.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/parted/cachedlist.py
new/pyparted-3.11.1/src/parted/cachedlist.py
--- old/pyparted-3.10.7/src/parted/cachedlist.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/parted/cachedlist.py 2017-06-26
17:20:05.000000000 +0200
@@ -82,9 +82,9 @@
self.__rebuildList()
return self._lst.count(value)
- def index(self, value):
+ def index(self, value, *args, **kwargs):
self.__rebuildList()
- return self._lst.index(value)
+ return self._lst.index(value, *args, **kwargs)
def invalidate(self):
"""Indicate that the list is no longer valid, due to some external
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/parted/constraint.py
new/pyparted-3.11.1/src/parted/constraint.py
--- old/pyparted-3.10.7/src/parted/constraint.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/parted/constraint.py 2017-06-26
17:20:05.000000000 +0200
@@ -44,7 +44,7 @@
__init__. If minGeom and maxGeom are supplied, the constraint will
be created to satisfy both. If only one of minGeom or maxGeom are
supplied, the constraint is only guaranteed to solve the given
- paramter. If exactGeom is given, the constraint will only be
+ parameter. If exactGeom is given, the constraint will only be
satisfied by the given geometry. If device is given, any region
on that device will satisfy the constraint.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/parted/device.py
new/pyparted-3.11.1/src/parted/device.py
--- old/pyparted-3.10.7/src/parted/device.py 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/src/parted/device.py 2017-06-26 17:20:05.000000000
+0200
@@ -37,11 +37,11 @@
class Device(object):
"""Device()
- Device represents a phyiscal piece of hardware in the system, e.g. a
+ Device represents a physical piece of hardware in the system, e.g. a
disk. A Device should be considered a low-level and operating system
specific interface to the hardware.
- A number of read-only properties about the Device are available.
+ A number of read-only properties of the Device are available.
For information on the individual methods, see
help(Device.METHODNAME)"""
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/parted/disk.py
new/pyparted-3.11.1/src/parted/disk.py
--- old/pyparted-3.10.7/src/parted/disk.py 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/src/parted/disk.py 2017-06-26 17:20:05.000000000
+0200
@@ -56,15 +56,15 @@
self._partitions = CachedList(lambda : self.__getPartitions())
def _hasSameParts(self, other):
- import itertools
+ import six
if len(self.partitions) != len(other.partitions):
return False
- partIter = itertools.izip(self.partitions, other.partitions)
+ partIter = six.moves.zip(self.partitions, other.partitions)
while True:
try:
- (left, right) = partIter.next()
+ (left, right) = next(partIter)
if left != right:
return False
except StopIteration:
@@ -351,38 +351,6 @@
returned (not the extended partition)."""
return parted.Partition(disk=self,
PedPartition=self.__disk.get_partition_by_sector(sector))
- def getMaxLogicalPartitions(self):
- """Return the maximum number of logical partitions this Disk
- will hold. Returns 0 if there is no extended partition on
- the disk, returns 11 when all else fails."""
- if not self.supportsFeature(parted.DISK_TYPE_EXTENDED):
- return 0
-
- # maximum number of logical partitions per device type
- maxLogicalPartitionCount = {
- "hd": 59,
- "sd": 11,
- "ataraid/": 11,
- "rd/": 3,
- "cciss/": 11,
- "i2o/": 11,
- "iseries/vd": 3,
- "ida/": 11,
- "sx8/": 11,
- "xvd": 11,
- "vd": 11,
- "mmcblk": 5
- }
-
- dev = self.device.path[5:]
- for key in maxLogicalPartitionCount.keys():
- if dev.startswith(key):
- return maxLogicalPartitionCount[key]
-
- # XXX: if we don't know about it, should we pretend it can't have
- # logicals? probably safer to just use something reasonable
- return 11
-
@localeC
def getExtendedPartition(self):
"""Return the extended Partition, if any, on this Disk."""
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/pyconstraint.c
new/pyparted-3.11.1/src/pyconstraint.c
--- old/pyparted-3.10.7/src/pyconstraint.c 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/src/pyconstraint.c 2017-06-26 17:20:05.000000000
+0200
@@ -264,9 +264,9 @@
}
if (!strcmp(member, "min_size")) {
- return PyLong_FromLong(self->min_size);
+ return PyLong_FromLongLong(self->min_size);
} else if (!strcmp(member, "max_size")) {
- return PyLong_FromLong(self->max_size);
+ return PyLong_FromLongLong(self->max_size);
} else {
PyErr_Format(PyExc_AttributeError, "_ped.Constraint object has no
attribute %s", member);
return NULL;
@@ -282,12 +282,12 @@
}
if (!strcmp(member, "min_size")) {
- self->min_size = PyLong_AsLong(value);
+ self->min_size = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
} else if (!strcmp(member, "max_size")) {
- self->max_size = PyLong_AsLong(value);
+ self->max_size = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/pydevice.c
new/pyparted-3.11.1/src/pydevice.c
--- old/pyparted-3.10.7/src/pydevice.c 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/pydevice.c 2017-06-26 17:20:05.000000000 +0200
@@ -266,11 +266,11 @@
} else if (!strcmp(member, "type")) {
return PyLong_FromLong(self->type);
} else if (!strcmp(member, "sector_size")) {
- return PyLong_FromLong(self->sector_size);
+ return PyLong_FromLongLong(self->sector_size);
} else if (!strcmp(member, "phys_sector_size")) {
- return PyLong_FromLong(self->phys_sector_size);
+ return PyLong_FromLongLong(self->phys_sector_size);
} else if (!strcmp(member, "length")) {
- return PyLong_FromLong(self->length);
+ return PyLong_FromLongLong(self->length);
} else if (!strcmp(member, "open_count")) {
return Py_BuildValue("i", self->open_count);
} else if (!strcmp(member, "read_only")) {
@@ -819,7 +819,7 @@
ret = ped_device_check(device, out_buf, start, count);
free(out_buf);
- return PyLong_FromLong(ret);
+ return PyLong_FromLongLong(ret);
}
PyObject *py_ped_device_get_constraint(PyObject *s, PyObject *args) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/pydisk.c
new/pyparted-3.11.1/src/pydisk.c
--- old/pyparted-3.10.7/src/pydisk.c 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/pydisk.c 2017-06-26 17:20:05.000000000 +0200
@@ -928,7 +928,7 @@
if (!disk)
return NULL;
- return PyLong_FromUnsignedLong(ped_disk_max_partition_length(disk));
+ return PyLong_FromUnsignedLongLong(ped_disk_max_partition_length(disk));
}
PyObject *py_ped_disk_max_partition_start_sector(PyObject *s, PyObject *args) {
@@ -938,7 +938,7 @@
if (!disk)
return NULL;
- return PyLong_FromUnsignedLong(ped_disk_max_partition_start_sector(disk));
+ return
PyLong_FromUnsignedLongLong(ped_disk_max_partition_start_sector(disk));
}
PyObject *py_ped_disk_set_flag(PyObject *s, PyObject *args) {
@@ -1217,9 +1217,11 @@
return NULL;
}
- out_fstype = _ped_FileSystemType2PedFileSystemType(in_fstype);
- if (out_fstype == NULL) {
- return NULL;
+ if (in_fstype != NULL) {
+ out_fstype = _ped_FileSystemType2PedFileSystemType(in_fstype);
+ if (out_fstype == NULL) {
+ return NULL;
+ }
}
/* ped_partition_set_system will assert on this. */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/pygeom.c
new/pyparted-3.11.1/src/pygeom.c
--- old/pyparted-3.10.7/src/pygeom.c 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/pygeom.c 2017-06-26 17:20:05.000000000 +0200
@@ -183,11 +183,11 @@
}
if (!strcmp(member, "start")) {
- return PyLong_FromLong(self->ped_geometry->start);
+ return PyLong_FromLongLong(self->ped_geometry->start);
} else if (!strcmp(member, "length")) {
- return PyLong_FromLong(self->ped_geometry->length);
+ return PyLong_FromLongLong(self->ped_geometry->length);
} else if (!strcmp(member, "end")) {
- return PyLong_FromLong(self->ped_geometry->end);
+ return PyLong_FromLongLong(self->ped_geometry->end);
} else {
PyErr_Format(PyExc_AttributeError, "_ped.Geometry object has no
attribute %s", member);
return NULL;
@@ -205,20 +205,20 @@
}
if (!strcmp(member, "start")) {
- val = PyLong_AsLong(value);
+ val = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
ret = ped_geometry_set_start(self->ped_geometry, val);
} else if (!strcmp(member, "length")) {
- val = PyLong_AsLong(value);
+ val = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
ret = ped_geometry_set(self->ped_geometry, self->ped_geometry->start,
val);
} else if (!strcmp(member, "end")) {
- val = PyLong_AsLong(value);
+ val = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
@@ -717,7 +717,7 @@
ped_timer_destroy(out_timer);
free(out_buf);
- return PyLong_FromLong(ret);
+ return PyLong_FromLongLong(ret);
}
PyObject *py_ped_geometry_map(PyObject *s, PyObject *args) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/src/pynatmath.c
new/pyparted-3.11.1/src/pynatmath.c
--- old/pyparted-3.10.7/src/pynatmath.c 2015-08-27 21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/src/pynatmath.c 2017-06-26 17:20:05.000000000 +0200
@@ -126,9 +126,9 @@
}
if (!strcmp(member, "offset")) {
- return PyLong_FromLong(self->offset);
+ return PyLong_FromLongLong(self->offset);
} else if (!strcmp(member, "grain_size")) {
- return PyLong_FromLong(self->grain_size);
+ return PyLong_FromLongLong(self->grain_size);
} else {
PyErr_Format(PyExc_AttributeError, "_ped.Alignment object has no
attribute %s", member);
return NULL;
@@ -143,12 +143,12 @@
}
if (!strcmp(member, "offset")) {
- self->offset = PyLong_AsLong(value);
+ self->offset = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
} else if (!strcmp(member, "grain_size")) {
- self->grain_size = PyLong_AsLong(value);
+ self->grain_size = PyLong_AsLongLong(value);
if (PyErr_Occurred()) {
return -1;
}
@@ -252,7 +252,7 @@
return NULL;
}
- return PyLong_FromLong(ret);
+ return PyLong_FromLongLong(ret);
}
PyObject *py_ped_alignment_align_down(PyObject *s, PyObject *args) {
@@ -284,7 +284,7 @@
return NULL;
}
- return PyLong_FromLong(ret);
+ return PyLong_FromLongLong(ret);
}
PyObject *py_ped_alignment_align_nearest(PyObject *s, PyObject *args) {
@@ -316,7 +316,7 @@
return NULL;
}
- return PyLong_FromLong(ret);
+ return PyLong_FromLongLong(ret);
}
PyObject *py_ped_alignment_is_aligned(PyObject *s, PyObject *args) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/README.rst
new/pyparted-3.11.1/tests/README.rst
--- old/pyparted-3.10.7/tests/README.rst 1970-01-01 01:00:00.000000000
+0100
+++ new/pyparted-3.11.1/tests/README.rst 2017-06-26 17:20:05.000000000
+0200
@@ -0,0 +1,67 @@
+Testing pyparted
+================
+
+Pyparted test suite inherits from the standard :class:`unittest.TestCase`
class.
+To execute it from inside the source directory run the command::
+
+ make test
+
+It is also possible to generate test coverage reports using the Python coverage
+tool. To do that execute::
+
+ make coverage
+
+To execute the Pylint code analysis tool run::
+
+ make check
+
+Running Pylint requires Python3 due to usage of pocket-lint.
+
+
+Test Suite Architecture
+------------------------
+
+Pyparted test suite relies on several base classes listed below. All test
+cases inherit from them.
+
+- :class:`unittest.TestCase` - the standard unit test class in Python.
+ Used only for base classes described below and for test cases which
+ don't need access to filesystems or disks;
+
+
+- :class:`~tests.baseclass.RequiresDeviceNode` - base class for any test case
+ that requires a temporary device node;
+
+- :class:`~tests.baseclass.RequiresDevice` - base class for any test case that
+ requires a _ped.Device or parted.Device object first;
+
+- :class:`~tests.baseclass.RequiresFileSystem` - base class for any test case
+ that requires a filesystem on a device;
+
+- :class:`~tests.baseclass.RequiresDeviceAlignment`- base class for certain
+ alignment tests that require a _ped.Device;
+
+- :class:`~tests.baseclass.RequiresLabeledDevice` - base class for any test
+ case that requires a labeled device;
+
+- :class:`~tests.baseclass.RequiresDisk` - base class for any test case that
+ requires a _ped.Disk or parted.Disk;
+
+- :class:`~tests.baseclass.RequiresMount` - base class for any test case that
+ requires a filesystem made and mounted;
+
+- :class:`~tests.baseclass.RequiresPartition` - base class for any test case
+ that requires a _ped.Partition;
+
+- :class:`~tests.baseclass.RequiresDiskTypes` - base class for any test case
+ that requires a hash table of all _ped.DiskType objects available;
+
+- :class:`~tests.baseclass.BuildList` - base class for any test case that
+ requires a list being built via successive calls of some function. The
+ function must raise IndexError when there's no more output to add to the
+ return list. This class is most useful for all those _get_next methods.
+ It is used in combination with other base classes;
+
+
+Test scenarios are defined inside the `runTest` method of each test class using
+multiple assert statements.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/pylint/runpylint.py
new/pyparted-3.11.1/tests/pylint/runpylint.py
--- old/pyparted-3.10.7/tests/pylint/runpylint.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/pylint/runpylint.py 2017-06-26
17:20:05.000000000 +0200
@@ -9,12 +9,6 @@
def extraArgs(self):
return ["--extension-pkg-whitelist", "_ped"]
- @property
- def pylintPlugins(self):
- retval = super(PypartedLintConfig, self).pylintPlugins
- retval.remove("pocketlint.checkers.eintr")
- return retval
-
if __name__ == "__main__":
conf = PypartedLintConfig()
linter = PocketLinter(conf)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test__ped_geometry.py
new/pyparted-3.11.1/tests/test__ped_geometry.py
--- old/pyparted-3.10.7/tests/test__ped_geometry.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test__ped_geometry.py 2017-06-26
17:20:05.000000000 +0200
@@ -1,5 +1,5 @@
#
-# Copyright (C) 2008-2011 Red Hat, Inc.
+# Copyright (C) 2008-2016 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
@@ -19,6 +19,7 @@
#
import _ped
+import six
from tests.baseclass import RequiresDevice
# One class per method, multiple tests per class. For these simple methods,
@@ -374,4 +375,4 @@
lines = str(self.g).split('\n')
self.assertEqual(lines[0], '_ped.Geometry instance --')
self.assertEqual(lines[1], ' start: 10 end: 109 length: 100')
- self.assertRegexpMatches(lines[2], '^ device: <_ped.Device object at
.*')
+ six.assertRegex(self, lines[2], '^ device: <_ped.Device object at .*')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test__ped_partition.py
new/pyparted-3.11.1/tests/test__ped_partition.py
--- old/pyparted-3.10.7/tests/test__ped_partition.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test__ped_partition.py 2017-06-26
17:20:05.000000000 +0200
@@ -122,7 +122,7 @@
'PARTITION_APPLE_TV_RECOVERY',
'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
'PARTITION_MSFT_DATA', 'PARTITION_IRST',
- 'PARTITION_ESP']:
+ 'PARTITION_ESP', 'PARTITION_NONFS']:
if not hasattr(_ped, f):
continue
attr = getattr(_ped, f)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test__ped_ped.py
new/pyparted-3.11.1/tests/test__ped_ped.py
--- old/pyparted-3.10.7/tests/test__ped_ped.py 2015-08-27 21:59:22.000000000
+0200
+++ new/pyparted-3.11.1/tests/test__ped_ped.py 2017-06-26 17:20:05.000000000
+0200
@@ -41,7 +41,7 @@
'PARTITION_APPLE_TV_RECOVERY',
'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
'PARTITION_MSFT_DATA', 'PARTITION_IRST',
- 'PARTITION_ESP']:
+ 'PARTITION_ESP', 'PARTITION_NONFS']:
if not hasattr(_ped, f):
continue
attr = getattr(_ped, f)
@@ -54,7 +54,7 @@
def runTest(self):
for f in ["boot", "root", "swap", "hidden", "raid", "lvm", "lba",
"hp-service", "palo", "prep", "msftres", "bios_grub",
- "msftdata", "irst", "esp"]:
+ "msftdata", "irst", "esp", "nonfs"]:
self.assertNotEqual(_ped.partition_flag_get_by_name(f), "", "Could
not get flag %s" % f)
self.assertEqual(_ped.partition_flag_get_by_name("nosuchflag"), 0)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_alignment.py
new/pyparted-3.11.1/tests/test_parted_alignment.py
--- old/pyparted-3.10.7/tests/test_parted_alignment.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_alignment.py 2017-06-26
17:20:05.000000000 +0200
@@ -141,21 +141,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(AlignmentNewTestCase())
- suite.addTest(AlignmentGetSetTestCase())
- suite.addTest(AlignmentIntersectTestCase())
- suite.addTest(AlignmentAlignUpTestCase())
- suite.addTest(AlignmentAlignDownTestCase())
- suite.addTest(AlignmentAlignNearestTestCase())
- suite.addTest(AlignmentIsAlignedTestCase())
- suite.addTest(AlignmentGetPedAlignmentTestCase())
- suite.addTest(AlignmentStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_constraint.py
new/pyparted-3.11.1/tests/test_parted_constraint.py
--- old/pyparted-3.10.7/tests/test_parted_constraint.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_constraint.py 2017-06-26
17:20:05.000000000 +0200
@@ -155,20 +155,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(ConstraintNewTestCase())
- suite.addTest(ConstraintGetSetTestCase())
- suite.addTest(ConstraintIntersectTestCase())
- suite.addTest(ConstraintSolveMaxTestCase())
- suite.addTest(ConstraintSolveNearestTestCase())
- suite.addTest(ConstraintIsSolutionTestCase())
- suite.addTest(ConstraintGetPedConstraintTestCase())
- suite.addTest(ConstraintStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_device.py
new/pyparted-3.11.1/tests/test_parted_device.py
--- old/pyparted-3.10.7/tests/test_parted_device.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_device.py 2017-06-26
17:20:05.000000000 +0200
@@ -155,34 +155,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(DeviceNewTestCase())
- suite.addTest(DeviceGetSetTestCase())
- suite.addTest(DeviceOpenTestCase())
- suite.addTest(DeviceCloseTestCase())
- suite.addTest(DeviceDestroyTestCase())
- suite.addTest(DeviceRemoveFromCacheTestCase())
- suite.addTest(DeviceBeginExternalAccessTestCase())
- suite.addTest(DeviceEndExternalAccessTestCase())
- suite.addTest(DeviceReadTestCase())
- suite.addTest(DeviceWriteTestCase())
- suite.addTest(DeviceSyncTestCase())
- suite.addTest(DeviceCheckTestCase())
- suite.addTest(DeviceStartSectorToCylinderTestCase())
- suite.addTest(DeviceEndSectorToCylinderTestCase())
- suite.addTest(DeviceStartCylinderToSectorTestCase())
- suite.addTest(DeviceEndCylinderToSectorTestCase())
- suite.addTest(DeviceGetSizeTestCase())
- suite.addTest(DeviceGetLengthTestCase())
- suite.addTest(DeviceGetSizeAsSectorsTestCase())
- suite.addTest(DeviceGetConstraintTestCase())
- suite.addTest(DeviceGetPedDeviceTestCase())
- suite.addTest(DeviceStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_disk.py
new/pyparted-3.11.1/tests/test_parted_disk.py
--- old/pyparted-3.10.7/tests/test_parted_disk.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_disk.py 2017-06-26
17:20:05.000000000 +0200
@@ -88,11 +88,19 @@
# TODO
self.fail("Unimplemented test case.")
-@unittest.skip("Unimplemented test case.")
-class DiskAddPartitionTestCase(unittest.TestCase):
+class DiskAddPartitionTestCase(RequiresDisk):
+ """
+ addPartition should return True if partition is added successfully(even
+ without committing)
+ """
def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
+ self.disk.setFlag(parted.DISK_CYLINDER_ALIGNMENT)
+
+ length = 100
+ geom = parted.Geometry(self.device, start=100, length=length)
+ part = parted.Partition(self.disk, parted.PARTITION_NORMAL,
geometry=geom)
+ constraint = parted.Constraint(exactGeom=geom)
+ self.assertTrue(self.disk.addPartition(part, constraint))
@unittest.skip("Unimplemented test case.")
class DiskRemovePartitionTestCase(unittest.TestCase):
@@ -142,17 +150,17 @@
# TODO
self.fail("Unimplemented test case.")
-@unittest.skip("Unimplemented test case.")
-class DiskGetMaxLogicalPartitionsTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
-class DiskGetMaxSupportedPartitionCountTestCase(unittest.TestCase):
+class DiskGetMaxSupportedPartitionCountTestCase(RequiresDisk):
+ """
+ maxSupportedPartitionCount should return value 64, based on default
+ value MAX_NUM_PARTS(parted/libparted/arch/linux.c) applied if it cannot
+ find value in /sys/block/DEV/ext_range (RequiresDisk implies there is
+ no ext_range value). Also see testcase
+ DiskGetMaxSupportedPartitionCountTestCase in tests/test__ped_disk ,
+ which tests value returned by source C function defined in module _ped
+ """
def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
+ self.assertEqual(self.disk.maxSupportedPartitionCount, 64)
class DiskMaxPartitionLengthTestCase(RequiresDisk):
def runTest(self):
@@ -254,50 +262,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(DiskNewTestCase())
- suite.addTest(DiskGetSetTestCase())
- suite.addTest(DiskClobberTestCase())
- suite.addTest(DiskDuplicateTestCase())
- suite.addTest(DiskDestroyTestCase())
- suite.addTest(DiskCommitTestCase())
- suite.addTest(DiskCommitToDeviceTestCase())
- suite.addTest(DiskCommitToOSTestCase())
- suite.addTest(DiskCheckTestCase())
- suite.addTest(DiskSupportsFeatureTestCase())
- suite.addTest(DiskAddPartitionTestCase())
- suite.addTest(DiskRemovePartitionTestCase())
- suite.addTest(DiskDeletePartitionTestCase())
- suite.addTest(DiskDeleteAllPartitionsTestCase())
- suite.addTest(DiskSetPartitionGeometryTestCase())
- suite.addTest(DiskMaximizePartitionTestCase())
- suite.addTest(DiskCalculateMaxPartitionGeometryTestCase())
- suite.addTest(DiskMinimizeExtendedPartitionTestCase())
- suite.addTest(DiskGetPartitionBySectorTestCase())
- suite.addTest(DiskGetMaxLogicalPartitionsTestCase())
- suite.addTest(DiskGetMaxSupportedPartitionCountTestCase())
- suite.addTest(DiskMaxPartitionLengthTestCase())
- suite.addTest(DiskMaxPartitionStartSectorTestCase())
- suite.addTest(DiskGetFlagTestCase())
- suite.addTest(DiskSetFlagTestCase())
- suite.addTest(DiskUnsetFlagTestCase())
- suite.addTest(DiskIsFlagAvailableTestCase())
- suite.addTest(DiskGetExtendedPartitionTestCase())
- suite.addTest(DiskGetLogicalPartitionsTestCase())
- suite.addTest(DiskGetPrimaryPartitionsTestCase())
- suite.addTest(DiskGetRaidPartitionsTestCase())
- suite.addTest(DiskGetLVMPartitionsTestCase())
- suite.addTest(DiskGetFreeSpaceRegionsTestCase())
- suite.addTest(DiskGetFreeSpacePartitionsTestCase())
- suite.addTest(DiskGetFirstPartitionTestCase())
- suite.addTest(DiskGetPartitionByPathTestCase())
- suite.addTest(DiskGetPedDiskTestCase())
- suite.addTest(DiskStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_filesystem.py
new/pyparted-3.11.1/tests/test_parted_filesystem.py
--- old/pyparted-3.10.7/tests/test_parted_filesystem.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_filesystem.py 2017-06-26
17:20:05.000000000 +0200
@@ -48,16 +48,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(FileSystemNewTestCase())
- suite.addTest(FileSystemGetSetTestCase())
- suite.addTest(FileSystemGetPedFileSystemTestCase())
- suite.addTest(FileSystemStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_geometry.py
new/pyparted-3.11.1/tests/test_parted_geometry.py
--- old/pyparted-3.10.7/tests/test_parted_geometry.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_geometry.py 2017-06-26
17:20:05.000000000 +0200
@@ -125,28 +125,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(GeometryNewTestCase())
- suite.addTest(GeometryGetSetTestCase())
- suite.addTest(GeometryCheckTestCase())
- suite.addTest(GeometryContainsTestCase())
- suite.addTest(GeometryContainsSectorTestCase())
- suite.addTest(GeometryEqualTestCase())
- suite.addTest(GeometryGetSizeTestCase())
- suite.addTest(GeometryGetLengthTestCase())
- suite.addTest(GeometryIntersectTestCase())
- suite.addTest(GeometryMapTestCase())
- suite.addTest(GeometryOverlapsWithTestCase())
- suite.addTest(GeometryReadTestCase())
- suite.addTest(GeometrySyncTestCase())
- suite.addTest(GeometryWriteTestCase())
- suite.addTest(GeometryGetPedGeometryTestCase())
- suite.addTest(GeometryStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_parted.py
new/pyparted-3.11.1/tests/test_parted_parted.py
--- old/pyparted-3.10.7/tests/test_parted_parted.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_parted.py 2017-06-26
17:20:05.000000000 +0200
@@ -44,6 +44,7 @@
self.assertRaises(SyntaxError, parted.sizeToSectors, 9, "yb", 1)
self.assertEqual(int(parted.sizeToSectors(7777.0, "B", 512)),
parted.sizeToSectors(7777.0, "B", 512))
+ self.assertEqual(parted.sizeToSectors(1000, "B", 512), 2)
class GetLabelsTestCase(unittest.TestCase):
def runTest(self):
@@ -141,23 +142,3 @@
ver = parted.version()
self.assertEqual(ver['libparted'], _ped.libparted_version())
self.assertEqual(ver['pyparted'], _ped.pyparted_version())
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(FormatBytesTestCase())
- suite.addTest(BytesToSectorsTestCase())
- suite.addTest(GetLabelsTestCase())
- suite.addTest(GetDeviceTestCase())
- suite.addTest(GetAllDevicesTestCase())
- suite.addTest(ProbeForSpecificFileSystemTestCase())
- suite.addTest(ProbeFileSystemTestCase())
- suite.addTest(FreshDiskTestCase())
- suite.addTest(IsAlignToCylindersTestCase())
- suite.addTest(ToggleAlignToCylindersTestCase())
- suite.addTest(VersionTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyparted-3.10.7/tests/test_parted_partition.py
new/pyparted-3.11.1/tests/test_parted_partition.py
--- old/pyparted-3.10.7/tests/test_parted_partition.py 2015-08-27
21:59:22.000000000 +0200
+++ new/pyparted-3.11.1/tests/test_parted_partition.py 2017-06-26
17:20:05.000000000 +0200
@@ -28,35 +28,158 @@
# One class per method, multiple tests per class. For these simple methods,
# that seems like good organization. More complicated methods may require
# multiple classes and their own test suite.
-@unittest.skip("Unimplemented test case.")
-class PartitionNewTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-@unittest.skip("Unimplemented test case.")
-class PartitionGetSetTestCase(unittest.TestCase):
+class PartitionNewTestCase(RequiresDisk):
+ """
+ PartitionNew tests if parted.Partition:
+ 1) raises user defined exception if called without arguments
+ 2) if parted.Partition is instantiable with argument fs
+ 3) if parted.Partition is instantiable without argument fs
+ """
+ def setUp(self):
+ super(PartitionNewTestCase, self).setUp()
+ self.geom = parted.Geometry(self.device, start=100, length=100)
+ self.fs = parted.FileSystem(type='ext2', geometry=self.geom)
+ self.part = parted.Partition(self.disk, parted.PARTITION_NORMAL,
+ geometry=self.geom, fs=self.fs)
+
+ def runTest(self):
+ # Check that not passing args to parted.Partition.__init__ is caught.
+ with self.assertRaises((parted.PartitionException,)):
+ parted.Partition()
+
+ self.assertIsInstance(self.part, parted.Partition)
+ # You don't need to pass a filesystem type at all, since this partition
+ # might be FREESPACE or METADATA.
+ part_nofs = parted.Partition(self.disk, parted.PARTITION_NORMAL,
+ geometry=self.geom)
+ self.assertIsInstance(part_nofs, parted.Partition)
+
+class PartitionGetSetTestCase(PartitionNewTestCase):
+ """
+ PartitionGetSet tests "part" instance
+ of class parted.Partition(created in baseclass)
+ for basic get and set operations on its attributes.
+ """
+ def runTest(self):
+ # Test that passing the kwargs to __init__ works.
+ self.assertEqual(self.part.disk, self.disk)
+ self.assertIsInstance(self.part.geometry, parted.Geometry)
+ self.assertEqual(self.part.type, parted.PARTITION_NORMAL)
+ self.assertEqual(self.part.fileSystem.type, "ext2")
+
+ # Test that setting the RW attributes directly works.
+ self.part.type = parted.PARTITION_EXTENDED
+ self.assertEqual(self.part.type, parted.PARTITION_EXTENDED)
+
+ # Test that setting the RO attributes directly doesn't work.
+ exn = (AttributeError, TypeError)
+ with self.assertRaises(exn):
+ self.part.number = 1
+ with self.assertRaises(exn):
+ self.part.active = True
+ with self.assertRaises(exn):
+ self.part.name = "blah"
+ with self.assertRaises(exn):
+ self.part.type = "blah"
+ with self.assertRaises(exn):
+ self.part.disk = self.disk
+
+ # Check that looking for invalid attributes fails properly.
+ with self.assertRaises((AttributeError)):
+ print(self.part.blah)
+
+class PartitionSetFlagTestCase(PartitionNewTestCase):
+ """
+ Method setFlag should return True, if flag was set to "on" state.
+ Next few flag testcases will inherit from setUp.
+ This testcase checks if method setFlag returns:
+ 1)correct bool when state of BOOT and RAID flags is set to "on"
+ on partition.
+ 2)raises user defined exception on unavailable flag
+ See parted/include/parted/disk.in.h for flag numbers.
+ Partition flags are dependent on disklabel. In this case msdos label is
+ used, see parted library libparted/labels/dos.c for flags availability.
+ """
+ def setUp(self):
+ super(PartitionSetFlagTestCase, self).setUp()
+ self.neg_msg = "Method returns unexpected bool value"
+ self.flag_set = self.part.setFlag(1)
+ self.flag_set1 = self.part.setFlag(5)
+
+ def runTest(self):
+ self.assertTrue(self.flag_set, self.neg_msg)
+ self.assertTrue(self.flag_set1, self.neg_msg)
+ with self.assertRaises((parted.PartitionException,)):
+ self.part.setFlag(2)
+
+class PartitionGetFlagTestCase(PartitionSetFlagTestCase):
+ """
+ Method getFlag should return correct bool value depending on flag
+ setting(flag is off=>False; on=>True).
+ This testcase checks if method getFlag returns:
+ 1)correct bools when checks state of BOOT(on), RAID(on) and LVM(off)
+ flags.
+ """
+ def runTest(self):
+ self.assertTrue(self.part.getFlag(1), self.neg_msg)
+ self.assertTrue(self.part.getFlag(5), self.neg_msg)
+ self.assertFalse(self.part.getFlag(6), self.neg_msg)
+
+class PartitionUnsetFlagTestCase(PartitionSetFlagTestCase):
+ """
+ Method unsetFlag should set flag to "off" state and return True on
+ success. PartitionException should be raised on error.
+ This testcase checks if method unsetFlag returns:
+ 1)correct bool value when flag is unset and if flag is in state 'off'
+ 2)raises user defined exception on unavailable flag
+ """
+ def runTest(self):
+ self.assertTrue(self.part.unsetFlag(1), self.neg_msg)
+ self.assertFalse(self.part.getFlag(1), self.neg_msg)
+
+ with self.assertRaises((parted.PartitionException,)):
+ self.part.unsetFlag(2)
+
+class PartitionIsFlagAvailableTestCase(PartitionNewTestCase):
+ '''
+ Method isFlagAvailable should return bool value whenever flag is
+ available according to chosen disk label setting and disk proportions
+ itself.
+ This testcase checks if method isFlagAvailable returns:
+ 1)bool value without traceback
+ 2)false on nonexistent flag
+ 3)raises user defined exception when called on inactive partition
+ '''
+ def runTest(self):
+ for f in ['PARTITION_BOOT', 'PARTITION_ROOT', 'PARTITION_SWAP',
+ 'PARTITION_HIDDEN', 'PARTITION_RAID', 'PARTITION_LVM',
+ 'PARTITION_LBA', 'PARTITION_HPSERVICE',
+ 'PARTITION_PALO', 'PARTITION_PREP',
+ 'PARTITION_MSFT_RESERVED',
+ 'PARTITION_APPLE_TV_RECOVERY',
+ 'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
+ 'PARTITION_MSFT_DATA', 'PARTITION_IRST',
+ 'PARTITION_ESP', 'PARTITION_NONFS']:
+ if not hasattr(parted, f):
+ continue
+ attr = getattr(parted, f)
+ self.assertIsInstance(self.part.isFlagAvailable(attr), bool)
+
+ self.assertFalse(self.part.isFlagAvailable(1000))
+
+ with self.assertRaises((parted.PartitionException,)):
+ self.part = parted.Partition(self.disk, parted.PARTITION_FREESPACE,
+ geometry=self.geom)
+ self.part.isFlagAvailable(parted.PARTITION_BOOT)
+
+class PartitionGetFlagsAsStringTestCase(PartitionSetFlagTestCase):
+ '''
+ Method getFlagsAsString should return all flags which are in state "on"
+ as comma separated list.
+ '''
def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
-class PartitionGetFlagTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
-class PartitionSetFlagTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
-class PartitionUnsetFlagTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
+ self.assertEqual(self.part.getFlagsAsString(), 'boot, raid')
@unittest.skip("Unimplemented test case.")
class PartitionGetMaxGeometryTestCase(unittest.TestCase):
@@ -65,12 +188,6 @@
self.fail("Unimplemented test case.")
@unittest.skip("Unimplemented test case.")
-class PartitionIsFlagAvailableTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
class PartitionNextPartitionTestCase(unittest.TestCase):
def runTest(self):
# TODO
@@ -96,12 +213,6 @@
self.assertEqual(part.getLength(), length)
@unittest.skip("Unimplemented test case.")
-class PartitionGetFlagsAsStringTestCase(unittest.TestCase):
- def runTest(self):
- # TODO
- self.fail("Unimplemented test case.")
-
-@unittest.skip("Unimplemented test case.")
class PartitionGetMaxAvailableSizeTestCase(unittest.TestCase):
def runTest(self):
# TODO
@@ -124,27 +235,3 @@
def runTest(self):
# TODO
self.fail("Unimplemented test case.")
-
-# And then a suite to hold all the test cases for this module.
-def makeSuite():
- suite = unittest.TestSuite()
- suite.addTest(PartitionNewTestCase())
- suite.addTest(PartitionGetSetTestCase())
- suite.addTest(PartitionGetFlagTestCase())
- suite.addTest(PartitionSetFlagTestCase())
- suite.addTest(PartitionUnsetFlagTestCase())
- suite.addTest(PartitionGetMaxGeometryTestCase())
- suite.addTest(PartitionIsFlagAvailableTestCase())
- suite.addTest(PartitionNextPartitionTestCase())
- suite.addTest(PartitionGetSizeTestCase())
- suite.addTest(PartitionGetLengthTestCase())
- suite.addTest(PartitionGetFlagsAsStringTestCase())
- suite.addTest(PartitionGetMaxAvailableSizeTestCase())
- suite.addTest(PartitionGetDeviceNodeNameTestCase())
- suite.addTest(PartitionGetPedPartitionTestCase())
- suite.addTest(PartitionStrTestCase())
- return suite
-
-s = makeSuite()
-if __name__ == "__main__":
- unittest.main(defaultTest='s', verbosity=2)
++++++ python-parted-featurestest.patch ++++++
Index: pyparted-3.11.1/tests/test__ped_disktype.py
===================================================================
--- pyparted-3.11.1.orig/tests/test__ped_disktype.py
+++ pyparted-3.11.1/tests/test__ped_disktype.py
@@ -80,7 +80,7 @@ class DiskTypeStrTestCase(RequiresDiskTy
self.assertEqual(str(self.disktype['sun']), '_ped.DiskType instance
--\n name: sun features: 0')
self.assertEqual(str(self.disktype['amiga']), '_ped.DiskType instance
--\n name: amiga features: 2')
self.assertEqual(str(self.disktype['gpt']), '_ped.DiskType instance
--\n name: gpt features: 2')
- self.assertEqual(str(self.disktype['mac']), '_ped.DiskType instance
--\n name: mac features: 2')
+ self.assertEqual(str(self.disktype['mac']), '_ped.DiskType instance
--\n name: mac features: 6')
self.assertEqual(str(self.disktype['bsd']), '_ped.DiskType instance
--\n name: bsd features: 0')
self.assertEqual(str(self.disktype['pc98']), '_ped.DiskType instance
--\n name: pc98 features: 2')
self.assertEqual(str(self.disktype['loop']), '_ped.DiskType instance
--\n name: loop features: 0')
Index: pyparted-3.11.1/tests/test_parted_partition.py
===================================================================
--- pyparted-3.11.1.orig/tests/test_parted_partition.py
+++ pyparted-3.11.1/tests/test_parted_partition.py
@@ -179,7 +179,7 @@ class PartitionGetFlagsAsStringTestCase(
as comma separated list.
'''
def runTest(self):
- self.assertEqual(self.part.getFlagsAsString(), 'boot, raid')
+ self.assertEqual(self.part.getFlagsAsString(), 'boot, raid, type')
@unittest.skip("Unimplemented test case.")
class PartitionGetMaxGeometryTestCase(unittest.TestCase):
++++++ python-parted-parted-binary.patch ++++++
Index: pyparted-3.11.1/tests/baseclass.py
===================================================================
--- pyparted-3.11.1.orig/tests/baseclass.py
+++ pyparted-3.11.1/tests/baseclass.py
@@ -68,7 +68,7 @@ class RequiresFileSystem(unittest.TestCa
os.write(fd, b"0")
f.close()
- os.system("mke2fs -F -q %s" % (self.path,))
+ os.system("/usr/sbin/mke2fs -F -q %s" % (self.path,))
self._device = _ped.device_get(self.path)
self._geometry = _ped.Geometry(self._device, 0, self._device.length -
1)
@@ -133,7 +133,7 @@ class RequiresDeviceAlignment(RequiresDe
class RequiresLabeledDevice(RequiresDevice):
def setUp(self):
RequiresDevice.setUp(self)
- os.system("parted -s %s mklabel msdos" % (self.path,))
+ os.system("/usr/sbin/parted -s %s mklabel msdos" % (self.path,))
# Base class for any test case that requires a _ped.Disk or parted.Disk.
class RequiresDisk(RequiresDevice):
@@ -150,7 +150,7 @@ class RequiresMount(RequiresDevice):
self.mountpoint = None
def mkfs(self):
- os.system("mkfs.ext2 -F -q %s" % self.path)
+ os.system("/usr/sbin/mkfs.ext2 -F -q %s" % self.path)
def doMount(self):
self.mountpoint = tempfile.mkdtemp()
++++++ python-parted-unittests.patch ++++++
>From 52762a217fdc702e3f8ed869d1d8ccf30babed05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20=27sil2100=27=20Zemczak?=
<lukasz.zemc...@ubuntu.com>
Date: Mon, 17 Jul 2017 12:36:01 +0200
Subject: [PATCH] _ped's *_flag_get_name methods now throw a PartedException
instead of ValueError on unsupported flags.
---
tests/test__ped_ped.py | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/test__ped_ped.py b/tests/test__ped_ped.py
index 79046ab..e7ce116 100755
--- a/tests/test__ped_ped.py
+++ b/tests/test__ped_ped.py
@@ -48,7 +48,7 @@ def runTest(self):
self.assertNotEqual(_ped.partition_flag_get_name(attr), "", "Could
not get name for flag _ped.%s" % f)
self.assertRaises(ValueError, _ped.partition_flag_get_name, -1)
- self.assertRaises(ValueError, _ped.partition_flag_get_name, 1000)
+ self.assertRaises(_ped.PartedException, _ped.partition_flag_get_name,
1000)
class PartitionFlagGetByNameTestCase(unittest.TestCase):
def runTest(self):
@@ -82,7 +82,7 @@ def runTest(self):
self.assertNotEqual(_ped.disk_flag_get_name(f), "", "Could not get
name for flag %s" % f)
self.assertRaises(ValueError, _ped.disk_flag_get_name, -1)
- self.assertRaises(ValueError, _ped.disk_flag_get_name, 1000)
+ self.assertRaises(_ped.PartedException, _ped.disk_flag_get_name, 1000)
class DiskFlagGetByNameTestCase(unittest.TestCase):
def runTest(self):
