diff --git a/src/dfm-base/file/local/localdiriterator.cpp b/src/dfm-base/file/local/localdiriterator.cpp index 941ab40003..5eab75f4cf 100644 --- a/src/dfm-base/file/local/localdiriterator.cpp +++ b/src/dfm-base/file/local/localdiriterator.cpp @@ -27,10 +27,6 @@ LocalDirIteratorPrivate::LocalDirIteratorPrivate(const QUrl &url, const QStringL dfmioDirIterator.reset(new DFMIO::DEnumerator(urlReally, nameFilters, static_cast(static_cast(filters)), static_cast(static_cast(flags)))); - if (!dfmioDirIterator) { - qWarning("Failed dfm-io use factory create enumerator"); - abort(); - } } LocalDirIteratorPrivate::~LocalDirIteratorPrivate() @@ -59,11 +55,11 @@ FileInfoPointer LocalDirIteratorPrivate::fileInfo() } auto infoTrans = InfoFactory::transfromInfo(url.scheme(), info); - infoTrans->setExtendedAttributes(ExtInfoType::kFileIsHid, isHidden); - infoTrans->setExtendedAttributes(ExtInfoType::kFileLocalDevice, isLocalDevice); - infoTrans->setExtendedAttributes(ExtInfoType::kFileCdRomDevice, isCdRomDevice); if (infoTrans) { + infoTrans->setExtendedAttributes(ExtInfoType::kFileIsHid, isHidden); + infoTrans->setExtendedAttributes(ExtInfoType::kFileLocalDevice, isLocalDevice); + infoTrans->setExtendedAttributes(ExtInfoType::kFileCdRomDevice, isCdRomDevice); emit InfoCacheController::instance().removeCacheFileInfo({url}); emit InfoCacheController::instance().cacheFileInfo(url, infoTrans); } else { diff --git a/src/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperationutils/fileoperatebaseworker.cpp b/src/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperationutils/fileoperatebaseworker.cpp index cc2fa14603..75aec255f3 100644 --- a/src/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperationutils/fileoperatebaseworker.cpp +++ b/src/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperationutils/fileoperatebaseworker.cpp @@ -553,7 +553,6 @@ bool FileOperateBaseWorker::doCheckNewFile(const FileInfoPointer &fromInfo, cons if (action != AbstractJobHandler::SupportAction::kEnforceAction) { setSkipValue(skip, action); if (skip && *skip) - workData->skipWriteSize += isCountSize && (fromInfo->isAttributes(OptInfoType::kIsSymLink) || fromInfo->size() <= 0) ? workData->dirSize : fromInfo->size(); return false; } @@ -684,7 +683,7 @@ bool FileOperateBaseWorker::checkAndCopyDir(const FileInfoPointer &fromInfo, con const QUrl &url = iterator->next(); const FileInfoPointer &info = InfoFactory::create(url, Global::CreateFileInfoType::kCreateFileInfoSync); bool ok = doCopyFile(info, toInfo, skip); - if (!ok && !skip) { + if (!ok && (!skip || !*skip)) { return false; } } diff --git a/tests/dfm-base/file/local/ut_desktopfileinfo.cpp b/tests/dfm-base/file/local/ut_desktopfileinfo.cpp new file mode 100644 index 0000000000..6c80f261de --- /dev/null +++ b/tests/dfm-base/file/local/ut_desktopfileinfo.cpp @@ -0,0 +1,191 @@ +// SPDX-FileCopyrightText: 2021 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#ifndef UT_DESKTOPFILEINFO +#define UT_DESKTOPFILEINFO + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +DFMBASE_USE_NAMESPACE + +class UT_DesktopFileInfo : public testing::Test +{ +public: + virtual void SetUp() override + { + // 注册路由 + UrlRoute::regScheme(dfmbase::Global::Scheme::kFile, "/", QIcon(), false, QObject::tr("System Disk")); + } + + virtual void TearDown() override + { + } + + ~UT_DesktopFileInfo() override {} +}; + + +TEST_F(UT_DesktopFileInfo, testDesktopFileInfo) +{ + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + InfoFactory::instance().constructList.clear(); + DesktopFileInfo info(url); + QSharedPointer dfileinfo (new dfmio::DFileInfo(url)); + EXPECT_TRUE(info.proxy.isNull()); + + InfoFactory::regClass(Global::Scheme::kFile); + DesktopFileInfo info1(url); + EXPECT_FALSE(info1.proxy.isNull()); +} + +TEST_F(UT_DesktopFileInfo, testDesktopName) +{ + InfoFactory::regClass(Global::Scheme::kFile); + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + stub_ext::StubExt stub; + stub.set_lamda(&DesktopFile::desktopDeepinVendor, []{ __DBG_STUB_INVOKE__ return QString("deepin");}); + stub.set_lamda(&DesktopFile::desktopDisplayName, []{ __DBG_STUB_INVOKE__ return QString("deepin");}); + DesktopFileInfo info(url); + QSharedPointer dfileinfo (new dfmio::DFileInfo(url)); + stub.set_lamda(VADDR(ProxyFileInfo, refresh), []{ __DBG_STUB_INVOKE__ }); + EXPECT_EQ(QString("deepin"), info.desktopName()); + + stub.set_lamda(&DesktopFile::desktopDisplayName, []{ __DBG_STUB_INVOKE__ return QString("");}); + stub.set_lamda(&DesktopFile::desktopLocalName, []{ __DBG_STUB_INVOKE__ return QString("deepin");}); + info.refresh(); + EXPECT_EQ(QString("deepin"), info.desktopName()); + + EXPECT_TRUE(info.desktopExec().isEmpty()); + EXPECT_TRUE(info.desktopIconName().isEmpty()); + EXPECT_FALSE(info.desktopType().isEmpty()); + EXPECT_TRUE(info.desktopCategories().isEmpty()); + + stub.set_lamda(&DesktopFile::desktopIcon, []{ __DBG_STUB_INVOKE__ return QString("user-trash");}); + stub.set_lamda(&FileUtils::trashIsEmpty, []{ __DBG_STUB_INVOKE__ return false;}); + info.refresh(); + EXPECT_EQ(QString("user-trash-full"), info.desktopIconName()); +} + +TEST_F(UT_DesktopFileInfo, testDesktopFileInfoNameOf) +{ + InfoFactory::regClass(Global::Scheme::kFile); + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + stub_ext::StubExt stub; + DesktopFileInfo info(url); + stub.set_lamda(&DesktopFileInfo::desktopName, []{ __DBG_STUB_INVOKE__ return QString("eee");}); + EXPECT_EQ(QString("eee"), info.displayOf(DisPlayInfoType::kFileDisplayName)); + + stub.set_lamda(&DesktopFileInfo::desktopName, []{ __DBG_STUB_INVOKE__ return QString("");}); + stub.set_lamda(VADDR(ProxyFileInfo, displayOf), []{ __DBG_STUB_INVOKE__ return QString("eeee");}); + EXPECT_EQ(QString("eeee"), info.displayOf(DisPlayInfoType::kFileDisplayName)); + + stub.set_lamda(VADDR(DesktopFileInfo, displayOf), []{ __DBG_STUB_INVOKE__ return QString("display");}); + EXPECT_EQ(QString("display"), info.nameOf(NameInfoType::kFileNameOfRename)); + EXPECT_EQ(QString("display"), info.nameOf(NameInfoType::kBaseNameOfRename)); + EXPECT_TRUE(info.nameOf(NameInfoType::kSuffixOfRename).isEmpty()); + + stub.set_lamda(VADDR(ProxyFileInfo, nameOf), []{ __DBG_STUB_INVOKE__ return QString("nameOf");}); + + EXPECT_EQ(QString("nameOf"), info.nameOf(NameInfoType::kFileCopyName)); + EXPECT_TRUE(info.nameOf(NameInfoType::kIconName).isEmpty()); + EXPECT_EQ(QString("application-default-icon"), info.nameOf(NameInfoType::kGenericIconName)); + EXPECT_EQ(QString("nameOf"), info.nameOf(NameInfoType::kMimeTypeName)); +} + +TEST_F(UT_DesktopFileInfo, testDesktopFileInfoSupportedOfAttributes) +{ + InfoFactory::regClass(Global::Scheme::kFile); + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + stub_ext::StubExt stub; + stub.set_lamda(&DesktopFile::desktopDeepinId, []{ __DBG_STUB_INVOKE__ return QString("dde-computer");}); + DesktopFileInfo info(url); + + EXPECT_FALSE(info.canTag()); + + EXPECT_EQ(Qt::IgnoreAction, info.supportedOfAttributes(SupportedType::kDrag)); + stub.set_lamda(VADDR(ProxyFileInfo, supportedOfAttributes), []{ __DBG_STUB_INVOKE__ return Qt::MoveAction;}); + + EXPECT_EQ(Qt::MoveAction, info.supportedOfAttributes(SupportedType::kDrop)); + + stub.set_lamda(&DesktopFile::desktopDeepinId, []{ __DBG_STUB_INVOKE__ return QString("dde-file-manager");}); + stub.set_lamda(VADDR(ProxyFileInfo, refresh), []{ __DBG_STUB_INVOKE__ }); + stub.set_lamda(&DesktopFile::desktopExec, []{ __DBG_STUB_INVOKE__ return QString("dd -O dd");}); + info.refresh(); + EXPECT_FALSE(info.canTag()); + + stub.set_lamda(&DesktopFile::desktopExec, []{ __DBG_STUB_INVOKE__ return QString("dd");}); + info.refresh(); + EXPECT_TRUE(info.canTag()); +} + +TEST_F(UT_DesktopFileInfo, testDesktopFileInfoCanAttributes) +{ + InfoFactory::regClass(Global::Scheme::kFile); + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + stub_ext::StubExt stub; + stub.set_lamda(&DesktopFile::desktopDeepinId, []{ __DBG_STUB_INVOKE__ return QString("dde-computer");}); + DesktopFileInfo info(url); + + EXPECT_FALSE(info.canAttributes(CanableInfoType::kCanMoveOrCopy)); + EXPECT_FALSE(info.canAttributes(CanableInfoType::kCanDrop)); + + stub.set_lamda(&DesktopFile::desktopDeepinId, []{ __DBG_STUB_INVOKE__ return QString("dde-file-manager");}); + stub.set_lamda(VADDR(ProxyFileInfo, refresh), []{ __DBG_STUB_INVOKE__ }); + stub.set_lamda(&DesktopFile::desktopExec, []{ __DBG_STUB_INVOKE__ return QString("dd -O dd");}); + info.refresh(); + EXPECT_FALSE(info.canAttributes(CanableInfoType::kCanMoveOrCopy)); + + stub.set_lamda(&DesktopFile::desktopExec, []{ __DBG_STUB_INVOKE__ return QString("dd");}); + info.refresh(); + EXPECT_TRUE(info.canAttributes(CanableInfoType::kCanMoveOrCopy)); + + stub.set_lamda(VADDR(ProxyFileInfo, canAttributes), []{ __DBG_STUB_INVOKE__ return true;}); + EXPECT_TRUE(info.canAttributes(CanableInfoType::kCanDrop)); + EXPECT_TRUE(info.canAttributes(CanableInfoType::kCanDragCompress)); +} + +TEST_F(UT_DesktopFileInfo, testDesktopFileInfoFileIcon) +{ + InfoFactory::regClass(Global::Scheme::kFile); + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + stub_ext::StubExt stub; + DesktopFileInfo info(url); + + stub.set_lamda(&QIcon::isNull, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&QIcon::availableSizes, []{ __DBG_STUB_INVOKE__ QList list; list.append(QSize()); return list;}); + EXPECT_TRUE(info.fileIcon().name().isEmpty()); + + stub.reset(&QIcon::availableSizes); + EXPECT_TRUE(info.fileIcon().name().isEmpty()); + + stub.clear(); + stub.set_lamda(VADDR(DesktopFileInfo, nameOf), []{ __DBG_STUB_INVOKE__ return "data:image/ooooooo;jjj";}); + typedef int (QString::*IndexOfFunc)(const QString &, int from, Qt::CaseSensitivity) const; + stub.set_lamda(static_cast(&QString::indexOf), []{ __DBG_STUB_INVOKE__ return 12;}); + typedef bool(QPixmap::*LoadFromData)(const QByteArray &, const char *, Qt::ImageConversionFlags); + stub.set_lamda(static_cast(&QPixmap::loadFromData), []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(VADDR(ProxyFileInfo, fileIcon), []{ __DBG_STUB_INVOKE__ return QIcon();}); + EXPECT_TRUE(info.fileIcon().name().isEmpty()); + + stub.set_lamda(static_cast(&QPixmap::loadFromData), []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(info.fileIcon().name().isEmpty()); + + stub.set_lamda(VADDR(DesktopFileInfo, nameOf), []{ __DBG_STUB_INVOKE__ return "~";}); + stub.set_lamda(VADDR(DesktopFileInfo, pathOf), []{ __DBG_STUB_INVOKE__ return QDir::currentPath();}); + EXPECT_FALSE(info.fileIcon().name().isEmpty()); +} + +#endif diff --git a/tests/dfm-base/file/local/ut_localfilediriterator.cpp b/tests/dfm-base/file/local/ut_localfilediriterator.cpp index d84778dece..e5121293e3 100644 --- a/tests/dfm-base/file/local/ut_localfilediriterator.cpp +++ b/tests/dfm-base/file/local/ut_localfilediriterator.cpp @@ -2,10 +2,17 @@ // // SPDX-License-Identifier: GPL-3.0-or-later -#ifndef UT_ABSTRACTFILEWATCHER -#define UT_ABSTRACTFILEWATCHER +#ifndef UT_LOCALFILEWATCHER +#define UT_LOCALFILEWATCHER +#include #include +#include +#include +#include +#include + +#include #include @@ -44,6 +51,14 @@ TEST_F(UT_LocalFileDirIterator, testLocalFileIterator) auto fileUrl = QUrl::fromLocalFile(url.path() + QDir::separator() + "testAsyncFileInfo.txt"); EXPECT_EQ(fileUrl, iterator->next()); EXPECT_TRUE(!iterator->fileInfo().isNull()); + stub_ext::StubExt stub; + stub.set_lamda(&dfmio::DFileInfo::attribute, []{ __DBG_STUB_INVOKE__ return ".testOOOOOO.txt";}); + stub.set_lamda(&FileUtils::isLocalDevice, []{ __DBG_STUB_INVOKE__ return false;}); + typedef FileInfoPointer (*TransfromInfo)(const QString &, FileInfoPointer); + stub.set_lamda(static_cast(&dfmbase::InfoFactory::transfromInfo), []{ __DBG_STUB_INVOKE__ return nullptr;}); + stub.set_lamda(&AsyncFileInfo::cacheAsyncAttributes, []{ __DBG_STUB_INVOKE__ }); + EXPECT_TRUE(iterator->fileInfo().isNull()); + EXPECT_EQ(fileUrl, iterator->fileUrl()); EXPECT_EQ("testAsyncFileInfo.txt", iterator->fileName()); EXPECT_EQ(url, iterator->url()); @@ -74,4 +89,28 @@ TEST_F(UT_LocalFileDirIterator, testLocalFileIterator) QProcess::execute("fm -rf ./testAsyncFileInfo"); } +TEST_F(UT_LocalFileDirIterator, testLocalFileIteratorOther) +{ + LocalDirIterator iterator(QUrl("recent:///ddd.txt")); + + EXPECT_FALSE(iterator.initIterator()); + + iterator.d->dfmioDirIterator = nullptr; + EXPECT_FALSE(iterator.hasNext()); + EXPECT_FALSE(iterator.url().isValid()); + QVariantMap args; + iterator.setArguments(args); + EXPECT_TRUE(iterator.sortFileInfoList().isEmpty()); + EXPECT_TRUE(iterator.oneByOne()); + EXPECT_FALSE(iterator.initIterator()); + EXPECT_TRUE(iterator.asyncIterator() == nullptr); + stub_ext::StubExt stub; + stub.set_lamda(VADDR(LocalDirIterator, fileUrl), []{ __DBG_STUB_INVOKE__ return QUrl();}); + EXPECT_TRUE(iterator.fileName().isEmpty()); + stub.set_lamda(VADDR(LocalDirIterator, fileUrl), []{ __DBG_STUB_INVOKE__ return QUrl("file:////");}); + EXPECT_TRUE(iterator.fileName().isEmpty()); + stub.set_lamda(VADDR(LocalDirIterator, fileUrl), []{ __DBG_STUB_INVOKE__ return QUrl("file:///tttt/");}); + EXPECT_TRUE(iterator.fileName() == QString("tttt")); +} + #endif diff --git a/tests/dfm-base/file/local/ut_localfileiconprivder.cpp b/tests/dfm-base/file/local/ut_localfileiconprivder.cpp new file mode 100644 index 0000000000..6b698fcf19 --- /dev/null +++ b/tests/dfm-base/file/local/ut_localfileiconprivder.cpp @@ -0,0 +1,48 @@ +// SPDX-FileCopyrightText: 2021 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#ifndef UT_LOCALILEICONPRIVDER +#define UT_LOCALILEICONPRIVDER + +#include +#include + +#include + +#include + +#include + +DFMBASE_USE_NAMESPACE + +class UT_LocalFileIconProvider : public testing::Test +{ +public: + virtual void SetUp() override + { + } + + virtual void TearDown() override + { + } + + ~UT_LocalFileIconProvider() override; +}; + +UT_LocalFileIconProvider::~UT_LocalFileIconProvider() { + +} + +TEST_F(UT_LocalFileIconProvider, testLocalFileIconProvider) +{ + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + LocalFileIconProvider *privder = LocalFileIconProvider::globalProvider(); + QFileInfo info(url.path()); + EXPECT_TRUE(privder->icon(info).name().isEmpty()); + + QString iconName("test"); + EXPECT_TRUE(privder->icon(iconName).isNull()); +} + +#endif diff --git a/tests/dfm-base/file/local/ut_localfilewatcher.cpp b/tests/dfm-base/file/local/ut_localfilewatcher.cpp index c0416b5bcf..b7585801bb 100644 --- a/tests/dfm-base/file/local/ut_localfilewatcher.cpp +++ b/tests/dfm-base/file/local/ut_localfilewatcher.cpp @@ -2,10 +2,14 @@ // // SPDX-License-Identifier: GPL-3.0-or-later -#ifndef UT_ABSTRACTFILEWATCHER -#define UT_ABSTRACTFILEWATCHER +#ifndef UT_LOCALFILEWATCHER +#define UT_LOCALFILEWATCHER +#include #include +#include + +#include #include @@ -52,6 +56,14 @@ TEST_F(UT_LocalFileWatcher, testLocalFileWatcher) EXPECT_TRUE(watcher->stopWatcher()); EXPECT_FALSE(watcher->stopWatcher()); + LocalFileWatcherPrivate * watherDptr = static_cast(watcher->d.data()); + stub_ext::StubExt stub; + stub.set_lamda(&dfmio::DWatcher::start, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(watherDptr->start()); + watherDptr->watcher = nullptr; + + EXPECT_FALSE(watherDptr->start()); + EXPECT_FALSE(watherDptr->stop()); } #endif diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackfileworker.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackfileworker.cpp index 5f6f1c31c6..6177109479 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackfileworker.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackfileworker.cpp @@ -123,6 +123,13 @@ TEST_F(UT_AbstractWorker, testStatisticsFilesSize) stub.set_lamda(&FileOperationsUtils::isFileOnDisk, []{ __DBG_STUB_INVOKE__ return false;}); EXPECT_TRUE(worker.statisticsFilesSize()); + worker.onStatisticsFilesSizeFinish(); + worker.currentState = AbstractJobHandler::JobState::kStartState; + EXPECT_TRUE(worker.stateCheck()); + + worker.workData->signalThread = false; + worker.retry = true; + worker.checkRetry(); } TEST_F(UT_AbstractWorker, testsCurrentTaskNotifyAndStop) @@ -146,9 +153,10 @@ TEST_F(UT_AbstractWorker, testsCurrentTaskNotifyAndStop) worker.threadCopyWorker.append(copy); } stub.set_lamda(&DoCopyFileWorker::pause, []{ __DBG_STUB_INVOKE__ }); + worker.copyOtherFileWorker.reset(new DoCopyFileWorker(worker.workData)); worker.pauseAllThread(); - worker.copyOtherFileWorker.reset(new DoCopyFileWorker(worker.workData)); + worker.resumeAllThread(); worker.resumeThread({quintptr(&worker)}); worker.checkRetry(); @@ -158,7 +166,11 @@ TEST_F(UT_AbstractWorker, testsCurrentTaskNotifyAndStop) worker.stopAllThread(); EXPECT_FALSE(worker.stateCheck()); worker.onStatisticsFilesSizeUpdate(100); - + stub.set_lamda(VADDR(AbstractWorker, initArgs), []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.doWork()); + stub.set_lamda(VADDR(AbstractWorker, initArgs), []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(VADDR(AbstractWorker,statisticsFilesSize), []{ __DBG_STUB_INVOKE__ return true;}); + EXPECT_TRUE(worker.doWork()); } TEST_F(UT_AbstractWorker, testsformatFileName) @@ -201,6 +213,8 @@ TEST_F(UT_AbstractWorker, testSaveOperations) worker.completeSourceFiles.append(url); worker.jobType = AbstractJobHandler::JobType::kCopyType; worker.saveOperations(); + worker.sourceUrls.append(QUrl()); + stub.set_lamda(&FileUtils::isTrashFile, []{ __DBG_STUB_INVOKE__ return true;}); worker.jobType = AbstractJobHandler::JobType::kCutType; worker.saveOperations(); worker.jobType = AbstractJobHandler::JobType::kMoveToTrashType; @@ -209,6 +223,9 @@ TEST_F(UT_AbstractWorker, testSaveOperations) worker.saveOperations(); worker.jobType = AbstractJobHandler::JobType::kDeleteType; worker.saveOperations(); + worker.jobType = AbstractJobHandler::JobType::kUnknow; + worker.saveOperations(); + worker.jobType = AbstractJobHandler::JobType::kDeleteType; worker.doOperateWork(AbstractJobHandler::SupportAction::kStopAction); EXPECT_EQ(AbstractJobHandler::JobState::kStopState, worker.currentState); @@ -237,9 +254,8 @@ TEST_F(UT_AbstractWorker, testSaveOperations) stub.set_lamda(&DFMBASE_NAMESPACE::FileStatisticsJob::stop, []{ __DBG_STUB_INVOKE__ }); worker.updateProgressThread.reset(new QThread); stub.set_lamda(&QThread::quit, []{ __DBG_STUB_INVOKE__ }); - stub.set_lamda(&QThread::wait, []{ __DBG_STUB_INVOKE__ return true;}); + worker.updateProgressTimer.reset(new UpdateProgressTimer); worker.stop(); worker.onUpdateProgress(); - } diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackjob.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackjob.cpp index ca59433c07..59245a9978 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackjob.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_abstrackjob.cpp @@ -42,17 +42,40 @@ TEST_F(UT_AbstractJob, testAbstractJob) job.setJobArgs(handle, {}); job.operateAation(AbstractJobHandler::SupportAction::kStartAction); + job.operateAation(AbstractJobHandler::SupportAction::kResumAction); job.operateAation(AbstractJobHandler::SupportAction::kCancelAction); JobInfoPointer info(new QMap); job.errorQueue.enqueue(info); + job.errorQueue.enqueue(info); job.operateAation(AbstractJobHandler::SupportAction::kSkipAction); - info->insert(AbstractJobHandler::NotifyInfoKey::kWorkerPointer, quintptr(job.doWorker.data())); job.errorQueue.enqueue(info); job.errorQueue.enqueue(info); + + job.operateAation(AbstractJobHandler::SupportAction::kRetryAction); + info->insert(AbstractJobHandler::NotifyInfoKey::kWorkerPointer, quintptr(job.doWorker.data())); + + job.handleError(info); + job.errorQueue.enqueue(info); + JobInfoPointer info1(new QMap); + info1->insert(AbstractJobHandler::NotifyInfoKey::kWorkerPointer, quintptr(job.doWorker.data())); + info1->insert(AbstractJobHandler::NotifyInfoKey::kErrorTypeKey, QVariant::fromValue(AbstractJobHandler::JobErrorType::kReadError)); job.handleError(info); + job.handleError(info1); + + JobInfoPointer info2(new QMap); + info2->insert(AbstractJobHandler::NotifyInfoKey::kWorkerPointer, quintptr(job.doWorker.data() - 1)); + info2->insert(AbstractJobHandler::NotifyInfoKey::kErrorTypeKey, QVariant::fromValue(AbstractJobHandler::JobErrorType::kReadError)); + job.handleError(info2); + + job.errorQueue.clear(); + job.handleError(info2); + job.errorQueue.clear(); + job.errorQueue.enqueue(info); + job.errorQueue.enqueue(info); + EXPECT_EQ(job.errorQueue.size(), 2); job.handleRetryErrorSuccess(quintptr(job.doWorker.data())); diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_docopyfileworker.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_docopyfileworker.cpp index 4ce44e8419..8ed058a077 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_docopyfileworker.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_docopyfileworker.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include @@ -134,6 +135,43 @@ TEST_F(UT_DoCopyFileWorker, testDoCopyFilePractically) QProcess::execute("rm sourceUrl.txt targetUrl.txt"); } +TEST_F(UT_DoCopyFileWorker, testDoDfmioFileCopy) +{ + QSharedPointer data(new WorkerData); + DoCopyFileWorker worker(data); + + worker.stop(); + auto sorceUrl = QUrl::fromLocalFile(QDir::currentPath() + "/sourceUrl.txt"); + auto targetUrl = QUrl::fromLocalFile(QDir::currentPath() + "/targetUrl.txt"); + auto targetInfo = InfoFactory::create(targetUrl); + auto sorceInfo = InfoFactory::create(sorceUrl); + EXPECT_FALSE(worker.doDfmioFileCopy(sorceInfo, targetInfo, nullptr)); + + bool skip{false}; + worker.resume(); + stub_ext::StubExt stub; + stub.set_lamda(&DoCopyFileWorker::readAheadSourceFile, []{ __DBG_STUB_INVOKE__ }); + stub.set_lamda(&DoCopyFileWorker::stateCheck, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.doDfmioFileCopy(sorceInfo, targetInfo, &skip)); + + stub.set_lamda(&DoCopyFileWorker::stateCheck, []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(&FileUtils::isMtpFile, []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(&DOperator::copyFile, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&DoCopyFileWorker::doHandleErrorAndWait,[]{ + __DBG_STUB_INVOKE__ + return AbstractJobHandler::SupportAction::kSkipAction; + }); + stub.set_lamda(&DoCopyFileWorker::actionOperating, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&DoCopyFileWorker::syncBlockFile, []{ __DBG_STUB_INVOKE__ }); + EXPECT_FALSE(worker.doDfmioFileCopy(sorceInfo, targetInfo, &skip)); + + DoCopyFileWorker::ProgressData *datatt {new DoCopyFileWorker::ProgressData()}; + datatt->data = worker.workData; + datatt->copyFile = sorceUrl; + DoCopyFileWorker::progressCallback(0, 0, datatt); + delete datatt; +} + TEST_F(UT_DoCopyFileWorker, testActionOperating) { QSharedPointer data(new WorkerData); @@ -166,10 +204,11 @@ TEST_F(UT_DoCopyFileWorker, testDoHandleErrorAndWait) auto sorceUrl = QUrl::fromLocalFile(QDir::currentPath() + "/sourceUrl.txt"); auto targetUrl = QUrl::fromLocalFile(QDir::currentPath() + "/targetUrl.txt"); worker.stop(); + stub_ext::StubExt stub; + stub.set_lamda(&FileUtils::isSameFile, []{__DBG_STUB_INVOKE__ return false;}); EXPECT_EQ(worker.doHandleErrorAndWait(sorceUrl, targetUrl, AbstractJobHandler::JobErrorType::kNoSourceError), AbstractJobHandler::SupportAction::kCancelAction); - stub_ext::StubExt stub; stub.set_lamda(static_cast(&QWaitCondition::wait), []{ __DBG_STUB_INVOKE__ return false;}); EXPECT_FALSE(worker.stateCheck()); diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_errormessageandaction.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_errormessageandaction.cpp index f9491575a7..2f20640b0c 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_errormessageandaction.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_errormessageandaction.cpp @@ -91,23 +91,24 @@ TEST_F(UT_ErrorMessageAndAction, testSupportActions) TEST_F(UT_ErrorMessageAndAction, testErrorSrcAndDestString) { QString sorceMsg, toMsg; - EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), nullptr, nullptr)); - EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), nullptr, nullptr, AbstractJobHandler::JobErrorType::kOpenError)); - EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), &sorceMsg, nullptr, AbstractJobHandler::JobErrorType::kOpenError)); EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), &sorceMsg, nullptr, AbstractJobHandler::JobErrorType::kOpenError)); + EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kDirectoryExistsError)); + EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kDirectoryExistsError)); EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl(), QUrl(), &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kOpenError)); - EXPECT_TRUE(sorceMsg.isEmpty()); - EXPECT_TRUE(toMsg.isEmpty()); + EXPECT_FALSE(sorceMsg.isEmpty()); + EXPECT_FALSE(toMsg.isEmpty()); + QString srcmsg; + ErrorMessageAndAction::srcAndDestString(QUrl(), QUrl(), &srcmsg, nullptr, AbstractJobHandler::JobType::kCopyType, AbstractJobHandler::JobErrorType::kDirectoryExistsError); EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl("file:///home/kjfsdakjdfjkashdjkfhasjkdfhajksdfjaksdfhjksdhnfkjsdfhjksadjfhaksjdfhkjs"), - QUrl(), &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kOpenError)); + QUrl(), &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kDirectoryExistsError)); EXPECT_NO_FATAL_FAILURE(ErrorMessageAndAction::errorSrcAndDestString(QUrl("file:///home/kjfsdakjdfjkashdjkfhasjkdfhajksdfjaksdfhjksdhnfkjsdfhjksadjfhaksjdfhkjs"), - QUrl("file:///home/kjfsdakjdfjkashdjkfhasjkdfhajksdfjaksdfhjksdhnfkjsdfhjksadjfhaksjdfhkjs"), - &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kOpenError)); + QUrl("file:///home/kjfsdakjdfjkashdjkfhasjkdfhajksdfjaksdfhjksdhnfkjsdfhjksadjfhaksjdfhkjs/tees"), + &sorceMsg, &toMsg, AbstractJobHandler::JobErrorType::kDirectoryExistsError)); - EXPECT_TRUE(sorceMsg.isEmpty()); - EXPECT_TRUE(toMsg.isEmpty()); + EXPECT_FALSE(sorceMsg.isEmpty()); + EXPECT_FALSE(toMsg.isEmpty()); } TEST_F(UT_ErrorMessageAndAction, testErrorToString) @@ -124,6 +125,7 @@ TEST_F(UT_ErrorMessageAndAction, testErrorToString) EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kCreateParentDirError).endsWith(url.path())); EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kRemoveError).endsWith(url.path())); EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kDeleteFileError).endsWith(url.path())); + EXPECT_TRUE(!ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kFileMoveToTrashError).isEmpty()); EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kRenameError).endsWith(url.path())); EXPECT_TRUE(!ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kNonexistenceError).isEmpty()); EXPECT_TRUE(!ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kFileSizeTooBigError).isEmpty()); @@ -138,6 +140,7 @@ TEST_F(UT_ErrorMessageAndAction, testErrorToString) EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kFailedParseUrlOfTrash) == QObject::tr("Failed to parse the url of trash")); EXPECT_FALSE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kFailedObtainTrashOriginalFile) == QObject::tr("Failed to obtain the trash original file")); EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kUnknowError).isEmpty()); + EXPECT_TRUE(ErrorMessageAndAction::errorToString(url, AbstractJobHandler::JobErrorType::kDfmIoError) == QObject::tr("Copy or Cut File failed!")); } TEST_F(UT_ErrorMessageAndAction, testErrorToStringByCause) @@ -154,6 +157,7 @@ TEST_F(UT_ErrorMessageAndAction, testErrorToStringByCause) EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kCreateParentDirError, "testerror").endsWith("testerror")); EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kRemoveError, "testerror").endsWith("testerror")); EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kDeleteFileError, "testerror").endsWith("testerror")); + EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kFileMoveToTrashError, "testerror").endsWith("testerror")); EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kRenameError, "testerror").endsWith("testerror")); EXPECT_TRUE(!ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kNonexistenceError, "testerror").isEmpty()); EXPECT_TRUE(!ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kFileSizeTooBigError, "testerror").isEmpty()); @@ -165,4 +169,6 @@ TEST_F(UT_ErrorMessageAndAction, testErrorToStringByCause) EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kNotSupportedError, "testerror") == QObject::tr("The action is not supported")); EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kSymlinkError, "testerror").endsWith("testerror")); EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kUnknowError, "testerror").isEmpty()); + EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kDfmIoError, "testerror").endsWith("testerror")); + EXPECT_TRUE(ErrorMessageAndAction::errorToStringByCause(url, AbstractJobHandler::JobErrorType::kDirectoryExistsError, "testerror").endsWith("already exists")); } diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperatebaseworker.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperatebaseworker.cpp index a140f30dff..86d5bf33b0 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperatebaseworker.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperatebaseworker.cpp @@ -136,6 +136,7 @@ TEST_F(UT_FileOperateBaseWorker, testCheckFileSize) worker.workData.reset(new WorkerData); WorkerData::BlockFileCopyInfo info; WorkerData::BlockFileCopyInfo info2(info); + info.buffer = new char[10]; stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction; }); EXPECT_FALSE(worker.checkFileSize(5l * 1024 * 1024 * 1024, url, url, &skip)); @@ -299,6 +300,223 @@ TEST_F(UT_FileOperateBaseWorker, testCopyAndDeleteFile) } +TEST_F(UT_FileOperateBaseWorker, testDoCheckFile) +{ + FileOperateBaseWorker worker; + QUrl url = QUrl::fromLocalFile(QDir::currentPath() + QDir::separator() + "testDoCheckFile.txt"); + auto fromInfo = InfoFactory::create(url); + stub_ext::StubExt stub; + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction;}); + FileInfoPointer newInfo; + EXPECT_FALSE(worker.doCheckFile(nullptr, nullptr, QString(), newInfo, nullptr)); + + EXPECT_FALSE(worker.doCheckFile(fromInfo, nullptr, QString(), newInfo, nullptr)); + + stub.set_lamda(VADDR(SyncFileInfo, exists), []{ __DBG_STUB_INVOKE__ return true;}); + EXPECT_FALSE(worker.doCheckFile(fromInfo, nullptr, QString(), newInfo, nullptr)); + + int index = 0; + stub.set_lamda(VADDR(SyncFileInfo, exists), [&index]{ __DBG_STUB_INVOKE__ index++; return index > 1;}); + EXPECT_FALSE(worker.doCheckFile(fromInfo, fromInfo, QString(), newInfo, nullptr)); + + stub.set_lamda(VADDR(SyncFileInfo, exists), []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(VADDR(SyncFileInfo, fileType), []{ __DBG_STUB_INVOKE__ return FileInfo::FileType::kSocketFile;}); + bool skip(false); + worker.workData.reset(new WorkerData); + EXPECT_FALSE(worker.doCheckFile(fromInfo, fromInfo, QString(), newInfo, &skip)); + + stub.set_lamda(VADDR(SyncFileInfo, fileType), []{ __DBG_STUB_INVOKE__ return FileInfo::FileType::kDocuments;}); + index = 0; + stub.set_lamda(VADDR(SyncFileInfo, exists), [&index]{ __DBG_STUB_INVOKE__ index++; return index < 3;}); + stub.set_lamda(&FileUtils::isTrashFile, []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(&FileOperateBaseWorker::doCheckNewFile, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.doCheckFile(fromInfo, fromInfo, QString(), newInfo, &skip)); +} + +TEST_F(UT_FileOperateBaseWorker, testCreateSystemLink) +{ + FileOperateBaseWorker worker; + QUrl url = QUrl::fromLocalFile(QDir::currentPath() + QDir::separator()); + worker.workData.reset(new WorkerData); + auto fileInfo = InfoFactory::create(url); + bool skip(false); + stub_ext::StubExt stub; + stub.set_lamda(&FileOperateBaseWorker::checkAndCopyFile, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&FileOperateBaseWorker::checkAndCopyDir, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.createSystemLink(fileInfo, nullptr, true, true, &skip)); + + stub.set_lamda(VADDR(SyncFileInfo,isAttributes), [](SyncFileInfo *,OptInfoType type){ __DBG_STUB_INVOKE__ + if (type == OptInfoType::kIsFile) { + return true; + } + return false;}); + EXPECT_FALSE(worker.createSystemLink(fileInfo, nullptr, true, true, &skip)); + + stub.set_lamda(&LocalFileHandler::createSystemLink, []{ __DBG_STUB_INVOKE__ return true;}); + EXPECT_TRUE(worker.createSystemLink(fileInfo, fileInfo, true, false, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction;}); + stub.set_lamda(&LocalFileHandler::createSystemLink, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&LocalFileHandler::errorString, []{ __DBG_STUB_INVOKE__ return QString();}); + EXPECT_FALSE(worker.createSystemLink(fileInfo, fileInfo, true, false, &skip)); +} +bool createNewTargetInfoFunc(FileOperateBaseWorker *&, const FileInfoPointer &fromInfo, const FileInfoPointer &toInfo, + FileInfoPointer &newTargetInfo, const QUrl &fileNewUrl, + bool *skip, bool isCountSize = false){ + newTargetInfo = InfoFactory::create(QUrl::fromLocalFile(QDir::currentPath())); + return false; +} + +TEST_F(UT_FileOperateBaseWorker, testDoCheckNewFile) +{ + FileOperateBaseWorker worker; + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + worker.workData.reset(new WorkerData); + auto fileInfo = InfoFactory::create(url); + bool skip(false); + stub_ext::StubExt stub; + FileInfoPointer newInfo(nullptr); + QString fileBaseName; + stub.set_lamda(&FileOperateBaseWorker::createNewTargetUrl, []{ __DBG_STUB_INVOKE__ return QUrl();}); + stub.set_lamda(&FileOperateBaseWorker::createNewTargetInfo, []{ __DBG_STUB_INVOKE__ return true;}); + EXPECT_TRUE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::createNewTargetInfo, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&FileOperationsUtils::isAncestorUrl, []{ __DBG_STUB_INVOKE__ return true;}); + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction;}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kNoAction;}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set(ADDR(FileOperateBaseWorker, createNewTargetInfo), createNewTargetInfoFunc); + stub.set_lamda(&FileOperationsUtils::isAncestorUrl, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kReplaceAction;}); + stub.set_lamda(&FileOperateBaseWorker::doActionReplace, []{ __DBG_STUB_INVOKE__ return QVariant();}); + EXPECT_TRUE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doActionReplace, []{ __DBG_STUB_INVOKE__ return QVariant(true);}); + EXPECT_TRUE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kCoexistAction;}); + stub.set_lamda(&FileUtils::nonExistFileName, []{ __DBG_STUB_INVOKE__ return QString();}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileUtils::nonExistFileName, []{ __DBG_STUB_INVOKE__ return QString("pp");}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kMergeAction;}); + stub.set_lamda(&FileOperateBaseWorker::doActionMerge, []{ __DBG_STUB_INVOKE__ return QVariant();}); + EXPECT_TRUE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doActionMerge, []{ __DBG_STUB_INVOKE__ return QVariant(true);}); + EXPECT_TRUE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction;}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kCancelAction;}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kNoAction;}); + EXPECT_FALSE(worker.doCheckNewFile(fileInfo, fileInfo, newInfo, fileBaseName, &skip)); +} + +TEST_F(UT_FileOperateBaseWorker, testCheckAndCopyFile) +{ + FileOperateBaseWorker worker; + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + worker.workData.reset(new WorkerData); + auto fileInfo = InfoFactory::create(url); + bool skip(false); + stub_ext::StubExt stub; + stub.set_lamda(&FileOperateBaseWorker::checkFileSize, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.checkAndCopyFile(fileInfo, fileInfo, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::checkFileSize, []{ __DBG_STUB_INVOKE__ return true;}); + worker.jobType = AbstractJobHandler::JobType::kCutType; + stub.set_lamda(&FileOperateBaseWorker::doCopyOtherFile, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.checkAndCopyFile(fileInfo, fileInfo, &skip)); + + worker.jobType = AbstractJobHandler::JobType::kCopyType; + worker.isSourceFileLocal = true; + worker.isTargetFileLocal = true; + worker.workData->signalThread = false; + stub.set_lamda(VADDR(SyncFileInfo, size), []{ __DBG_STUB_INVOKE__ return 100 * 1024 *1024;}); + stub.set_lamda(&FileOperateBaseWorker::doCopyLocalBigFile, []{ __DBG_STUB_INVOKE__ return false;}); + EXPECT_FALSE(worker.checkAndCopyFile(fileInfo, fileInfo, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doCopyLocalFile, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(VADDR(SyncFileInfo, size), []{ __DBG_STUB_INVOKE__ return 1 * 1024 *1024;}); + EXPECT_FALSE(worker.checkAndCopyFile(fileInfo, fileInfo, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doCopyOtherFile, []{ __DBG_STUB_INVOKE__ return false;}); + worker.workData->signalThread = true; + EXPECT_FALSE(worker.checkAndCopyFile(fileInfo, fileInfo, &skip)); +} + +TEST_F(UT_FileOperateBaseWorker, testCheckAndCopyDir) +{ + FileOperateBaseWorker worker; + QUrl url = QUrl::fromLocalFile(QDir::currentPath()); + worker.workData.reset(new WorkerData); + auto fileInfo = InfoFactory::create(url); + bool skip(false); + stub_ext::StubExt stub; + auto toUrl = QUrl::fromLocalFile(QDir::currentPath() + QDir::separator() + "testCheckAndCopyDir"); + auto toInfo = InfoFactory::create(toUrl); + stub.set_lamda(&LocalFileHandler::mkdir, []{ __DBG_STUB_INVOKE__ return false;}); + stub.set_lamda(&LocalFileHandler::errorString, []{ __DBG_STUB_INVOKE__ return QString();}); + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kSkipAction;}); + worker.localFileHandler.reset(new LocalFileHandler); + EXPECT_FALSE(worker.checkAndCopyDir(fileInfo, toInfo, &skip)); + + stub.set_lamda(&FileOperateBaseWorker::doHandleErrorAndWait, + []{ __DBG_STUB_INVOKE__ return AbstractJobHandler::SupportAction::kNoAction;}); + worker.workData->jobFlags |= AbstractJobHandler::JobFlag::kCopyToSelf; + EXPECT_TRUE(worker.checkAndCopyDir(fileInfo, toInfo, &skip)); + + stub.set_lamda(&LocalFileHandler::mkdir, []{ __DBG_STUB_INVOKE__ return true;}); + DirIteratorFactory::instance().constructList.clear(); + DirIteratorFactory::instance().constructAguList.clear(); + EXPECT_FALSE(worker.checkAndCopyDir(fileInfo, fileInfo, &skip)); + + DirIteratorFactory::regClass(Global::Scheme::kFile); + stub.set_lamda(VADDR(LocalDirIterator, hasNext), []{ __DBG_STUB_INVOKE__ return true;}); + worker.stop(); + EXPECT_FALSE(worker.checkAndCopyDir(fileInfo, fileInfo, &skip)); + + worker.resume(); + stub.set_lamda(&FileOperateBaseWorker::doCopyFile, []{ __DBG_STUB_INVOKE__ return false; }); + skip = false; + EXPECT_FALSE(worker.checkAndCopyDir(fileInfo, fileInfo, &skip)); + + int index = 0; + stub.set_lamda(VADDR(LocalDirIterator, hasNext), [&index]{ __DBG_STUB_INVOKE__ index++; return index < 2;}); + skip = true; + stub.set_lamda(&FileUtils::isMtpFile, []{ __DBG_STUB_INVOKE__ return false; }); + EXPECT_TRUE(worker.checkAndCopyDir(fileInfo, fileInfo, &skip)); + + index = 0; + worker.isTargetFileLocal = true; + worker.isSourceFileLocal = true; + EXPECT_TRUE(worker.checkAndCopyDir(fileInfo, fileInfo, &skip)); + + worker.workData->jobFlags |= AbstractJobHandler::JobFlag::kCountProgressCustomize; + worker.initCopyWay(); +} + TEST_F(UT_FileOperateBaseWorker, testTrashInfo) { FileOperateBaseWorker worker; diff --git a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperationsutils.cpp b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperationsutils.cpp index 98aa1463c7..1ddbe2280f 100644 --- a/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperationsutils.cpp +++ b/tests/plugins/common/core/dfmplugin-fileoperations/fileoperations/fileoperations/fileoperationutils/ut_fileoperationsutils.cpp @@ -13,6 +13,7 @@ #include +#include DPFILEOPERATIONS_USE_NAMESPACE DFMBASE_USE_NAMESPACE @@ -44,6 +45,11 @@ TEST_F(UT_FileOperationsUtils, testFileOperationsUtils) EXPECT_TRUE(FileOperationsUtils::isAncestorUrl(url, fileUrl)); EXPECT_TRUE(!FileOperationsUtils::isFileOnDisk(QUrl())); EXPECT_TRUE(FileOperationsUtils::isFileOnDisk(url)); + + stub_ext::StubExt stub; + stub.set_lamda(fts_open, []{ __DBG_STUB_INVOKE__ return nullptr;}); + EXPECT_FALSE(FileOperationsUtils::isFilesSizeOutLimit(fileUrl, 1024)); + EXPECT_TRUE(FileOperationsUtils::statisticsFilesSize({url}, true)->allFiles.isEmpty()); } TEST_F(UT_FileOperationsUtils, testUpdateProgressTimer)