aiden
/
calamares
mirror of https://github.com/cutefishos/calamares
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1558 from gportay/partition-cleanups

Browse Source 
[partition] cleanups
main
Adriaan de Groot 4 years ago committed by GitHub
parent 89a04e0fa3 f03ae06deb
commit 7db398cfdf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 204 additions and 297 deletions
Show Stats Download Patch File Download Diff File

4
src/modules/partition/core/PartUtils.cpp
Unescape Escape View File

@ -1,7 +1,7 @@
/* === This file is part of Calamares - <https://calamares.io> ===
*
* SPDX-FileCopyrightText: 2015-2016 Teo Mrnjavac <teo@kde.org>
* Copyright 2018-2019 Adriaan de Groot <groot@kde.org>
* SPDX-FileCopyrightText: 2018-2019 Adriaan de Groot <groot@kde.org>
* SPDX-FileCopyrightText: 2019 Collabora Ltd <arnaud.ferraris@collabora.com>
* SPDX-License-Identifier: GPL-3.0-or-later
*
@ -59,7 +59,7 @@ convenienceName( const Partition* const candidate )
QString p;
QTextStream s( &p );
s << static_cast<const void*>(candidate); // No good name available, use pointer address
s << static_cast< const void* >( candidate ); // No good name available, use pointer address
return p;
}

76
src/modules/partition/core/PartitionCoreModule.cpp
Unescape Escape View File

@ -860,82 +860,10 @@ PartitionCoreModule::setBootLoaderInstallPath( const QString& path )
m_bootLoaderInstallPath = path;
}
void
PartitionCoreModule::initLayout()
{
m_partLayout = new PartitionLayout();
m_partLayout->addEntry( QString( "/" ), QString( "100%" ) );
}
void
PartitionCoreModule::initLayout( const QVariantList& config )
{
bool ok;
QString sizeString;
QString minSizeString;
QString maxSizeString;
m_partLayout = new PartitionLayout();
for ( const auto& r : config )
{
QVariantMap pentry = r.toMap();
if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
|| !pentry.contains( "size" ) )
{
cError() << "Partition layout entry #" << config.indexOf( r )
<< "lacks mandatory attributes, switching to default layout.";
delete ( m_partLayout );
initLayout();
break;
}
if ( pentry.contains( "size" ) && CalamaresUtils::getString( pentry, "size" ).isEmpty() )
{
sizeString.setNum( CalamaresUtils::getInteger( pentry, "size", 0 ) );
}
else
{
sizeString = CalamaresUtils::getString( pentry, "size" );
}
if ( pentry.contains( "minSize" ) && CalamaresUtils::getString( pentry, "minSize" ).isEmpty() )
{
minSizeString.setNum( CalamaresUtils::getInteger( pentry, "minSize", 0 ) );
}
else
{
minSizeString = CalamaresUtils::getString( pentry, "minSize" );
}
if ( pentry.contains( "maxSize" ) && CalamaresUtils::getString( pentry, "maxSize" ).isEmpty() )
{
maxSizeString.setNum( CalamaresUtils::getInteger( pentry, "maxSize", 0 ) );
}
else
{
maxSizeString = CalamaresUtils::getString( pentry, "maxSize" );
}
if ( !m_partLayout->addEntry( CalamaresUtils::getString( pentry, "name" ),
CalamaresUtils::getString( pentry, "uuid" ),
CalamaresUtils::getString( pentry, "type" ),
CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
CalamaresUtils::getString( pentry, "mountPoint" ),
CalamaresUtils::getString( pentry, "filesystem" ),
CalamaresUtils::getSubMap( pentry, "features", ok ),
sizeString,
minSizeString,
maxSizeString ) )
{
cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
delete ( m_partLayout );
initLayout();
break;
}
}
m_partLayout.init( config );
}
void
@ -947,7 +875,7 @@ PartitionCoreModule::layoutApply( Device* dev,
const PartitionRole& role )
{
bool isEfi = PartUtils::isEfiSystem();
QList< Partition* > partList = m_partLayout->execute( dev, firstSector, lastSector, luksPassphrase, parent, role );
QList< Partition* > partList = m_partLayout.createPartitions( dev, firstSector, lastSector, luksPassphrase, parent, role );
// Partition::mountPoint() tells us where it is mounted **now**, while
// PartitionInfo::mountPoint() says where it will be mounted in the target system.

5
src/modules/partition/core/PartitionCoreModule.h
Unescape Escape View File

@ -156,8 +156,7 @@ public:
/// @brief Set the path where the bootloader will be installed
void setBootLoaderInstallPath( const QString& path );
void initLayout();
void initLayout( const QVariantList& config );
void initLayout( const QVariantList& config = QVariantList() );
void layoutApply( Device* dev, qint64 firstSector, qint64 lastSector, QString luksPassphrase );
void layoutApply( Device* dev,
@ -256,7 +255,7 @@ private:
bool m_hasRootMountPoint = false;
bool m_isDirty = false;
QString m_bootLoaderInstallPath;
PartitionLayout* m_partLayout;
PartitionLayout m_partLayout;
OsproberEntryList m_osproberLines;

327
src/modules/partition/core/PartitionLayout.cpp
Unescape Escape View File

@ -21,6 +21,8 @@
#include "core/PartitionActions.h"
#include "core/PartitionInfo.h"
#include "utils/Variant.h"
#include <kpmcore/core/device.h>
#include <kpmcore/core/partition.h>
#include <kpmcore/fs/filesystem.h>
@ -48,12 +50,6 @@ PartitionLayout::PartitionLayout()
{
}
PartitionLayout::PartitionLayout( PartitionLayout::PartitionEntry entry )
: PartitionLayout()
{
m_partLayout.append( entry );
}
PartitionLayout::PartitionLayout( const PartitionLayout& layout )
: m_defaultFsType( layout.m_defaultFsType )
, m_partLayout( layout.m_partLayout )
@ -62,270 +58,247 @@ PartitionLayout::PartitionLayout( const PartitionLayout& layout )
PartitionLayout::~PartitionLayout() {}
bool
PartitionLayout::addEntry( PartitionLayout::PartitionEntry entry )
PartitionLayout::PartitionEntry::PartitionEntry()
: partAttributes( 0 )
{
if ( !entry.isValid() )
{
cError() << "Partition size is invalid or has min size > max size";
return false;
}
m_partLayout.append( entry );
return true;
}
PartitionLayout::PartitionEntry::PartitionEntry()
PartitionLayout::PartitionEntry::PartitionEntry( const QString& mountPoint, const QString& size, const QString& minSize, const QString& maxSize )
: partAttributes( 0 )
, partMountPoint( mountPoint )
, partSize( size )
, partMinSize( minSize )
, partMaxSize( maxSize )
{
}
PartitionLayout::PartitionEntry::PartitionEntry( const QString& size, const QString& min, const QString& max )
: partAttributes( 0 )
PartitionLayout::PartitionEntry::PartitionEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& minSize,
const QString& maxSize )
: partLabel( label )
, partUUID( uuid )
, partType( type )
, partAttributes( attributes )
, partMountPoint( mountPoint )
, partFeatures( features )
, partSize( size )
, partMinSize( min )
, partMaxSize( max )
, partMinSize( minSize )
, partMaxSize( maxSize )
{
PartUtils::findFS( fs, &partFileSystem );
}
bool
PartitionLayout::addEntry( const QString& mountPoint, const QString& size, const QString& min, const QString& max )
PartitionLayout::PartitionEntry::PartitionEntry( const PartitionEntry& e )
: partLabel( e.partLabel )
, partUUID( e.partUUID )
, partType( e.partType )
, partAttributes( e.partAttributes )
, partMountPoint( e.partMountPoint )
, partFileSystem( e.partFileSystem )
, partFeatures( e.partFeatures )
, partSize( e.partSize )
, partMinSize( e.partMinSize )
, partMaxSize( e.partMaxSize )
{
PartitionLayout::PartitionEntry entry( size, min, max );
}
bool
PartitionLayout::addEntry( const PartitionEntry& entry )
{
if ( !entry.isValid() )
{
cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
return false;
}
if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
{
cError() << "Partition mount point" << mountPoint << "is invalid";
return false;
}
entry.partMountPoint = mountPoint;
entry.partFileSystem = m_defaultFsType;
m_partLayout.append( entry );
return true;
}
bool
PartitionLayout::addEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& min,
const QString& max )
void
PartitionLayout::init( const QVariantList& config )
{
PartitionLayout::PartitionEntry entry( size, min, max );
bool ok;
if ( !entry.isValid() )
{
cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
return false;
}
if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
m_partLayout.clear();
for ( const auto& r : config )
{
cError() << "Partition mount point" << mountPoint << "is invalid";
return false;
QVariantMap pentry = r.toMap();
if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
|| !pentry.contains( "size" ) )
{
cError() << "Partition layout entry #" << config.indexOf( r )
<< "lacks mandatory attributes, switching to default layout.";
m_partLayout.clear();
break;
}
if ( !addEntry( { CalamaresUtils::getString( pentry, "name" ),
CalamaresUtils::getString( pentry, "uuid" ),
CalamaresUtils::getString( pentry, "type" ),
CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
CalamaresUtils::getString( pentry, "mountPoint" ),
CalamaresUtils::getString( pentry, "filesystem" ),
CalamaresUtils::getSubMap( pentry, "features", ok ),
CalamaresUtils::getString( pentry, "size", QStringLiteral( "0" ) ),
CalamaresUtils::getString( pentry, "minSize", QStringLiteral( "0" ) ),
CalamaresUtils::getString( pentry, "maxSize", QStringLiteral( "0" ) ) } ) )
{
cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
m_partLayout.clear();
break;
}
}
entry.partLabel = label;
entry.partUUID = uuid;
entry.partType = type;
entry.partAttributes = attributes;
entry.partMountPoint = mountPoint;
PartUtils::findFS( fs, &entry.partFileSystem );
if ( entry.partFileSystem == FileSystem::Unknown )
if ( !m_partLayout.count() )
{
entry.partFileSystem = m_defaultFsType;
addEntry( { QString( "/" ), QString( "100%" ) } );
}
entry.partFeatures = features;
m_partLayout.append( entry );
return true;
}
QList< Partition* >
PartitionLayout::execute( Device* dev,
qint64 firstSector,
qint64 lastSector,
QString luksPassphrase,
PartitionNode* parent,
const PartitionRole& role )
PartitionLayout::createPartitions( Device* dev,
qint64 firstSector,
qint64 lastSector,
QString luksPassphrase,
PartitionNode* parent,
const PartitionRole& role )
{
QList< Partition* > partList;
// Map each partition entry to its requested size (0 when calculated later)
QMap< const PartitionLayout::PartitionEntry*, qint64 > partSizeMap;
qint64 totalSize = lastSector - firstSector + 1;
qint64 availableSize = totalSize;
QMap< const PartitionLayout::PartitionEntry*, qint64 > partSectorsMap;
const qint64 totalSectors = lastSector - firstSector + 1;
qint64 currentSector, availableSectors = totalSectors;
// Let's check if we have enough space for each partSize
for ( const auto& part : qAsConst( m_partLayout ) )
// Let's check if we have enough space for each partitions, using the size
// propery or the min-size property if unit is in percentage.
for ( const auto& entry : qAsConst( m_partLayout ) )
{
if ( !part.partSize.isValid() )
if ( !entry.partSize.isValid() )
{
cWarning() << "Partition" << part.partMountPoint << "size is invalid, skipping...";
cWarning() << "Partition" << entry.partMountPoint << "size is invalid, skipping...";
continue;
}
// Calculate partition size: Rely on "possibly uninitialized use"
// warnings to ensure that all the cases are covered below.
qint64 size;
// We need to ignore the percent-defined until later
if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
qint64 sectors = 0;
if ( entry.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
{
size = part.partSize.toSectors( totalSize, dev->logicalSize() );
sectors = entry.partSize.toSectors( totalSectors, dev->logicalSize() );
}
else
else if ( entry.partMinSize.isValid() )
{
if ( part.partMinSize.isValid() )
{
size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
}
else
{
size = 0;
}
sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
}
partSizeMap.insert( &part, size );
availableSize -= size;
partSectorsMap.insert( &entry, sectors );
availableSectors -= sectors;
}
// Use partMinSize and see if we can do better afterward.
if ( availableSize < 0 )
// There is not enough space for all partitions, use the min-size property
// and see if we can do better afterward.
if ( availableSectors < 0 )
{
availableSize = totalSize;
for ( const auto& part : qAsConst( m_partLayout ) )
availableSectors = totalSectors;
for ( const auto& entry : qAsConst( m_partLayout ) )
{
qint64 size;
if ( part.partMinSize.isValid() )
{
size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
}
else if ( part.partSize.isValid() )
{
if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
{
size = part.partSize.toSectors( totalSize, dev->logicalSize() );
}
else
{
size = 0;
}
}
else
qint64 sectors = partSectorsMap.value( &entry );
if ( entry.partMinSize.isValid() )
{
size = 0;
sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
partSectorsMap.insert( &entry, sectors );
}
partSizeMap.insert( &part, size );
availableSize -= size;
availableSectors -= sectors;
}
}
// Assign size for percentage-defined partitions
for ( const auto& part : qAsConst( m_partLayout ) )
// Assign sectors for percentage-defined partitions.
for ( const auto& entry : qAsConst( m_partLayout ) )
{
if ( part.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent )
if ( entry.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent )
{
qint64 size = partSizeMap.value( &part );
size = part.partSize.toSectors( availableSize + size, dev->logicalSize() );
if ( part.partMinSize.isValid() )
qint64 sectors = entry.partSize.toSectors( availableSectors + partSectorsMap.value( &entry ),
dev->logicalSize() );
if ( entry.partMinSize.isValid() )
{
qint64 minSize = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
if ( minSize > size )
{
size = minSize;
}
sectors = std::max( sectors, entry.partMinSize.toSectors( totalSectors, dev->logicalSize() ) );
}
if ( part.partMaxSize.isValid() )
if ( entry.partMaxSize.isValid() )
{
qint64 maxSize = part.partMaxSize.toSectors( totalSize, dev->logicalSize() );
if ( maxSize < size )
{
size = maxSize;
}
sectors = std::min( sectors, entry.partMaxSize.toSectors( totalSectors, dev->logicalSize() ) );
}
partSizeMap.insert( &part, size );
partSectorsMap.insert( &entry, sectors );
}
}
availableSize = totalSize;
// TODO: Refine partition sizes to make sure there is room for every partition
// Use a default (200-500M ?) minimum size for partition without minSize
for ( const auto& part : qAsConst( m_partLayout ) )
// Create the partitions.
currentSector = firstSector;
availableSectors = totalSectors;
for ( const auto& entry : qAsConst( m_partLayout ) )
{
qint64 size, end;
Partition* currentPartition = nullptr;
size = partSizeMap.value( &part );
// Adjust partition size based on available space
if ( size > availableSize )
// Adjust partition size based on available space.
qint64 sectors = partSectorsMap.value( &entry );
sectors = std::min( sectors, availableSectors );
if ( sectors == 0 )
{
size = availableSize;
continue;
}
end = firstSector + std::max( size - 1, Q_INT64_C( 0 ) );
Partition* part = nullptr;
if ( luksPassphrase.isEmpty() )
{
currentPartition = KPMHelpers::createNewPartition(
parent, *dev, role, part.partFileSystem, firstSector, end, KPM_PARTITION_FLAG( None ) );
part = KPMHelpers::createNewPartition(
parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, KPM_PARTITION_FLAG( None ) );
}
else
{
currentPartition = KPMHelpers::createNewEncryptedPartition(
parent, *dev, role, part.partFileSystem, firstSector, end, luksPassphrase, KPM_PARTITION_FLAG( None ) );
part = KPMHelpers::createNewEncryptedPartition(
parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, luksPassphrase, KPM_PARTITION_FLAG( None ) );
}
PartitionInfo::setFormat( currentPartition, true );
PartitionInfo::setMountPoint( currentPartition, part.partMountPoint );
if ( !part.partLabel.isEmpty() )
PartitionInfo::setFormat( part, true );
PartitionInfo::setMountPoint( part, entry.partMountPoint );
if ( !entry.partLabel.isEmpty() )
{
currentPartition->setLabel( part.partLabel );
currentPartition->fileSystem().setLabel( part.partLabel );
part->setLabel( entry.partLabel );
part->fileSystem().setLabel( entry.partLabel );
}
if ( !part.partUUID.isEmpty() )
if ( !entry.partUUID.isEmpty() )
{
currentPartition->setUUID( part.partUUID );
part->setUUID( entry.partUUID );
}
if ( !part.partType.isEmpty() )
if ( !entry.partType.isEmpty() )
{
#if defined( WITH_KPMCORE42API )
currentPartition->setType( part.partType );
part->setType( entry.partType );
#else
cWarning() << "Ignoring type; requires KPMcore >= 4.2.0.";
#endif
}
if ( part.partAttributes )
if ( entry.partAttributes )
{
#if defined( WITH_KPMCORE42API )
currentPartition->setAttributes( part.partAttributes );
part->setAttributes( entry.partAttributes );
#else
cWarning() << "Ignoring attributes; requires KPMcore >= 4.2.0.";
#endif
}
if ( !part.partFeatures.isEmpty() )
if ( !entry.partFeatures.isEmpty() )
{
#if defined( WITH_KPMCORE42API )
for ( const auto& k : part.partFeatures.keys() )
for ( const auto& k : entry.partFeatures.keys() )
{
currentPartition->fileSystem().addFeature( k, part.partFeatures.value( k ) );
part->fileSystem().addFeature( k, entry.partFeatures.value( k ) );
}
#else
cWarning() << "Ignoring features; requires KPMcore >= 4.2.0.";
@ -333,9 +306,9 @@ PartitionLayout::execute( Device* dev,
}
// Some buggy (legacy) BIOSes test if the bootflag of at least one partition is set.
// Otherwise they ignore the device in boot-order, so add it here.
partList.append( currentPartition );
firstSector = end + 1;
availableSize -= size;
partList.append( part );
currentSector += sectors;
availableSectors -= sectors;
}
return partList;

50
src/modules/partition/core/PartitionLayout.h
Unescape Escape View File

@ -44,8 +44,24 @@ public:
/// @brief All-zeroes PartitionEntry
PartitionEntry();
/// @brief Parse @p size, @p min and @p max to their respective member variables
PartitionEntry( const QString& size, const QString& min, const QString& max );
/// @brief Parse @p mountPoint, @p size, @p minSize and @p maxSize to their respective member variables
PartitionEntry( const QString& mountPoint,
const QString& size,
const QString& minSize = QString(),
const QString& maxSize = QString() );
/// @brief All-field PartitionEntry
PartitionEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& minSize = QString(),
const QString& maxSize = QString() );
/// @brief Copy PartitionEntry
PartitionEntry( const PartitionEntry& e );
bool isValid() const
{
@ -59,36 +75,22 @@ public:
};
PartitionLayout();
PartitionLayout( PartitionEntry entry );
PartitionLayout( const PartitionLayout& layout );
~PartitionLayout();
bool addEntry( PartitionEntry entry );
bool addEntry( const QString& mountPoint,
const QString& size,
const QString& min = QString(),
const QString& max = QString() );
bool addEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& min = QString(),
const QString& max = QString() );
void init( const QVariantList& config );
bool addEntry( const PartitionEntry& entry );
/**
* @brief Apply the current partition layout to the selected drive space.
* @return A list of Partition objects.
*/
QList< Partition* > execute( Device* dev,
qint64 firstSector,
qint64 lastSector,
QString luksPassphrase,
PartitionNode* parent,
const PartitionRole& role );
QList< Partition* > createPartitions( Device* dev,
qint64 firstSector,
qint64 lastSector,
QString luksPassphrase,
PartitionNode* parent,
const PartitionRole& role );
private:
FileSystem::Type m_defaultFsType;

9
src/modules/partition/gui/PartitionViewStep.cpp
Unescape Escape View File

@ -596,14 +596,7 @@ PartitionViewStep::setConfigurationMap( const QVariantMap& configurationMap )
QFuture< void > future = QtConcurrent::run( this, &PartitionViewStep::initPartitionCoreModule );
m_future->setFuture( future );
if ( configurationMap.contains( "partitionLayout" ) )
{
m_core->initLayout( configurationMap.value( "partitionLayout" ).toList() );
}
else
{
m_core->initLayout();
}
m_core->initLayout( configurationMap.value( "partitionLayout" ).toList() );
}

14
src/modules/partition/partition.conf
Unescape Escape View File

@ -154,7 +154,19 @@ defaultFileSystemType: "ext4"
# If nothing is specified, LUKS is enabled in automated modes.
#enableLuksAutomatedPartitioning: true
# To apply a custom partition layout, it has to be defined this way :
# Partition layout.
#
# This optional setting specifies a custom partition layout.
#
# If nothing is specified, the default partition layout is a single partition
# for root that uses 100% of the space and uses the filesystem defined by
# defaultFileSystemType.
#
# Note: the EFI system partition is prepend automatically to the layout if
# needed; the swap partition is appended to the layout if enabled (small of
# suspend).
#
# Otherwise, the partition layout is defined as follow:
#
# partitionLayout:
# - name: "rootfs"

16
src/modules/partition/tests/CreateLayoutsTests.cpp
Unescape Escape View File

@ -61,12 +61,12 @@ CreateLayoutsTests::testFixedSizePartition()
PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) )
if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
{
QFAIL( qPrintable( "Unable to create / partition" ) );
}
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 1 );
@ -81,12 +81,12 @@ CreateLayoutsTests::testPercentSizePartition()
PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "50%" ) ) )
if ( !layout.addEntry( { QString( "/" ), QString( "50%" ) } ) )
{
QFAIL( qPrintable( "Unable to create / partition" ) );
}
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 1 );
@ -101,22 +101,22 @@ CreateLayoutsTests::testMixedSizePartition()
PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) )
if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
{
QFAIL( qPrintable( "Unable to create / partition" ) );
}
if ( !layout.addEntry( QString( "/home" ), QString( "50%" ) ) )
if ( !layout.addEntry( { QString( "/home" ), QString( "50%" ) } ) )
{
QFAIL( qPrintable( "Unable to create /home partition" ) );
}
if ( !layout.addEntry( QString( "/bkup" ), QString( "50%" ) ) )
if ( !layout.addEntry( { QString( "/bkup" ), QString( "50%" ) } ) )
{
QFAIL( qPrintable( "Unable to create /bkup partition" ) );
}
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 3 );

Write Preview
Loading…
Cancel
Save