void SessionModel::populate(Session::Type type, const QString &path) {
// read session files
QDir dir(path);
dir.setNameFilters(QStringList() << "*.desktop");
dir.setFilter(QDir::Files);
// read session
foreach(const QString &session, dir.entryList()) {
if (!dir.exists(session))
continue;
Session *si = new Session(type, session);
bool execAllowed = true;
QFileInfo fi(si->tryExec());
if (fi.isAbsolute()) {
if (!fi.exists() || !fi.isExecutable())
execAllowed = false;
} else {
execAllowed = false;
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString envPath = env.value("PATH");
QStringList pathList = envPath.split(':');
foreach(const QString &path, pathList) {
QDir pathDir(path);
fi.setFile(pathDir, si->tryExec());
if (fi.exists() && fi.isExecutable()) {
execAllowed = true;
break;
}
}
}
// add to sessions list
if (execAllowed)
d->sessions.push_back(si);
}
void ProjectPanel::recursiveAddFilesFrom(const TCHAR *folderPath, HTREEITEM hTreeItem)
{
bool isRecursive = true;
bool isInHiddenDir = false;
generic_string dirFilter(folderPath);
if (folderPath[lstrlen(folderPath)-1] != '\\')
dirFilter += TEXT("\\");
dirFilter += TEXT("*.*");
WIN32_FIND_DATA foundData;
std::vector<generic_string> files;
HANDLE hFile = ::FindFirstFile(dirFilter.c_str(), &foundData);
do {
if (hFile == INVALID_HANDLE_VALUE)
break;
if (foundData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!isInHiddenDir && (foundData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
{
// do nothing
}
else if (isRecursive)
{
if ((lstrcmp(foundData.cFileName, TEXT("."))) && (lstrcmp(foundData.cFileName, TEXT(".."))))
{
generic_string pathDir(folderPath);
if (folderPath[lstrlen(folderPath)-1] != '\\')
pathDir += TEXT("\\");
pathDir += foundData.cFileName;
pathDir += TEXT("\\");
HTREEITEM addedItem = addFolder(hTreeItem, foundData.cFileName);
recursiveAddFilesFrom(pathDir.c_str(), addedItem);
}
}
}
else
{
files.push_back(foundData.cFileName);
}
} while (::FindNextFile(hFile, &foundData));
for (size_t i = 0, len = files.size() ; i < len ; ++i)
{
generic_string pathFile(folderPath);
if (folderPath[lstrlen(folderPath)-1] != '\\')
pathFile += TEXT("\\");
pathFile += files[i];
_treeView.addItem(files[i].c_str(), hTreeItem, INDEX_LEAF, pathFile.c_str());
}
::FindClose(hFile);
}
bool ABSHandler::setUpBuildingEnvironment(const QString &package, const QString &p)
{
QString path = p;
if ( !path.endsWith( QChar( '/' ) ) ) {
path.append( QChar( '/' ) );
}
path.append( package );
QDir pathDir( path );
if ( pathDir.exists() ) {
cleanBuildingEnvironment( package, path );
}
if ( !pathDir.mkpath( path ) ) {
return false;
}
QString abspath( getABSPath( package ) );
if ( abspath.isEmpty() ) {
qDebug() << "Couldn't find a matching ABS Dir!!";
return false;
}
QDir absPDir( abspath );
absPDir.setFilter( QDir::Files | QDir::Hidden | QDir::NoDotAndDotDot | QDir::NoSymLinks );
QFileInfoList Plist = absPDir.entryInfoList();
for ( int i = 0; i < Plist.size(); ++i ) {
QString dest( path );
if ( !dest.endsWith( QChar( '/' ) ) )
dest.append( QChar( '/' ) );
dest.append( Plist.at( i ).fileName() );
qDebug() << "Copying " << Plist.at( i ).absoluteFilePath() << " to " << dest;
if ( !QFile::copy( Plist.at( i ).absoluteFilePath(), dest ) ) {
return false;
}
}
return true;
}
// This constructor is for use by HdfsRdwrMemBuffer to create a file buffer when we
// run out of memory.
HdfsRdwrFileBuffer::HdfsRdwrFileBuffer(HdfsRdwrMemBuffer* pMemBuffer) throw (std::exception) :
IDBDataFile(pMemBuffer->name().c_str()),
m_buffer(NULL),
m_dirty(false)
{
// we have been asked to replace memory buffered rw operations with file buffered
// operations on a file that currently exists in HDFS.
// Set up the local directory that we need to write to
string bufname = IDBPolicy::hdfsRdwrScratch() + name();
boost::filesystem::path pathDir(bufname);
// this will create the directory we want to work in
if( IDBPolicy::mkdir(pathDir.parent_path().string().c_str()) != 0 )
{
ostringstream oss;
oss << "MemBuffer overflow. Unable to create directory path: " << pathDir.parent_path();
throw std::runtime_error(oss.str());
}
m_buffer = new BufferedFile( bufname.c_str(), "w+", IDBDataFile::USE_VBUF );
// Dump the contents of the memory buffer into the file
const unsigned char* membuffer = pMemBuffer->getbuffer();
ssize_t bytesToProcess = pMemBuffer->size();
ssize_t bytesProcessed = 0;
while (bytesToProcess > 0)
{
bytesProcessed = m_buffer->write( membuffer, bytesToProcess );
if (bytesProcessed < 0 && errno != EINTR)
{
ostringstream oss;
oss << "MemBuffer overflow. Error while writing: " << pathDir << " " << strerror(errno);
throw std::runtime_error(oss.str());
}
membuffer += bytesProcessed;
bytesToProcess -= bytesProcessed;
}
}
/**
* Determine the file name.
* @param concept the package
* @param ext the file extension
* @return the valid file name
*/
QString SimpleCodeGenerator::findFileName(UMLPackage* concept, const QString &ext)
{
//if we already know to which file this class was written/should be written, just return it.
if (m_fileMap.contains(concept))
return m_fileMap[concept];
//else, determine the "natural" file name
QString name;
// Get the package name
QString package = concept->package(".");
// Replace all white spaces with blanks
package = package.simplified();
// Replace all blanks with underscore
package.replace(QRegExp(" "), "_");
// Convert all "::" to "/" : Platform-specific path separator
// package.replace(QRegExp("::"), "/");
// if package is given add this as a directory to the file name
if (!package.isEmpty() && m_createDirHierarchyForPackages) {
name = package + '.' + concept->name();
name.replace(QRegExp("\\."),"/");
package.replace(QRegExp("\\."), "/");
package = '/' + package;
} else {
name = concept->fullyQualifiedName("-");
}
if (! UMLApp::app()->activeLanguageIsCaseSensitive()) {
package = package.toLower();
name = name.toLower();
}
// if a package name exists check the existence of the package directory
if (!package.isEmpty() && m_createDirHierarchyForPackages) {
QDir pathDir(UMLApp::app()->commonPolicy()->getOutputDirectory().absolutePath() + package);
// does our complete output directory exist yet? if not, try to create it
if (!pathDir.exists())
{
const QStringList dirs = pathDir.absolutePath().split('/');
QString currentDir = "";
QStringList::const_iterator end(dirs.end());
for (QStringList::const_iterator dir(dirs.begin()); dir != end; ++dir)
{
currentDir += '/' + *dir;
if (! (pathDir.exists(currentDir)
|| pathDir.mkdir(currentDir) ) )
{
KMessageBox::error(0, i18n("Cannot create the folder:\n") +
pathDir.absolutePath() + i18n("\nPlease check the access rights"),
i18n("Cannot Create Folder"));
return NULL;
}
}
}
}
name = name.simplified();
name.replace(QRegExp(" "),"_");
QString extension = ext.simplified();
extension.replace(' ', '_');
return overwritableName(concept, name, extension);
}
void FileBrowser::getDirectoryStructure(const TCHAR *dir, const std::vector<generic_string> & patterns, FolderInfo & directoryStructure, bool isRecursive, bool isInHiddenDir)
{
if (directoryStructure._parent == nullptr) // Root!
directoryStructure.setRootPath(dir);
generic_string dirFilter(dir);
if (dirFilter[dirFilter.length() - 1] != '\\')
dirFilter += TEXT("\\");
dirFilter += TEXT("*.*");
WIN32_FIND_DATA foundData;
HANDLE hFile = ::FindFirstFile(dirFilter.c_str(), &foundData);
if (hFile != INVALID_HANDLE_VALUE)
{
if (foundData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!isInHiddenDir && (foundData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
{
// do nothing
}
else if (isRecursive)
{
if ((lstrcmp(foundData.cFileName, TEXT("."))) && (lstrcmp(foundData.cFileName, TEXT(".."))))
{
generic_string pathDir(dir);
if (pathDir[pathDir.length() - 1] != '\\')
pathDir += TEXT("\\");
pathDir += foundData.cFileName;
pathDir += TEXT("\\");
FolderInfo subDirectoryStructure(foundData.cFileName, &directoryStructure);
getDirectoryStructure(pathDir.c_str(), patterns, subDirectoryStructure, isRecursive, isInHiddenDir);
directoryStructure.addSubFolder(subDirectoryStructure);
}
}
}
else
{
if (matchInList(foundData.cFileName, patterns))
{
directoryStructure.addFile(foundData.cFileName);
}
}
}
while (::FindNextFile(hFile, &foundData))
{
if (foundData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!isInHiddenDir && (foundData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
{
// do nothing
}
else if (isRecursive)
{
if ((lstrcmp(foundData.cFileName, TEXT("."))) && (lstrcmp(foundData.cFileName, TEXT(".."))))
{
generic_string pathDir(dir);
if (pathDir[pathDir.length() - 1] != '\\')
pathDir += TEXT("\\");
pathDir += foundData.cFileName;
pathDir += TEXT("\\");
FolderInfo subDirectoryStructure(foundData.cFileName, &directoryStructure);
getDirectoryStructure(pathDir.c_str(), patterns, subDirectoryStructure, isRecursive, isInHiddenDir);
directoryStructure.addSubFolder(subDirectoryStructure);
}
}
}
else
{
if (matchInList(foundData.cFileName, patterns))
{
directoryStructure.addFile(foundData.cFileName);
}
}
}
::FindClose(hFile);
}
bool ItemRepositoryRegistry::open(const QString& path, bool clear, KLockFile::Ptr lock) {
QMutexLocker mlock(&m_mutex);
if(m_path == path && !clear)
return true;
m_lock = lock;
m_path = path;
bool needRepoCheck = true;
while(needRepoCheck) {
if(QFile::exists(m_path + "/is_writing")) {
kWarning() << "repository" << m_path << "was write-locked, it probably is inconsistent";
clear = true;
}
QDir pathDir(m_path);
pathDir.setFilter(QDir::Files);
//When there is only one file in the repository, it's the lock-file, and the repository has just been cleared
if(pathDir.count() != 1)
{
if(!QFile::exists( m_path + QString("/version_%1").arg(staticItemRepositoryVersion()) ))
{
kWarning() << "version-hint not found, seems to be an old version";
clear = true;
}else if(getenv("CLEAR_DUCHAIN_DIR"))
{
kWarning() << "clearing duchain directory because CLEAR_DUCHAIN_DIR is set";
clear = true;
}
}
QFile crashesFile(m_path + QString("/crash_counter"));
if(crashesFile.open(QIODevice::ReadOnly)) {
int count;
QDataStream stream(&crashesFile);
stream >> count;
kDebug() << "current count of crashes: " << count;
if(count >= crashesBeforeCleanup && !getenv("DONT_CLEAR_DUCHAIN_DIR"))
{
int userAnswer = 0;
///NOTE: we don't want to crash our beloved tools when run in no-gui mode
///NOTE 2: create a better, reusable version of the below for other tools
if (QApplication::type() == QApplication::Tty) {
// no ui-mode e.g. for duchainify and other tools
QTextStream out(stdout);
out << i18np("Session crashed %1 time in a row", "Session crashed %1 times in a row", count) << endl;
out << endl;
QTextStream in(stdin);
QString input;
while(true) {
out << i18n("Clear cache: [Y/n] ") << flush;
input = in.readLine().trimmed();
if (input.toLower() == "y" || input.isEmpty()) {
userAnswer = KMessageBox::Yes;
break;
} else if (input.toLower() == "n") {
userAnswer = KMessageBox::No;
break;
}
}
} else {
userAnswer = KMessageBox::questionYesNo(0,
i18np("The Session crashed once.", "The Session crashed %1 times in a row.", count) + "\n\n" + i18n("The crash may be caused by a corruption of cached data.\n\nPress OK if you want KDevelop to clear the cache, otherwise press Cancel if you are sure the crash has another origin."),
i18n("Session crashed"),
KStandardGuiItem::ok(),
KStandardGuiItem::cancel());
}
if (userAnswer == KMessageBox::Yes) {
clear = true;
kDebug() << "User chose to clean repository";
} else {
setCrashCounter(crashesFile, 1);
kDebug() << "User chose to reset crash counter";
}
}else{
///Increase the crash-count. It will be reset if kdevelop is shut down cleanly.
setCrashCounter(crashesFile, ++count);
}
}else{
HdfsRdwrFileBuffer::HdfsRdwrFileBuffer(const char* fname, const char* mode, unsigned opts) :
IDBDataFile(fname),
m_buffer(NULL),
m_dirty(false),
m_new(false)
{
// we have been asked to support rw operations on a file that currently
// exists in HDFS by using a local file buffer.
IDBFileSystem& fs = IDBFactory::getFs( HDFS );
// append an extra tmp extension if USE_TMPFILE extension is set.
string input(fname);
if (opts & USE_TMPFILE)
{
m_fname += ".tmp"; // use .tmp as working copy to replace the ".hdr/chk" backup.
if (IDBPolicy::exists(m_fname.c_str()))
input = m_fname; // get from .tmp if revisit
else
m_new = true;
}
// cache the size first - we will use this to determine if the
// file already exists and needs to be read into the buffer
off64_t size = fs.size(input.c_str());
// first we will try to open the file for writing - if this fails
// it means we can't actually open the file for writing and need
// to throw exception anyway
bool truncate = (mode != NULL && *mode == 'w');
if( size < 0 || truncate)
{
HdfsFile* trywrite = new HdfsFile(input.c_str(), "w", 0);
delete trywrite;
size = 0;
}
// if we get here, then will be ok to write later. First we
// we set up the local directory that we need to write to
string bufname = IDBPolicy::hdfsRdwrScratch() + input;
boost::filesystem::path pathDir(bufname);
// this will create the directory we want to work in
if( IDBPolicy::mkdir(pathDir.parent_path().string().c_str()) != 0 )
{
ostringstream oss;
oss << "Unable to create directory path: " << pathDir.parent_path();
throw std::runtime_error(oss.str());
}
m_buffer = new BufferedFile( bufname.c_str(), "w+", IDBDataFile::USE_VBUF );
// Now we need to
// open one for reading if the file existed previously
if( size > 0 )
{
HdfsFile tryread(input.c_str(), "r", 0);
boost::scoped_array<unsigned char> buffer(new unsigned char[BUFSIZE]);
ssize_t bytesProcessed = 0;
while(bytesProcessed < (ssize_t) size)
{
ssize_t bytesRead = tryread.read( buffer.get(), BUFSIZE );
m_buffer->write( buffer.get(), bytesRead );
bytesProcessed += bytesRead;
}
m_buffer->seek(0,SEEK_SET);
}
else
{
// in this case there is no existing file to read and nothing else to do
;
}
}
void FileSystemController::service(HttpRequest& request, HttpResponse& response)
{
if (!CheckCreditinals(request, response))
{
return;
}
QString method = request.getMethod();
if (method.compare("GET", Qt::CaseInsensitive) == 0)
{
QString currentPath = request.getParameter("currentPath");
currentPath = QUrl::fromPercentEncoding(currentPath.toUtf8());
QtJson::JsonArray respJson;
if (!currentPath.isEmpty())
{
QDir pathDir(currentPath);
if (pathDir.exists())
{
QStringList subdirsList = pathDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
for (int i = 0; i < subdirsList.count(); i++)
{
QtJson::JsonObject dir;
dir["type"] = "dir";
dir["name"] = subdirsList[i];
respJson.append(dir);
}
}
else
{
QtJson::JsonObject errObj;
errObj["type"] = "err";
errObj["msg"] = "Path doesnot exist";
respJson.append(errObj);
}
}
else
{
QList<QStorageInfo> volumes = QStorageInfo::mountedVolumes();
for (int i = 0; i < volumes.count(); i++)
{
QtJson::JsonObject drive;
drive["type"] = "drive";
drive["freeSpace"] = StaticHelpers::toKbMbGb(volumes[i].bytesFree());
drive["size"] = StaticHelpers::toKbMbGb(volumes[i].bytesTotal());
drive["name"] = volumes[i].rootPath();
respJson.append(drive);
}
}
response.setHeader("Content-Type", "application/json");
response.write(QtJson::serialize(respJson));
}
else
{
response.setStatus(405, "Method Not Allowed");
response.write("<BODY><h3>405 Method Not Allowed.</h3>");
response.write("</BODY>");
}
}
// InitTest1
void
SymLinkTest::InitTest1()
{
const char *dirLink = dirLinkname;
const char *dirSuperLink = dirSuperLinkname;
const char *dirRelLink = dirRelLinkname;
const char *fileLink = fileLinkname;
const char *existingDir = existingDirname;
const char *existingSuperDir = existingSuperDirname;
const char *existingRelDir = existingRelDirname;
const char *existingFile = existingFilename;
const char *existingSuperFile = existingSuperFilename;
const char *existingRelFile = existingRelFilename;
const char *nonExisting = nonExistingDirname;
const char *nonExistingSuper = nonExistingSuperDirname;
const char *nonExistingRel = nonExistingRelDirname;
// 1. default constructor
NextSubTest();
{
BSymLink link;
CPPUNIT_ASSERT( link.InitCheck() == B_NO_INIT );
}
// 2. BSymLink(const char*)
NextSubTest();
{
BSymLink link(fileLink);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BSymLink link(nonExisting);
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
NextSubTest();
{
BSymLink link((const char *)NULL);
CPPUNIT_ASSERT( equals(link.InitCheck(), B_BAD_VALUE, B_NO_INIT) );
}
NextSubTest();
{
BSymLink link("");
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
NextSubTest();
{
BSymLink link(existingFile);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BSymLink link(existingDir);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BSymLink link(tooLongEntryname);
CPPUNIT_ASSERT( link.InitCheck() == B_NAME_TOO_LONG );
}
// 3. BSymLink(const BEntry*)
NextSubTest();
{
BEntry entry(dirLink);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
BSymLink link(&entry);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BEntry entry(nonExisting);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
BSymLink link(&entry);
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
NextSubTest();
{
BSymLink link((BEntry *)NULL);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BEntry entry;
BSymLink link(&entry);
CPPUNIT_ASSERT( equals(link.InitCheck(), B_BAD_ADDRESS, B_BAD_VALUE) );
}
NextSubTest();
{
BEntry entry(existingFile);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
BSymLink link(&entry);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BEntry entry(existingDir);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
BSymLink link(&entry);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BEntry entry(tooLongEntryname);
// R5 returns E2BIG instead of B_NAME_TOO_LONG
CPPUNIT_ASSERT( equals(entry.InitCheck(), E2BIG, B_NAME_TOO_LONG) );
BSymLink link(&entry);
CPPUNIT_ASSERT( equals(link.InitCheck(), B_BAD_ADDRESS, B_BAD_VALUE) );
}
// 4. BSymLink(const entry_ref*)
NextSubTest();
{
BEntry entry(dirLink);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
entry_ref ref;
CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
BSymLink link(&ref);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BEntry entry(nonExisting);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
entry_ref ref;
CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
BSymLink link(&ref);
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
NextSubTest();
{
BSymLink link((entry_ref *)NULL);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BEntry entry(existingFile);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
entry_ref ref;
CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
BSymLink link(&ref);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BEntry entry(existingDir);
CPPUNIT_ASSERT( entry.InitCheck() == B_OK );
entry_ref ref;
CPPUNIT_ASSERT( entry.GetRef(&ref) == B_OK );
BSymLink link(&ref);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
// 5. BSymLink(const BDirectory*, const char*)
NextSubTest();
{
BDirectory pathDir(dirSuperLink);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, dirRelLink);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BDirectory pathDir(dirSuperLink);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, dirLink);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BDirectory pathDir(nonExistingSuper);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, nonExistingRel);
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
NextSubTest();
{
BSymLink link((BDirectory *)NULL, (const char *)NULL);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BSymLink link((BDirectory *)NULL, dirLink);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BDirectory pathDir(dirSuperLink);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, (const char *)NULL);
CPPUNIT_ASSERT( link.InitCheck() == B_BAD_VALUE );
}
NextSubTest();
{
BDirectory pathDir(dirSuperLink);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, "");
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BDirectory pathDir(existingSuperFile);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, existingRelFile);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BDirectory pathDir(existingSuperDir);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, existingRelDir);
CPPUNIT_ASSERT( link.InitCheck() == B_OK );
}
NextSubTest();
{
BDirectory pathDir(tooLongSuperEntryname);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, tooLongRelEntryname);
CPPUNIT_ASSERT( link.InitCheck() == B_NAME_TOO_LONG );
}
NextSubTest();
{
BDirectory pathDir(fileSuperDirname);
CPPUNIT_ASSERT( pathDir.InitCheck() == B_OK );
BSymLink link(&pathDir, fileRelDirname);
CPPUNIT_ASSERT( link.InitCheck() == B_ENTRY_NOT_FOUND );
}
}
